OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [sim/] [testsuite/] [sim/] [h8300/] [movl.s] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn 
# Hitachi H8 testcase 'mov.l'
2 
# mach(): h8300h h8300s h8sx
3 
# as(h8300h):   --defsym sim_cpu=1
4 
# as(h8300s):   --defsym sim_cpu=2
5 
# as(h8sx):     --defsym sim_cpu=3
6 
# ld(h8300h):   -m h8300helf
7 
# ld(h8300s):   -m h8300self
8 
# ld(h8sx):     -m h8300sxelf
9 
 
10 
        .include "testutils.inc"
11 
 
12 
        start
13 
 
14 
        .data
15 
        .align  4
16 
long_src:
17 
        .long   0x77777777
18 
long_dst:
19 
        .long   0
20 
 
21 
        .text
22 
 
23 
        ;;
24 
        ;; Move long from immediate source
25 
        ;;
26 
 
27 
.if (sim_cpu == h8sx)
28 
mov_l_imm3_to_reg32:
29 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
30 
        set_ccr_zero
31 
 
32 
        ;; mov.l #xx:3, erd
33 
        mov.l   #0x3:3, er0     ; Immediate 3-bit operand
34 
;;;     .word   0x0fb8
35 
 
36 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
37 
        test_neg_clear
38 
        test_zero_clear
39 
        test_ovf_clear
40 
        test_carry_clear
41 
 
42 
        test_h_gr32 0x3 er0
43 
 
44 
        test_gr_a5a5 1          ; Make sure other general regs not disturbed
45 
        test_gr_a5a5 2
46 
        test_gr_a5a5 3
47 
        test_gr_a5a5 4
48 
        test_gr_a5a5 5
49 
        test_gr_a5a5 6
50 
        test_gr_a5a5 7
51 
 
52 
mov_l_imm16_to_reg32:
53 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
54 
        set_ccr_zero
55 
 
56 
        ;; mov.l #xx:16, erd
57 
        mov.l   #0x1234, er0    ; Immediate 16-bit operand
58 
;;;     .word   0x7a08
59 
;;;     .word   0x1234
60 
 
61 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
62 
        test_neg_clear
63 
        test_zero_clear
64 
        test_ovf_clear
65 
        test_carry_clear
66 
 
67 
        test_h_gr32 0x1234 er0
68 
 
69 
        test_gr_a5a5 1          ; Make sure other general regs not disturbed
70 
        test_gr_a5a5 2
71 
        test_gr_a5a5 3
72 
        test_gr_a5a5 4
73 
        test_gr_a5a5 5
74 
        test_gr_a5a5 6
75 
        test_gr_a5a5 7
76 
.endif
77 
 
78 
mov_l_imm32_to_reg32:
79 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
80 
        set_ccr_zero
81 
 
82 
        ;; mov.l #xx:32, erd
83 
        mov.l   #0x12345678, er0        ; Immediate 32-bit operand
84 
;;;     .word   0x7a00
85 
;;;     .long   0x12345678
86 
 
87 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
88 
        test_neg_clear
89 
        test_zero_clear
90 
        test_ovf_clear
91 
        test_carry_clear
92 
 
93 
        test_h_gr32 0x12345678 er0
94 
 
95 
        test_gr_a5a5 1          ; Make sure other general regs not disturbed
96 
        test_gr_a5a5 2
97 
        test_gr_a5a5 3
98 
        test_gr_a5a5 4
99 
        test_gr_a5a5 5
100 
        test_gr_a5a5 6
101 
        test_gr_a5a5 7
102 
 
103 
.if (sim_cpu == h8sx)
104 
mov_l_imm8_to_indirect:
105 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
106 
        set_ccr_zero
107 
 
108 
        ;; mov.l #xx:8, @erd
109 
        mov.l   #long_dst, er1
110 
        mov.l   #0xa5:8, @er1   ; Register indirect operand
111 
;;;     .word   0x010d
112 
;;;     .word   0x01a5
113 
 
114 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
115 
        test_neg_clear
116 
        test_zero_clear
117 
        test_ovf_clear
118 
        test_carry_clear
119 
 
120 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
121 
        test_h_gr32     long_dst, er1
122 
        test_gr_a5a5 2
123 
        test_gr_a5a5 3
124 
        test_gr_a5a5 4
125 
        test_gr_a5a5 5
126 
        test_gr_a5a5 6
127 
        test_gr_a5a5 7
128 
 
129 
        ;; Now check the result of the move to memory.
130 
        cmp.l   #0xa5, @long_dst
131 
        beq     .Lnext1
132 
        fail
133 
.Lnext1:
134 
        mov.l   #0, @long_dst    ; zero it again for the next use.
135 
 
136 
mov_l_imm8_to_postinc:          ; post-increment from imm8 to mem
137 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
138 
        set_ccr_zero
139 
 
140 
        ;; mov.l #xx:8, @erd+
141 
        mov.l   #long_dst, er1
142 
        mov.l   #0xa5:8, @er1+  ; Imm8, register post-incr operands.
143 
;;;     .word   0x010d
144 
;;;     .word   0x81a5
145 
 
146 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
147 
        test_neg_clear
148 
        test_zero_clear
149 
        test_ovf_clear
150 
        test_carry_clear
151 
 
152 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
153 
        test_h_gr32     long_dst+4, er1
154 
        test_gr_a5a5 2
155 
        test_gr_a5a5 3
156 
        test_gr_a5a5 4
157 
        test_gr_a5a5 5
158 
        test_gr_a5a5 6
159 
        test_gr_a5a5 7
160 
 
161 
        ;; Now check the result of the move to memory.
162 
        cmp.l   #0xa5, @long_dst
163 
        beq     .Lnext2
164 
        fail
165 
.Lnext2:
166 
        mov.l   #0, @long_dst    ; zero it again for the next use.
167 
 
168 
mov_l_imm8_to_postdec:          ; post-decrement from imm8 to mem
169 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
170 
        set_ccr_zero
171 
 
172 
        ;; mov.l #xx:8, @erd-
173 
        mov.l   #long_dst, er1
174 
        mov.l   #0xa5:8, @er1-  ; Imm8, register post-decr operands.
175 
;;;     .word   0x010d
176 
;;;     .word   0xa1a5
177 
 
178 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
179 
        test_neg_clear
180 
        test_zero_clear
181 
        test_ovf_clear
182 
        test_carry_clear
183 
 
184 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
185 
        test_h_gr32     long_dst-4, er1
186 
        test_gr_a5a5 2
187 
        test_gr_a5a5 3
188 
        test_gr_a5a5 4
189 
        test_gr_a5a5 5
190 
        test_gr_a5a5 6
191 
        test_gr_a5a5 7
192 
 
193 
        ;; Now check the result of the move to memory.
194 
        cmp.l   #0xa5, @long_dst
195 
        beq     .Lnext3
196 
        fail
197 
.Lnext3:
198 
        mov.l   #0, @long_dst    ; zero it again for the next use.
199 
 
200 
mov_l_imm8_to_preinc:           ; pre-increment from register to mem
201 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
202 
        set_ccr_zero
203 
 
204 
        ;; mov.l #xx:8, @+erd
205 
        mov.l   #long_dst-4, er1
206 
        mov.l   #0xa5:8, @+er1  ; Imm8, register pre-incr operands
207 
;;;     .word   0x010d
208 
;;;     .word   0x91a5
209 
 
210 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
211 
        test_neg_clear
212 
        test_zero_clear
213 
        test_ovf_clear
214 
        test_carry_clear
215 
 
216 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
217 
        test_h_gr32     long_dst, er1
218 
        test_gr_a5a5 2
219 
        test_gr_a5a5 3
220 
        test_gr_a5a5 4
221 
        test_gr_a5a5 5
222 
        test_gr_a5a5 6
223 
        test_gr_a5a5 7
224 
 
225 
        ;; Now check the result of the move to memory.
226 
        cmp.l   #0xa5, @long_dst
227 
        beq     .Lnext4
228 
        fail
229 
.Lnext4:
230 
        mov.l   #0, @long_dst    ; zero it again for the next use.
231 
 
232 
mov_l_imm8_to_predec:           ; pre-decrement from register to mem
233 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
234 
        set_ccr_zero
235 
 
236 
        ;; mov.l #xx:8, @-erd
237 
        mov.l   #long_dst+4, er1
238 
        mov.l   #0xa5:8, @-er1  ; Imm8, register pre-decr operands
239 
;;;     .word   0x010d
240 
;;;     .word   0xb1a5
241 
 
242 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
243 
        test_neg_clear
244 
        test_zero_clear
245 
        test_ovf_clear
246 
        test_carry_clear
247 
 
248 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
249 
        test_h_gr32     long_dst, er1
250 
        test_gr_a5a5 2
251 
        test_gr_a5a5 3
252 
        test_gr_a5a5 4
253 
        test_gr_a5a5 5
254 
        test_gr_a5a5 6
255 
        test_gr_a5a5 7
256 
 
257 
        ;; Now check the result of the move to memory.
258 
        cmp.l   #0xa5, @long_dst
259 
        beq     .Lnext5
260 
        fail
261 
.Lnext5:
262 
        mov.l   #0, @long_dst    ; zero it again for the next use.
263 
 
264 
mov_l_imm8_to_disp2:
265 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
266 
        set_ccr_zero
267 
 
268 
        ;; mov.l #xx:8, @(dd:2, erd)
269 
        mov.l   #long_dst-12, er1
270 
        mov.l   #0xa5:8, @(12:2, er1)   ; Imm8, reg plus 2-bit disp. operand
271 
;;;     .word   0x010d
272 
;;;     .word   0x31a5
273 
 
274 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
275 
        test_neg_clear
276 
        test_zero_clear
277 
        test_ovf_clear
278 
        test_carry_clear
279 
 
280 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
281 
        test_h_gr32     long_dst-12, er1
282 
        test_gr_a5a5 2
283 
        test_gr_a5a5 3
284 
        test_gr_a5a5 4
285 
        test_gr_a5a5 5
286 
        test_gr_a5a5 6
287 
        test_gr_a5a5 7
288 
 
289 
        ;; Now check the result of the move to memory.
290 
        cmp.l   #0xa5, @long_dst
291 
        beq     .Lnext6
292 
        fail
293 
.Lnext6:
294 
        mov.l   #0, @long_dst    ; zero it again for the next use.
295 
 
296 
mov_l_imm8_to_disp16:
297 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
298 
        set_ccr_zero
299 
 
300 
        ;; mov.l #xx:8, @(dd:16, erd)
301 
        mov.l   #long_dst-4, er1
302 
        mov.l   #0xa5:8, @(4:16, er1)   ; Register plus 16-bit disp. operand
303 
;;;     .word   0x010d
304 
;;;     .word   0x6f90
305 
;;;     .word   0x0004
306 
 
307 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
308 
        test_neg_clear
309 
        test_zero_clear
310 
        test_ovf_clear
311 
        test_carry_clear
312 
 
313 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
314 
        test_h_gr32     long_dst-4, er1
315 
        test_gr_a5a5 2
316 
        test_gr_a5a5 3
317 
        test_gr_a5a5 4
318 
        test_gr_a5a5 5
319 
        test_gr_a5a5 6
320 
        test_gr_a5a5 7
321 
 
322 
        ;; Now check the result of the move to memory.
323 
        cmp.l   #0xa5, @long_dst
324 
        beq     .Lnext7
325 
        fail
326 
.Lnext7:
327 
        mov.l   #0, @long_dst    ; zero it again for the next use.
328 
 
329 
mov_l_imm8_to_disp32:
330 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
331 
        set_ccr_zero
332 
 
333 
        ;; mov.l #xx:8, @(dd:32, erd)
334 
        mov.l   #long_dst-8, er1
335 
        mov.l   #0xa5:8, @(8:32, er1)   ; Register plus 32-bit disp. operand
336 
;;;     .word   0x010d
337 
;;;     .word   0xc9a5
338 
;;;     .long   8
339 
 
340 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
341 
        test_neg_clear
342 
        test_zero_clear
343 
        test_ovf_clear
344 
        test_carry_clear
345 
 
346 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
347 
        test_h_gr32     long_dst-8, er1
348 
        test_gr_a5a5 2
349 
        test_gr_a5a5 3
350 
        test_gr_a5a5 4
351 
        test_gr_a5a5 5
352 
        test_gr_a5a5 6
353 
        test_gr_a5a5 7
354 
 
355 
        ;; Now check the result of the move to memory.
356 
        cmp.l   #0xa5, @long_dst
357 
        beq     .Lnext8
358 
        fail
359 
.Lnext8:
360 
        mov.l   #0, @long_dst    ; zero it again for the next use.
361 
 
362 
mov_l_imm8_to_abs16:
363 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
364 
        set_ccr_zero
365 
 
366 
        ;; mov.l #xx:8, @aa:16
367 
        mov.l   #0xa5:8, @long_dst:16   ; 16-bit address-direct operand
368 
;;;     .word   0x010d
369 
;;;     .word   0x40a5
370 
;;;     .word   @long_dst
371 
 
372 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
373 
        test_neg_clear
374 
        test_zero_clear
375 
        test_ovf_clear
376 
        test_carry_clear
377 
 
378 
        test_gr_a5a5 0           ; Make sure _ALL_ general regs not disturbed
379 
        test_gr_a5a5 1          ; (first, because on h8/300 we must use one
380 
        test_gr_a5a5 2          ; to examine the destination memory).
381 
        test_gr_a5a5 3
382 
        test_gr_a5a5 4
383 
        test_gr_a5a5 5
384 
        test_gr_a5a5 6
385 
        test_gr_a5a5 7
386 
 
387 
        ;; Now check the result of the move to memory.
388 
        cmp.l   #0xa5, @long_dst
389 
        beq     .Lnext9
390 
        fail
391 
.Lnext9:
392 
        mov.l   #0, @long_dst    ; zero it again for the next use.
393 
 
394 
mov_l_imm8_to_abs32:
395 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
396 
        set_ccr_zero
397 
 
398 
        ;; mov.l #xx:8, @aa:32
399 
        mov.l   #0xa5:8, @long_dst:32   ; 32-bit address-direct operand
400 
;;;     .word   0x010d
401 
;;;     .word   0x48a5
402 
;;;     .long   @long_dst
403 
 
404 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
405 
        test_neg_clear
406 
        test_zero_clear
407 
        test_ovf_clear
408 
        test_carry_clear
409 
 
410 
        test_gr_a5a5 0           ; Make sure _ALL_ general regs not disturbed
411 
        test_gr_a5a5 1          ; (first, because on h8/300 we must use one
412 
        test_gr_a5a5 2          ; to examine the destination memory).
413 
        test_gr_a5a5 3
414 
        test_gr_a5a5 4
415 
        test_gr_a5a5 5
416 
        test_gr_a5a5 6
417 
        test_gr_a5a5 7
418 
 
419 
        ;; Now check the result of the move to memory.
420 
        cmp.l   #0xa5, @long_dst
421 
        beq     .Lnext10
422 
        fail
423 
.Lnext10:
424 
        mov.l   #0, @long_dst    ; zero it again for the next use.
425 
 
426 
mov_l_imm16_to_indirect:
427 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
428 
        set_ccr_zero
429 
 
430 
        ;; mov.l #xx:16, @erd
431 
        mov.l   #long_dst, er1
432 
        mov.l   #0xdead:16, @er1        ; Register indirect operand
433 
;;;     .word   0x7a7c
434 
;;;     .word   0xdead
435 
;;;     .word   0x0100
436 
 
437 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
438 
        test_neg_clear
439 
        test_zero_clear
440 
        test_ovf_clear
441 
        test_carry_clear
442 
 
443 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
444 
        test_h_gr32     long_dst, er1
445 
        test_gr_a5a5 2
446 
        test_gr_a5a5 3
447 
        test_gr_a5a5 4
448 
        test_gr_a5a5 5
449 
        test_gr_a5a5 6
450 
        test_gr_a5a5 7
451 
 
452 
        ;; Now check the result of the move to memory.
453 
        cmp.l   #0xdead, @long_dst
454 
        beq     .Lnext11
455 
        fail
456 
.Lnext11:
457 
        mov.l   #0, @long_dst    ; zero it again for the next use.
458 
 
459 
mov_l_imm16_to_postinc:         ; post-increment from imm16 to mem
460 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
461 
        set_ccr_zero
462 
 
463 
        ;; mov.l #xx:16, @erd+
464 
        mov.l   #long_dst, er1
465 
        mov.l   #0xdead:16, @er1+       ; Imm16, register post-incr operands.
466 
;;;     .word   0x7a7c
467 
;;;     .word   0xdead
468 
;;;     .word   0x8100
469 
 
470 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
471 
        test_neg_clear
472 
        test_zero_clear
473 
        test_ovf_clear
474 
        test_carry_clear
475 
 
476 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
477 
        test_h_gr32     long_dst+4, er1
478 
        test_gr_a5a5 2
479 
        test_gr_a5a5 3
480 
        test_gr_a5a5 4
481 
        test_gr_a5a5 5
482 
        test_gr_a5a5 6
483 
        test_gr_a5a5 7
484 
 
485 
        ;; Now check the result of the move to memory.
486 
        cmp.l   #0xdead, @long_dst
487 
        beq     .Lnext12
488 
        fail
489 
.Lnext12:
490 
        mov.l   #0, @long_dst    ; zero it again for the next use.
491 
 
492 
mov_l_imm16_to_postdec:         ; post-decrement from imm16 to mem
493 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
494 
        set_ccr_zero
495 
 
496 
        ;; mov.l #xx:16, @erd-
497 
        mov.l   #long_dst, er1
498 
        mov.l   #0xdead:16, @er1-       ; Imm16, register post-decr operands.
499 
;;;     .word   0x7a7c
500 
;;;     .word   0xdead
501 
;;;     .word   0xa100
502 
 
503 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
504 
        test_neg_clear
505 
        test_zero_clear
506 
        test_ovf_clear
507 
        test_carry_clear
508 
 
509 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
510 
        test_h_gr32     long_dst-4, er1
511 
        test_gr_a5a5 2
512 
        test_gr_a5a5 3
513 
        test_gr_a5a5 4
514 
        test_gr_a5a5 5
515 
        test_gr_a5a5 6
516 
        test_gr_a5a5 7
517 
 
518 
        ;; Now check the result of the move to memory.
519 
        cmp.l   #0xdead, @long_dst
520 
        beq     .Lnext13
521 
        fail
522 
.Lnext13:
523 
        mov.l   #0, @long_dst    ; zero it again for the next use.
524 
 
525 
mov_l_imm16_to_preinc:          ; pre-increment from register to mem
526 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
527 
        set_ccr_zero
528 
 
529 
        ;; mov.l #xx:16, @+erd
530 
        mov.l   #long_dst-4, er1
531 
        mov.l   #0xdead:16, @+er1       ; Imm16, register pre-incr operands
532 
;;;     .word   0x7a7c
533 
;;;     .word   0xdead
534 
;;;     .word   0x9100
535 
 
536 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
537 
        test_neg_clear
538 
        test_zero_clear
539 
        test_ovf_clear
540 
        test_carry_clear
541 
 
542 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
543 
        test_h_gr32     long_dst, er1
544 
        test_gr_a5a5 2
545 
        test_gr_a5a5 3
546 
        test_gr_a5a5 4
547 
        test_gr_a5a5 5
548 
        test_gr_a5a5 6
549 
        test_gr_a5a5 7
550 
 
551 
        ;; Now check the result of the move to memory.
552 
        cmp.l   #0xdead, @long_dst
553 
        beq     .Lnext14
554 
        fail
555 
.Lnext14:
556 
        mov.l   #0, @long_dst    ; zero it again for the next use.
557 
 
558 
mov_l_imm16_to_predec:          ; pre-decrement from register to mem
559 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
560 
        set_ccr_zero
561 
 
562 
        ;; mov.l #xx:16, @-erd
563 
        mov.l   #long_dst+4, er1
564 
        mov.l   #0xdead:16, @-er1       ; Imm16, register pre-decr operands
565 
;;;     .word   0x7a7c
566 
;;;     .word   0xdead
567 
;;;     .word   0xb100
568 
 
569 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
570 
        test_neg_clear
571 
        test_zero_clear
572 
        test_ovf_clear
573 
        test_carry_clear
574 
 
575 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
576 
        test_h_gr32     long_dst, er1
577 
        test_gr_a5a5 2
578 
        test_gr_a5a5 3
579 
        test_gr_a5a5 4
580 
        test_gr_a5a5 5
581 
        test_gr_a5a5 6
582 
        test_gr_a5a5 7
583 
 
584 
        ;; Now check the result of the move to memory.
585 
        cmp.l   #0xdead, @long_dst
586 
        beq     .Lnext15
587 
        fail
588 
.Lnext15:
589 
        mov.l   #0, @long_dst    ; zero it again for the next use.
590 
 
591 
mov_l_imm16_to_disp2:
592 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
593 
        set_ccr_zero
594 
 
595 
        ;; mov.l #xx:16, @(dd:2, erd)
596 
        mov.l   #long_dst-12, er1
597 
        mov.l   #0xdead:16, @(12:2, er1)        ; Imm16, reg plus 2-bit disp. operand
598 
;;;     .word   0x7a7c
599 
;;;     .word   0xdead
600 
;;;     .word   0x3100
601 
 
602 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
603 
        test_neg_clear
604 
        test_zero_clear
605 
        test_ovf_clear
606 
        test_carry_clear
607 
 
608 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
609 
        test_h_gr32     long_dst-12, er1
610 
        test_gr_a5a5 2
611 
        test_gr_a5a5 3
612 
        test_gr_a5a5 4
613 
        test_gr_a5a5 5
614 
        test_gr_a5a5 6
615 
        test_gr_a5a5 7
616 
 
617 
        ;; Now check the result of the move to memory.
618 
        cmp.l   #0xdead, @long_dst
619 
        beq     .Lnext16
620 
        fail
621 
.Lnext16:
622 
        mov.l   #0, @long_dst    ; zero it again for the next use.
623 
 
624 
mov_l_imm16_to_disp16:
625 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
626 
        set_ccr_zero
627 
 
628 
        ;; mov.l #xx:16, @(dd:16, erd)
629 
        mov.l   #long_dst-4, er1
630 
        mov.l   #0xdead:16, @(4:16, er1)        ; Register plus 16-bit disp. operand
631 
;;;     .word   0x7a7c
632 
;;;     .word   0xdead
633 
;;;     .word   0xc100
634 
;;;     .word   0x0004
635 
 
636 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
637 
        test_neg_clear
638 
        test_zero_clear
639 
        test_ovf_clear
640 
        test_carry_clear
641 
 
642 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
643 
        test_h_gr32     long_dst-4, er1
644 
        test_gr_a5a5 2
645 
        test_gr_a5a5 3
646 
        test_gr_a5a5 4
647 
        test_gr_a5a5 5
648 
        test_gr_a5a5 6
649 
        test_gr_a5a5 7
650 
 
651 
        ;; Now check the result of the move to memory.
652 
        cmp.l   #0xdead, @long_dst
653 
        beq     .Lnext17
654 
        fail
655 
.Lnext17:
656 
        mov.l   #0, @long_dst    ; zero it again for the next use.
657 
 
658 
mov_l_imm16_to_disp32:
659 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
660 
        set_ccr_zero
661 
 
662 
        ;; mov.l #xx:16, @(dd:32, erd)
663 
        mov.l   #long_dst-8, er1
664 
        mov.l   #0xdead:16, @(8:32, er1)   ; Register plus 32-bit disp. operand
665 
;;;     .word   0x7a7c
666 
;;;     .word   0xdead
667 
;;;     .word   0xc900
668 
;;;     .long   8
669 
 
670 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
671 
        test_neg_clear
672 
        test_zero_clear
673 
        test_ovf_clear
674 
        test_carry_clear
675 
 
676 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
677 
        test_h_gr32     long_dst-8, er1
678 
        test_gr_a5a5 2
679 
        test_gr_a5a5 3
680 
        test_gr_a5a5 4
681 
        test_gr_a5a5 5
682 
        test_gr_a5a5 6
683 
        test_gr_a5a5 7
684 
 
685 
        ;; Now check the result of the move to memory.
686 
        cmp.l   #0xdead, @long_dst
687 
        beq     .Lnext18
688 
        fail
689 
.Lnext18:
690 
        mov.l   #0, @long_dst    ; zero it again for the next use.
691 
 
692 
mov_l_imm16_to_abs16:
693 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
694 
        set_ccr_zero
695 
 
696 
        ;; mov.l #xx:16, @aa:16
697 
        mov.l   #0xdead:16, @long_dst:16        ; 16-bit address-direct operand
698 
;;;     .word   0x7a7c
699 
;;;     .word   0xdead
700 
;;;     .word   0x4000
701 
;;;     .word   @long_dst
702 
 
703 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
704 
        test_neg_clear
705 
        test_zero_clear
706 
        test_ovf_clear
707 
        test_carry_clear
708 
 
709 
        test_gr_a5a5 0           ; Make sure _ALL_ general regs not disturbed
710 
        test_gr_a5a5 1          ; (first, because on h8/300 we must use one
711 
        test_gr_a5a5 2          ; to examine the destination memory).
712 
        test_gr_a5a5 3
713 
        test_gr_a5a5 4
714 
        test_gr_a5a5 5
715 
        test_gr_a5a5 6
716 
        test_gr_a5a5 7
717 
 
718 
        ;; Now check the result of the move to memory.
719 
        cmp.l   #0xdead, @long_dst
720 
        beq     .Lnext19
721 
        fail
722 
.Lnext19:
723 
        mov.l   #0, @long_dst    ; zero it again for the next use.
724 
 
725 
mov_l_imm16_to_abs32:
726 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
727 
        set_ccr_zero
728 
 
729 
        ;; mov.l #xx:16, @aa:32
730 
        mov.l   #0xdead:16, @long_dst:32        ; 32-bit address-direct operand
731 
;;;     .word   0x7a7c
732 
;;;     .word   0xdead
733 
;;;     .word   0x4800
734 
;;;     .long   @long_dst
735 
 
736 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
737 
        test_neg_clear
738 
        test_zero_clear
739 
        test_ovf_clear
740 
        test_carry_clear
741 
 
742 
        test_gr_a5a5 0           ; Make sure _ALL_ general regs not disturbed
743 
        test_gr_a5a5 1          ; (first, because on h8/300 we must use one
744 
        test_gr_a5a5 2          ; to examine the destination memory).
745 
        test_gr_a5a5 3
746 
        test_gr_a5a5 4
747 
        test_gr_a5a5 5
748 
        test_gr_a5a5 6
749 
        test_gr_a5a5 7
750 
 
751 
        ;; Now check the result of the move to memory.
752 
        cmp.l   #0xdead, @long_dst
753 
        beq     .Lnext20
754 
        fail
755 
.Lnext20:
756 
        mov.l   #0, @long_dst    ; zero it again for the next use.
757 
 
758 
mov_l_imm32_to_indirect:
759 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
760 
        set_ccr_zero
761 
 
762 
        ;; mov.l #xx:32, @erd
763 
        mov.l   #long_dst, er1
764 
        mov.l   #0xcafedead:32, @er1    ; Register indirect operand
765 
;;;     .word   0x7a74
766 
;;;     .long   0xcafedead
767 
;;;     .word   0x0100
768 
 
769 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
770 
        test_neg_set
771 
        test_zero_clear
772 
        test_ovf_clear
773 
        test_carry_clear
774 
 
775 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
776 
        test_h_gr32     long_dst, er1
777 
        test_gr_a5a5 2
778 
        test_gr_a5a5 3
779 
        test_gr_a5a5 4
780 
        test_gr_a5a5 5
781 
        test_gr_a5a5 6
782 
        test_gr_a5a5 7
783 
 
784 
        ;; Now check the result of the move to memory.
785 
        cmp.l   #0xcafedead, @long_dst
786 
        beq     .Lnext21
787 
        fail
788 
.Lnext21:
789 
        mov.l   #0, @long_dst    ; zero it again for the next use.
790 
 
791 
mov_l_imm32_to_postinc:         ; post-increment from imm32 to mem
792 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
793 
        set_ccr_zero
794 
 
795 
        ;; mov.l #xx:32, @erd+
796 
        mov.l   #long_dst, er1
797 
        mov.l   #0xcafedead:32, @er1+   ; Imm32, register post-incr operands.
798 
;;;     .word   0x7a74
799 
;;;     .long   0xcafedead
800 
;;;     .word   0x8100
801 
 
802 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
803 
        test_neg_set
804 
        test_zero_clear
805 
        test_ovf_clear
806 
        test_carry_clear
807 
 
808 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
809 
        test_h_gr32     long_dst+4, er1
810 
        test_gr_a5a5 2
811 
        test_gr_a5a5 3
812 
        test_gr_a5a5 4
813 
        test_gr_a5a5 5
814 
        test_gr_a5a5 6
815 
        test_gr_a5a5 7
816 
 
817 
        ;; Now check the result of the move to memory.
818 
        cmp.l   #0xcafedead, @long_dst
819 
        beq     .Lnext22
820 
        fail
821 
.Lnext22:
822 
        mov.l   #0, @long_dst    ; zero it again for the next use.
823 
 
824 
mov_l_imm32_to_postdec:         ; post-decrement from imm32 to mem
825 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
826 
        set_ccr_zero
827 
 
828 
        ;; mov.l #xx:32, @erd-
829 
        mov.l   #long_dst, er1
830 
        mov.l   #0xcafedead:32, @er1-   ; Imm32, register post-decr operands.
831 
;;;     .word   0x7a74
832 
;;;     .long   0xcafedead
833 
;;;     .word   0xa100
834 
 
835 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
836 
        test_neg_set
837 
        test_zero_clear
838 
        test_ovf_clear
839 
        test_carry_clear
840 
 
841 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
842 
        test_h_gr32     long_dst-4, er1
843 
        test_gr_a5a5 2
844 
        test_gr_a5a5 3
845 
        test_gr_a5a5 4
846 
        test_gr_a5a5 5
847 
        test_gr_a5a5 6
848 
        test_gr_a5a5 7
849 
 
850 
        ;; Now check the result of the move to memory.
851 
        cmp.l   #0xcafedead, @long_dst
852 
        beq     .Lnext23
853 
        fail
854 
.Lnext23:
855 
        mov.l   #0, @long_dst    ; zero it again for the next use.
856 
 
857 
mov_l_imm32_to_preinc:          ; pre-increment from register to mem
858 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
859 
        set_ccr_zero
860 
 
861 
        ;; mov.l #xx:32, @+erd
862 
        mov.l   #long_dst-4, er1
863 
        mov.l   #0xcafedead:32, @+er1   ; Imm32, register pre-incr operands
864 
;;;     .word   0x7a74
865 
;;;     .long   0xcafedead
866 
;;;     .word   0x9100
867 
 
868 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
869 
        test_neg_set
870 
        test_zero_clear
871 
        test_ovf_clear
872 
        test_carry_clear
873 
 
874 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
875 
        test_h_gr32     long_dst, er1
876 
        test_gr_a5a5 2
877 
        test_gr_a5a5 3
878 
        test_gr_a5a5 4
879 
        test_gr_a5a5 5
880 
        test_gr_a5a5 6
881 
        test_gr_a5a5 7
882 
 
883 
        ;; Now check the result of the move to memory.
884 
        cmp.l   #0xcafedead, @long_dst
885 
        beq     .Lnext24
886 
        fail
887 
.Lnext24:
888 
        mov.l   #0, @long_dst    ; zero it again for the next use.
889 
 
890 
mov_l_imm32_to_predec:          ; pre-decrement from register to mem
891 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
892 
        set_ccr_zero
893 
 
894 
        ;; mov.l #xx:32, @-erd
895 
        mov.l   #long_dst+4, er1
896 
        mov.l   #0xcafedead:32, @-er1   ; Imm32, register pre-decr operands
897 
;;;     .word   0x7a74
898 
;;;     .long   0xcafedead
899 
;;;     .word   0xb100
900 
 
901 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
902 
        test_neg_set
903 
        test_zero_clear
904 
        test_ovf_clear
905 
        test_carry_clear
906 
 
907 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
908 
        test_h_gr32     long_dst, er1
909 
        test_gr_a5a5 2
910 
        test_gr_a5a5 3
911 
        test_gr_a5a5 4
912 
        test_gr_a5a5 5
913 
        test_gr_a5a5 6
914 
        test_gr_a5a5 7
915 
 
916 
        ;; Now check the result of the move to memory.
917 
        cmp.l   #0xcafedead, @long_dst
918 
        beq     .Lnext25
919 
        fail
920 
.Lnext25:
921 
        mov.l   #0, @long_dst    ; zero it again for the next use.
922 
 
923 
mov_l_imm32_to_disp2:
924 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
925 
        set_ccr_zero
926 
 
927 
        ;; mov.l #xx:32, @(dd:2, erd)
928 
        mov.l   #long_dst-12, er1
929 
        mov.l   #0xcafedead:32, @(12:2, er1)    ; Imm32, reg plus 2-bit disp. operand
930 
;;;     .word   0x7a74
931 
;;;     .long   0xcafedead
932 
;;;     .word   0x3100
933 
 
934 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
935 
        test_neg_set
936 
        test_zero_clear
937 
        test_ovf_clear
938 
        test_carry_clear
939 
 
940 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
941 
        test_h_gr32     long_dst-12, er1
942 
        test_gr_a5a5 2
943 
        test_gr_a5a5 3
944 
        test_gr_a5a5 4
945 
        test_gr_a5a5 5
946 
        test_gr_a5a5 6
947 
        test_gr_a5a5 7
948 
 
949 
        ;; Now check the result of the move to memory.
950 
        cmp.l   #0xcafedead, @long_dst
951 
        beq     .Lnext26
952 
        fail
953 
.Lnext26:
954 
        mov.l   #0, @long_dst    ; zero it again for the next use.
955 
 
956 
mov_l_imm32_to_disp16:
957 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
958 
        set_ccr_zero
959 
 
960 
        ;; mov.l #xx:32, @(dd:16, erd)
961 
        mov.l   #long_dst-4, er1
962 
        mov.l   #0xcafedead:32, @(4:16, er1)    ; Register plus 16-bit disp. operand
963 
;;;     .word   0x7a74
964 
;;;     .long   0xcafedead
965 
;;;     .word   0xc100
966 
;;;     .word   0x0004
967 
 
968 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
969 
        test_neg_set
970 
        test_zero_clear
971 
        test_ovf_clear
972 
        test_carry_clear
973 
 
974 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
975 
        test_h_gr32     long_dst-4, er1
976 
        test_gr_a5a5 2
977 
        test_gr_a5a5 3
978 
        test_gr_a5a5 4
979 
        test_gr_a5a5 5
980 
        test_gr_a5a5 6
981 
        test_gr_a5a5 7
982 
 
983 
        ;; Now check the result of the move to memory.
984 
        cmp.l   #0xcafedead, @long_dst
985 
        beq     .Lnext27
986 
        fail
987 
.Lnext27:
988 
        mov.l   #0, @long_dst    ; zero it again for the next use.
989 
 
990 
mov_l_imm32_to_disp32:
991 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
992 
        set_ccr_zero
993 
 
994 
        ;; mov.l #xx:32, @(dd:32, erd)
995 
        mov.l   #long_dst-8, er1
996 
        mov.l   #0xcafedead:32, @(8:32, er1)   ; Register plus 32-bit disp. operand
997 
;;;     .word   0x7a74
998 
;;;     .long   0xcafedead
999 
;;;     .word   0xc900
1000 
;;;     .long   8
1001 
 
1002 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1003 
        test_neg_set
1004 
        test_zero_clear
1005 
        test_ovf_clear
1006 
        test_carry_clear
1007 
 
1008 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
1009 
        test_h_gr32     long_dst-8, er1
1010 
        test_gr_a5a5 2
1011 
        test_gr_a5a5 3
1012 
        test_gr_a5a5 4
1013 
        test_gr_a5a5 5
1014 
        test_gr_a5a5 6
1015 
        test_gr_a5a5 7
1016 
 
1017 
        ;; Now check the result of the move to memory.
1018 
        cmp.l   #0xcafedead, @long_dst
1019 
        beq     .Lnext28
1020 
        fail
1021 
.Lnext28:
1022 
        mov.l   #0, @long_dst    ; zero it again for the next use.
1023 
 
1024 
mov_l_imm32_to_abs16:
1025 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1026 
        set_ccr_zero
1027 
 
1028 
        ;; mov.l #xx:32, @aa:16
1029 
        mov.l   #0xcafedead:32, @long_dst:16    ; 16-bit address-direct operand
1030 
;;;     .word   0x7a74
1031 
;;;     .long   0xcafedead
1032 
;;;     .word   0x4000
1033 
;;;     .word   @long_dst
1034 
 
1035 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1036 
        test_neg_set
1037 
        test_zero_clear
1038 
        test_ovf_clear
1039 
        test_carry_clear
1040 
 
1041 
        test_gr_a5a5 0           ; Make sure _ALL_ general regs not disturbed
1042 
        test_gr_a5a5 1          ; (first, because on h8/300 we must use one
1043 
        test_gr_a5a5 2          ; to examine the destination memory).
1044 
        test_gr_a5a5 3
1045 
        test_gr_a5a5 4
1046 
        test_gr_a5a5 5
1047 
        test_gr_a5a5 6
1048 
        test_gr_a5a5 7
1049 
 
1050 
        ;; Now check the result of the move to memory.
1051 
        cmp.l   #0xcafedead, @long_dst
1052 
        beq     .Lnext29
1053 
        fail
1054 
.Lnext29:
1055 
        mov.l   #0, @long_dst    ; zero it again for the next use.
1056 
 
1057 
mov_l_imm32_to_abs32:
1058 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1059 
        set_ccr_zero
1060 
 
1061 
        ;;  mov.l #xx:32, @aa:32
1062 
        mov.l   #0xcafedead:32, @long_dst:32    ; 32-bit address-direct operand
1063 
;;;     .word   0x7a74
1064 
;;;     .long   0xcafedead
1065 
;;;     .word   0x4800
1066 
;;;     .long   @long_dst
1067 
 
1068 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1069 
        test_neg_set
1070 
        test_zero_clear
1071 
        test_ovf_clear
1072 
        test_carry_clear
1073 
 
1074 
        test_gr_a5a5 0           ; Make sure _ALL_ general regs not disturbed
1075 
        test_gr_a5a5 1          ; (first, because on h8/300 we must use one
1076 
        test_gr_a5a5 2          ; to examine the destination memory).
1077 
        test_gr_a5a5 3
1078 
        test_gr_a5a5 4
1079 
        test_gr_a5a5 5
1080 
        test_gr_a5a5 6
1081 
        test_gr_a5a5 7
1082 
 
1083 
        ;; Now check the result of the move to memory.
1084 
        cmp.l   #0xcafedead, @long_dst
1085 
        beq     .Lnext30
1086 
        fail
1087 
.Lnext30:
1088 
        mov.l   #0, @long_dst    ; zero it again for the next use.
1089 
 
1090 
.endif
1091 
 
1092 
        ;;
1093 
        ;; Move long from register source
1094 
        ;;
1095 
 
1096 
mov_l_reg32_to_reg32:
1097 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1098 
        set_ccr_zero
1099 
 
1100 
        ;; mov.l ers, erd
1101 
        mov.l   #0x12345678, er1
1102 
        mov.l   er1, er0        ; Register 32-bit operand
1103 
;;;     .word   0x0f90
1104 
 
1105 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1106 
        test_neg_clear
1107 
        test_zero_clear
1108 
        test_ovf_clear
1109 
        test_carry_clear
1110 
        test_h_gr32 0x12345678 er0
1111 
        test_h_gr32 0x12345678 er1      ; mov src unchanged
1112 
 
1113 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1114 
        test_gr_a5a5 3
1115 
        test_gr_a5a5 4
1116 
        test_gr_a5a5 5
1117 
        test_gr_a5a5 6
1118 
        test_gr_a5a5 7
1119 
 
1120 
mov_l_reg32_to_indirect:
1121 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1122 
        set_ccr_zero
1123 
 
1124 
        ;; mov.l ers, @erd
1125 
        mov.l   #long_dst, er1
1126 
        mov.l   er0, @er1       ; Register indirect operand
1127 
;;;     .word   0x0100
1128 
;;;     .word   0x6990
1129 
 
1130 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1131 
        test_neg_set
1132 
        test_zero_clear
1133 
        test_ovf_clear
1134 
        test_carry_clear
1135 
 
1136 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
1137 
        test_h_gr32     long_dst, er1
1138 
        test_gr_a5a5 2
1139 
        test_gr_a5a5 3
1140 
        test_gr_a5a5 4
1141 
        test_gr_a5a5 5
1142 
        test_gr_a5a5 6
1143 
        test_gr_a5a5 7
1144 
 
1145 
        ;; Now check the result of the move to memory.
1146 
        mov.l   #0, er0
1147 
        mov.l   @long_dst, er0
1148 
        cmp.l   er2, er0
1149 
        beq     .Lnext44
1150 
        fail
1151 
.Lnext44:
1152 
        mov.l   #0, er0
1153 
        mov.l   er0, @long_dst  ; zero it again for the next use.
1154 
 
1155 
.if (sim_cpu == h8sx)
1156 
mov_l_reg32_to_postinc:         ; post-increment from register to mem
1157 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1158 
        set_ccr_zero
1159 
 
1160 
        ;; mov.l ers, @erd+
1161 
        mov.l   #long_dst, er1
1162 
        mov.l   er0, @er1+      ; Register post-incr operand
1163 
;;;     .word   0x0103
1164 
;;;     .word   0x6d90
1165 
 
1166 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1167 
        test_neg_set
1168 
        test_zero_clear
1169 
        test_ovf_clear
1170 
        test_carry_clear
1171 
 
1172 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
1173 
        test_h_gr32     long_dst+4, er1
1174 
        test_gr_a5a5 2
1175 
        test_gr_a5a5 3
1176 
        test_gr_a5a5 4
1177 
        test_gr_a5a5 5
1178 
        test_gr_a5a5 6
1179 
        test_gr_a5a5 7
1180 
 
1181 
        ;; Now check the result of the move to memory.
1182 
        cmp.l   er2, @long_dst
1183 
        beq     .Lnext49
1184 
        fail
1185 
.Lnext49:
1186 
        mov.l   #0, @long_dst    ; zero it again for the next use.
1187 
 
1188 
mov_l_reg32_to_postdec:         ; post-decrement from register to mem
1189 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1190 
        set_ccr_zero
1191 
 
1192 
        ;; mov.l ers, @erd-
1193 
        mov.l   #long_dst, er1
1194 
        mov.l   er0, @er1-      ; Register post-decr operand
1195 
;;;     .word   0x0101
1196 
;;;     .word   0x6d90
1197 
 
1198 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1199 
        test_neg_set
1200 
        test_zero_clear
1201 
        test_ovf_clear
1202 
        test_carry_clear
1203 
 
1204 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
1205 
        test_h_gr32     long_dst-4, er1
1206 
        test_gr_a5a5 2
1207 
        test_gr_a5a5 3
1208 
        test_gr_a5a5 4
1209 
        test_gr_a5a5 5
1210 
        test_gr_a5a5 6
1211 
        test_gr_a5a5 7
1212 
 
1213 
        ;; Now check the result of the move to memory.
1214 
        cmp.l   er2, @long_dst
1215 
        beq     .Lnext50
1216 
        fail
1217 
.Lnext50:
1218 
        mov.l   #0, @long_dst    ; zero it again for the next use.
1219 
 
1220 
mov_l_reg32_to_preinc:          ; pre-increment from register to mem
1221 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1222 
        set_ccr_zero
1223 
 
1224 
        ;; mov.l ers, @+erd
1225 
        mov.l   #long_dst-4, er1
1226 
        mov.l   er0, @+er1      ; Register pre-incr operand
1227 
;;;     .word   0x0102
1228 
;;;     .word   0x6d90
1229 
 
1230 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1231 
        test_neg_set
1232 
        test_zero_clear
1233 
        test_ovf_clear
1234 
        test_carry_clear
1235 
 
1236 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
1237 
        test_h_gr32     long_dst, er1
1238 
        test_gr_a5a5 2
1239 
        test_gr_a5a5 3
1240 
        test_gr_a5a5 4
1241 
        test_gr_a5a5 5
1242 
        test_gr_a5a5 6
1243 
        test_gr_a5a5 7
1244 
 
1245 
        ;; Now check the result of the move to memory.
1246 
        cmp.l   er2, @long_dst
1247 
        beq     .Lnext51
1248 
        fail
1249 
.Lnext51:
1250 
        mov.l   #0, @long_dst    ; zero it again for the next use.
1251 
.endif                          ; h8sx
1252 
 
1253 
mov_l_reg32_to_predec:          ; pre-decrement from register to mem
1254 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1255 
        set_ccr_zero
1256 
 
1257 
        ;; mov.l ers, @-erd
1258 
        mov.l   #long_dst+4, er1
1259 
        mov.l   er0, @-er1      ; Register pre-decr operand
1260 
;;;     .word   0x0100
1261 
;;;     .word   0x6d90
1262 
 
1263 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1264 
        test_neg_set
1265 
        test_zero_clear
1266 
        test_ovf_clear
1267 
        test_carry_clear
1268 
 
1269 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
1270 
        test_h_gr32     long_dst, er1
1271 
        test_gr_a5a5 2
1272 
        test_gr_a5a5 3
1273 
        test_gr_a5a5 4
1274 
        test_gr_a5a5 5
1275 
        test_gr_a5a5 6
1276 
        test_gr_a5a5 7
1277 
 
1278 
        ;; Now check the result of the move to memory.
1279 
        mov.l   #0, er0
1280 
        mov.l   @long_dst, er0
1281 
        cmp.l   er2, er0
1282 
        beq     .Lnext48
1283 
        fail
1284 
.Lnext48:
1285 
        mov.l   #0, er0
1286 
        mov.l   er0, @long_dst  ; zero it again for the next use.
1287 
 
1288 
.if (sim_cpu == h8sx)
1289 
mov_l_reg32_to_disp2:
1290 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1291 
        set_ccr_zero
1292 
 
1293 
        ;; mov.l ers, @(dd:2, erd)
1294 
        mov.l   #long_dst-12, er1
1295 
        mov.l   er0, @(12:2, er1)       ; Register plus 2-bit disp. operand
1296 
;;;     .word   0x0103
1297 
;;;     .word   0x6990
1298 
 
1299 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1300 
        test_neg_set
1301 
        test_zero_clear
1302 
        test_ovf_clear
1303 
        test_carry_clear
1304 
 
1305 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
1306 
        test_h_gr32     long_dst-12, er1
1307 
        test_gr_a5a5 2
1308 
        test_gr_a5a5 3
1309 
        test_gr_a5a5 4
1310 
        test_gr_a5a5 5
1311 
        test_gr_a5a5 6
1312 
        test_gr_a5a5 7
1313 
 
1314 
        ;; Now check the result of the move to memory.
1315 
        cmp.l   er2, @long_dst
1316 
        beq     .Lnext52
1317 
        fail
1318 
.Lnext52:
1319 
        mov.l   #0, @long_dst    ; zero it again for the next use.
1320 
.endif                          ; h8sx
1321 
 
1322 
mov_l_reg32_to_disp16:
1323 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1324 
        set_ccr_zero
1325 
 
1326 
        ;; mov.l ers, @(dd:16, erd)
1327 
        mov.l   #long_dst-4, er1
1328 
        mov.l   er0, @(4:16, er1)       ; Register plus 16-bit disp. operand
1329 
;;;     .word   0x0100
1330 
;;;     .word   0x6f90
1331 
;;;     .word   0x0004
1332 
 
1333 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1334 
        test_neg_set
1335 
        test_zero_clear
1336 
        test_ovf_clear
1337 
        test_carry_clear
1338 
 
1339 
        test_h_gr32     long_dst-4, er1
1340 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
1341 
        test_gr_a5a5 2
1342 
        test_gr_a5a5 3
1343 
        test_gr_a5a5 4
1344 
        test_gr_a5a5 5
1345 
        test_gr_a5a5 6
1346 
        test_gr_a5a5 7
1347 
 
1348 
        ;; Now check the result of the move to memory.
1349 
        mov.l   #0, er0
1350 
        mov.l   @long_dst, er0
1351 
        cmp.l   er2, er0
1352 
        beq     .Lnext45
1353 
        fail
1354 
.Lnext45:
1355 
        mov.l   #0, er0
1356 
        mov.l   er0, @long_dst  ; zero it again for the next use.
1357 
 
1358 
mov_l_reg32_to_disp32:
1359 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1360 
        set_ccr_zero
1361 
 
1362 
        ;; mov.l ers, @(dd:32, erd)
1363 
        mov.l   #long_dst-8, er1
1364 
        mov.l   er0, @(8:32, er1)       ; Register plus 32-bit disp. operand
1365 
;;;     .word   0x7890
1366 
;;;     .word   0x6ba0
1367 
;;;     .long   8
1368 
 
1369 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1370 
        test_neg_set
1371 
        test_zero_clear
1372 
        test_ovf_clear
1373 
        test_carry_clear
1374 
 
1375 
        test_h_gr32     long_dst-8, er1
1376 
        test_gr_a5a5 0           ; Make sure other general regs not disturbed
1377 
        test_gr_a5a5 2
1378 
        test_gr_a5a5 3
1379 
        test_gr_a5a5 4
1380 
        test_gr_a5a5 5
1381 
        test_gr_a5a5 6
1382 
        test_gr_a5a5 7
1383 
 
1384 
        ;; Now check the result of the move to memory.
1385 
        mov.l   #0, er0
1386 
        mov.l   @long_dst, er0
1387 
        cmp.l   er2, er0
1388 
        beq     .Lnext46
1389 
        fail
1390 
.Lnext46:
1391 
        mov.l   #0, er0
1392 
        mov.l   er0, @long_dst  ; zero it again for the next use.
1393 
 
1394 
mov_l_reg32_to_abs16:
1395 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1396 
        set_ccr_zero
1397 
 
1398 
        ;; mov.l ers, @aa:16
1399 
        mov.l   er0, @long_dst:16       ; 16-bit address-direct operand
1400 
;;;     .word   0x0100
1401 
;;;     .word   0x6b80
1402 
;;;     .word   @long_dst
1403 
 
1404 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1405 
        test_neg_set
1406 
        test_zero_clear
1407 
        test_ovf_clear
1408 
        test_carry_clear
1409 
 
1410 
        test_gr_a5a5 0           ; Make sure _ALL_ general regs not disturbed
1411 
        test_gr_a5a5 1          ; (first, because on h8/300 we must use one
1412 
        test_gr_a5a5 2          ; to examine the destination memory).
1413 
        test_gr_a5a5 3
1414 
        test_gr_a5a5 4
1415 
        test_gr_a5a5 5
1416 
        test_gr_a5a5 6
1417 
        test_gr_a5a5 7
1418 
 
1419 
        ;; Now check the result of the move to memory.
1420 
        mov.l   #0, er0
1421 
        mov.l   @long_dst, er0
1422 
        cmp.l   er0, er1
1423 
        beq     .Lnext41
1424 
        fail
1425 
.Lnext41:
1426 
        mov.l   #0, er0
1427 
        mov.l   er0, @long_dst  ; zero it again for the next use.
1428 
 
1429 
mov_l_reg32_to_abs32:
1430 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1431 
        set_ccr_zero
1432 
 
1433 
        ;; mov.l ers, @aa:32
1434 
        mov.l   er0, @long_dst:32       ; 32-bit address-direct operand
1435 
;;;     .word   0x0100
1436 
;;;     .word   0x6ba0
1437 
;;;     .long   @long_dst
1438 
 
1439 
        ;; test ccr             ; H=0 N=1 Z=0 V=0 C=0
1440 
        test_neg_set
1441 
        test_zero_clear
1442 
        test_ovf_clear
1443 
        test_carry_clear
1444 
 
1445 
        test_gr_a5a5 0           ; Make sure _ALL_ general regs not disturbed
1446 
        test_gr_a5a5 1          ; (first, because on h8/300 we must use one
1447 
        test_gr_a5a5 2          ; to examine the destination memory).
1448 
        test_gr_a5a5 3
1449 
        test_gr_a5a5 4
1450 
        test_gr_a5a5 5
1451 
        test_gr_a5a5 6
1452 
        test_gr_a5a5 7
1453 
 
1454 
        ;; Now check the result of the move to memory.
1455 
        mov.l   #0, er0
1456 
        mov.l   @long_dst, er0
1457 
        cmp.l   er0, er1
1458 
        beq     .Lnext42
1459 
        fail
1460 
.Lnext42:
1461 
        mov.l   #0, er0
1462 
        mov.l   er0, @long_dst  ; zero it again for the next use.
1463 
 
1464 
        ;;
1465 
        ;; Move long to register destination.
1466 
        ;;
1467 
 
1468 
mov_l_indirect_to_reg32:
1469 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1470 
        set_ccr_zero
1471 
 
1472 
        ;; mov.l @ers, erd
1473 
        mov.l   #long_src, er1
1474 
        mov.l   @er1, er0       ; Register indirect operand
1475 
;;;     .word   0x0100
1476 
;;;     .word   0x6910
1477 
 
1478 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1479 
        test_neg_clear
1480 
        test_zero_clear
1481 
        test_ovf_clear
1482 
        test_carry_clear
1483 
 
1484 
        test_h_gr32 0x77777777 er0
1485 
 
1486 
        test_h_gr32     long_src, er1
1487 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1488 
        test_gr_a5a5 3
1489 
        test_gr_a5a5 4
1490 
        test_gr_a5a5 5
1491 
        test_gr_a5a5 6
1492 
        test_gr_a5a5 7
1493 
 
1494 
mov_l_postinc_to_reg32:         ; post-increment from mem to register
1495 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1496 
        set_ccr_zero
1497 
 
1498 
        ;; mov.l @ers+, erd
1499 
 
1500 
        mov.l   #long_src, er1
1501 
        mov.l   @er1+, er0      ; Register post-incr operand
1502 
;;;     .word   0x0100
1503 
;;;     .word   0x6d10
1504 
 
1505 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1506 
        test_neg_clear
1507 
        test_zero_clear
1508 
        test_ovf_clear
1509 
        test_carry_clear
1510 
 
1511 
        test_h_gr32 0x77777777 er0
1512 
 
1513 
        test_h_gr32     long_src+4, er1
1514 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1515 
        test_gr_a5a5 3
1516 
        test_gr_a5a5 4
1517 
        test_gr_a5a5 5
1518 
        test_gr_a5a5 6
1519 
        test_gr_a5a5 7
1520 
 
1521 
.if (sim_cpu == h8sx)
1522 
mov_l_postdec_to_reg32:         ; post-decrement from mem to register
1523 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1524 
        set_ccr_zero
1525 
 
1526 
        ;; mov.l @ers-, erd
1527 
 
1528 
        mov.l   #long_src, er1
1529 
        mov.l   @er1-, er0      ; Register post-decr operand
1530 
;;;     .word   0x0102
1531 
;;;     .word   0x6d10
1532 
 
1533 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1534 
        test_neg_clear
1535 
        test_zero_clear
1536 
        test_ovf_clear
1537 
        test_carry_clear
1538 
 
1539 
        test_h_gr32 0x77777777 er0
1540 
 
1541 
        test_h_gr32     long_src-4, er1
1542 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1543 
        test_gr_a5a5 3
1544 
        test_gr_a5a5 4
1545 
        test_gr_a5a5 5
1546 
        test_gr_a5a5 6
1547 
        test_gr_a5a5 7
1548 
 
1549 
mov_l_preinc_to_reg32:          ; pre-increment from mem to register
1550 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1551 
        set_ccr_zero
1552 
 
1553 
        ;; mov.l @+ers, erd
1554 
 
1555 
        mov.l   #long_src-4, er1
1556 
        mov.l   @+er1, er0      ; Register pre-incr operand
1557 
;;;     .word   0x0101
1558 
;;;     .word   0x6d10
1559 
 
1560 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1561 
        test_neg_clear
1562 
        test_zero_clear
1563 
        test_ovf_clear
1564 
        test_carry_clear
1565 
 
1566 
        test_h_gr32 0x77777777 er0
1567 
 
1568 
        test_h_gr32     long_src, er1
1569 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1570 
        test_gr_a5a5 3
1571 
        test_gr_a5a5 4
1572 
        test_gr_a5a5 5
1573 
        test_gr_a5a5 6
1574 
        test_gr_a5a5 7
1575 
 
1576 
mov_l_predec_to_reg32:          ; pre-decrement from mem to register
1577 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1578 
        set_ccr_zero
1579 
 
1580 
        ;; mov.l @-ers, erd
1581 
 
1582 
        mov.l   #long_src+4, er1
1583 
        mov.l   @-er1, er0      ; Register pre-decr operand
1584 
;;;     .word   0x0103
1585 
;;;     .word   0x6d10
1586 
 
1587 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1588 
        test_neg_clear
1589 
        test_zero_clear
1590 
        test_ovf_clear
1591 
        test_carry_clear
1592 
 
1593 
        test_h_gr32 0x77777777 er0
1594 
 
1595 
        test_h_gr32     long_src, er1
1596 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1597 
        test_gr_a5a5 3
1598 
        test_gr_a5a5 4
1599 
        test_gr_a5a5 5
1600 
        test_gr_a5a5 6
1601 
        test_gr_a5a5 7
1602 
 
1603 
 
1604 
mov_l_disp2_to_reg32:
1605 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1606 
        set_ccr_zero
1607 
 
1608 
        ;; mov.l @(dd:2, ers), erd
1609 
        mov.l   #long_src-4, er1
1610 
        mov.l   @(4:2, er1), er0        ; Register plus 2-bit disp. operand
1611 
;;;     .word   0x0101
1612 
;;;     .word   0x6910
1613 
 
1614 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1615 
        test_neg_clear
1616 
        test_zero_clear
1617 
        test_ovf_clear
1618 
        test_carry_clear
1619 
 
1620 
        test_h_gr32 0x77777777 er0      ; mov result:   a5a5 | 7777
1621 
 
1622 
        test_h_gr32     long_src-4, er1
1623 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1624 
        test_gr_a5a5 3
1625 
        test_gr_a5a5 4
1626 
        test_gr_a5a5 5
1627 
        test_gr_a5a5 6
1628 
        test_gr_a5a5 7
1629 
.endif                          ; h8sx
1630 
 
1631 
mov_l_disp16_to_reg32:
1632 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1633 
        set_ccr_zero
1634 
 
1635 
        ;; mov.l @(dd:16, ers), erd
1636 
        mov.l   #long_src+0x1234, er1
1637 
        mov.l   @(-0x1234:16, er1), er0 ; Register plus 16-bit disp. operand
1638 
;;;     .word   0x0100
1639 
;;;     .word   0x6f10
1640 
;;;     .word   -0x1234
1641 
 
1642 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1643 
        test_neg_clear
1644 
        test_zero_clear
1645 
        test_ovf_clear
1646 
        test_carry_clear
1647 
 
1648 
        test_h_gr32 0x77777777 er0      ; mov result:   a5a5 | 7777
1649 
 
1650 
        test_h_gr32     long_src+0x1234, er1
1651 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1652 
        test_gr_a5a5 3
1653 
        test_gr_a5a5 4
1654 
        test_gr_a5a5 5
1655 
        test_gr_a5a5 6
1656 
        test_gr_a5a5 7
1657 
 
1658 
mov_l_disp32_to_reg32:
1659 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1660 
        set_ccr_zero
1661 
 
1662 
        ;; mov.l @(dd:32, ers), erd
1663 
        mov.l   #long_src+65536, er1
1664 
        mov.l   @(-65536:32, er1), er0  ; Register plus 32-bit disp. operand
1665 
;;;     .word   0x7890
1666 
;;;     .word   0x6b20
1667 
;;;     .long   -65536
1668 
 
1669 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1670 
        test_neg_clear
1671 
        test_zero_clear
1672 
        test_ovf_clear
1673 
        test_carry_clear
1674 
 
1675 
        test_h_gr32 0x77777777 er0      ; mov result:   a5a5 | 7777
1676 
 
1677 
        test_h_gr32     long_src+65536, er1
1678 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1679 
        test_gr_a5a5 3
1680 
        test_gr_a5a5 4
1681 
        test_gr_a5a5 5
1682 
        test_gr_a5a5 6
1683 
        test_gr_a5a5 7
1684 
 
1685 
mov_l_abs16_to_reg32:
1686 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1687 
        set_ccr_zero
1688 
 
1689 
        ;; mov.l @aa:16, erd
1690 
        mov.l   @long_src:16, er0       ; 16-bit address-direct operand
1691 
;;;     .word   0x0100
1692 
;;;     .word   0x6b00
1693 
;;;     .word   @long_src
1694 
 
1695 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1696 
        test_neg_clear
1697 
        test_zero_clear
1698 
        test_ovf_clear
1699 
        test_carry_clear
1700 
 
1701 
        test_h_gr32 0x77777777 er0
1702 
 
1703 
        test_gr_a5a5 1          ; Make sure other general regs not disturbed
1704 
        test_gr_a5a5 2
1705 
        test_gr_a5a5 3
1706 
        test_gr_a5a5 4
1707 
        test_gr_a5a5 5
1708 
        test_gr_a5a5 6
1709 
        test_gr_a5a5 7
1710 
 
1711 
mov_l_abs32_to_reg32:
1712 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1713 
        set_ccr_zero
1714 
 
1715 
        ;; mov.l @aa:32, erd
1716 
        mov.l   @long_src:32, er0       ; 32-bit address-direct operand
1717 
;;;     .word   0x0100
1718 
;;;     .word   0x6b20
1719 
;;;     .long   @long_src
1720 
 
1721 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1722 
        test_neg_clear
1723 
        test_zero_clear
1724 
        test_ovf_clear
1725 
        test_carry_clear
1726 
 
1727 
        test_h_gr32 0x77777777 er0
1728 
 
1729 
        test_gr_a5a5 1          ; Make sure other general regs not disturbed
1730 
        test_gr_a5a5 2
1731 
        test_gr_a5a5 3
1732 
        test_gr_a5a5 4
1733 
        test_gr_a5a5 5
1734 
        test_gr_a5a5 6
1735 
        test_gr_a5a5 7
1736 
 
1737 
 
1738 
.if (sim_cpu == h8sx)
1739 
 
1740 
        ;;
1741 
        ;; Move long from memory to memory
1742 
        ;;
1743 
 
1744 
mov_l_indirect_to_indirect:     ; reg indirect, memory to memory
1745 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1746 
        set_ccr_zero
1747 
 
1748 
        ;; mov.l @ers, @erd
1749 
 
1750 
        mov.l   #long_src, er1
1751 
        mov.l   #long_dst, er0
1752 
        mov.l   @er1, @er0
1753 
;;;     .word   0x0108
1754 
;;;     .word   0x0100
1755 
 
1756 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1757 
        test_neg_clear
1758 
        test_zero_clear
1759 
        test_ovf_clear
1760 
        test_carry_clear
1761 
 
1762 
        ;; Verify the affected registers.
1763 
 
1764 
        test_h_gr32  long_dst er0
1765 
        test_h_gr32  long_src er1
1766 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1767 
        test_gr_a5a5 3
1768 
        test_gr_a5a5 4
1769 
        test_gr_a5a5 5
1770 
        test_gr_a5a5 6
1771 
        test_gr_a5a5 7
1772 
 
1773 
        ;; Now check the result of the move to memory.
1774 
        cmp.l   @long_src, @long_dst
1775 
        beq     .Lnext55
1776 
        fail
1777 
.Lnext55:
1778 
        ;; Now clear the destination location, and verify that.
1779 
        mov.l   #0, @long_dst
1780 
        cmp.l   @long_src, @long_dst
1781 
        bne     .Lnext56
1782 
        fail
1783 
.Lnext56:                       ; OK, pass on.
1784 
 
1785 
mov_l_postinc_to_postinc:       ; reg post-increment, memory to memory
1786 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1787 
        set_ccr_zero
1788 
 
1789 
        ;; mov.l @ers+, @erd+
1790 
 
1791 
        mov.l   #long_src, er1
1792 
        mov.l   #long_dst, er0
1793 
        mov.l   @er1+, @er0+
1794 
;;;     .word   0x0108
1795 
;;;     .word   0x8180
1796 
 
1797 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1798 
        test_neg_clear
1799 
        test_zero_clear
1800 
        test_ovf_clear
1801 
        test_carry_clear
1802 
 
1803 
        ;; Verify the affected registers.
1804 
 
1805 
        test_h_gr32  long_dst+4 er0
1806 
        test_h_gr32  long_src+4 er1
1807 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1808 
        test_gr_a5a5 3
1809 
        test_gr_a5a5 4
1810 
        test_gr_a5a5 5
1811 
        test_gr_a5a5 6
1812 
        test_gr_a5a5 7
1813 
 
1814 
        ;; Now check the result of the move to memory.
1815 
        cmp.l   @long_src, @long_dst
1816 
        beq     .Lnext65
1817 
        fail
1818 
.Lnext65:
1819 
        ;; Now clear the destination location, and verify that.
1820 
        mov.l   #0, @long_dst
1821 
        cmp.l   @long_src, @long_dst
1822 
        bne     .Lnext66
1823 
        fail
1824 
.Lnext66:                       ; OK, pass on.
1825 
 
1826 
mov_l_postdec_to_postdec:       ; reg post-decrement, memory to memory
1827 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1828 
        set_ccr_zero
1829 
 
1830 
        ;; mov.l @ers-, @erd-
1831 
 
1832 
        mov.l   #long_src, er1
1833 
        mov.l   #long_dst, er0
1834 
        mov.l   @er1-, @er0-
1835 
;;;     .word   0x0108
1836 
;;;     .word   0xa1a0
1837 
 
1838 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1839 
        test_neg_clear
1840 
        test_zero_clear
1841 
        test_ovf_clear
1842 
        test_carry_clear
1843 
 
1844 
        ;; Verify the affected registers.
1845 
 
1846 
        test_h_gr32  long_dst-4 er0
1847 
        test_h_gr32  long_src-4 er1
1848 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1849 
        test_gr_a5a5 3
1850 
        test_gr_a5a5 4
1851 
        test_gr_a5a5 5
1852 
        test_gr_a5a5 6
1853 
        test_gr_a5a5 7
1854 
 
1855 
        ;; Now check the result of the move to memory.
1856 
        cmp.l   @long_src, @long_dst
1857 
        beq     .Lnext75
1858 
        fail
1859 
.Lnext75:
1860 
        ;; Now clear the destination location, and verify that.
1861 
        mov.l   #0, @long_dst
1862 
        cmp.l   @long_src, @long_dst
1863 
        bne     .Lnext76
1864 
        fail
1865 
.Lnext76:                       ; OK, pass on.
1866 
 
1867 
mov_l_preinc_to_preinc:         ; reg pre-increment, memory to memory
1868 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1869 
        set_ccr_zero
1870 
 
1871 
        ;; mov.l @+ers, @+erd
1872 
 
1873 
        mov.l   #long_src-4, er1
1874 
        mov.l   #long_dst-4, er0
1875 
        mov.l   @+er1, @+er0
1876 
;;;     .word   0x0108
1877 
;;;     .word   0x9190
1878 
 
1879 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1880 
        test_neg_clear
1881 
        test_zero_clear
1882 
        test_ovf_clear
1883 
        test_carry_clear
1884 
 
1885 
        ;; Verify the affected registers.
1886 
 
1887 
        test_h_gr32  long_dst er0
1888 
        test_h_gr32  long_src er1
1889 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1890 
        test_gr_a5a5 3
1891 
        test_gr_a5a5 4
1892 
        test_gr_a5a5 5
1893 
        test_gr_a5a5 6
1894 
        test_gr_a5a5 7
1895 
 
1896 
        ;; Now check the result of the move to memory.
1897 
        cmp.l   @long_src, @long_dst
1898 
        beq     .Lnext85
1899 
        fail
1900 
.Lnext85:
1901 
        ;; Now clear the destination location, and verify that.
1902 
        mov.l   #0, @long_dst
1903 
        cmp.l   @long_src, @long_dst
1904 
        bne     .Lnext86
1905 
        fail
1906 
.Lnext86:                               ; OK, pass on.
1907 
 
1908 
mov_l_predec_to_predec:         ; reg pre-decrement, memory to memory
1909 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1910 
        set_ccr_zero
1911 
 
1912 
        ;; mov.l @-ers, @-erd
1913 
 
1914 
        mov.l   #long_src+4, er1
1915 
        mov.l   #long_dst+4, er0
1916 
        mov.l   @-er1, @-er0
1917 
;;;     .word   0x0108
1918 
;;;     .word   0xb1b0
1919 
 
1920 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1921 
        test_neg_clear
1922 
        test_zero_clear
1923 
        test_ovf_clear
1924 
        test_carry_clear
1925 
 
1926 
        ;; Verify the affected registers.
1927 
 
1928 
        test_h_gr32  long_dst er0
1929 
        test_h_gr32  long_src er1
1930 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1931 
        test_gr_a5a5 3
1932 
        test_gr_a5a5 4
1933 
        test_gr_a5a5 5
1934 
        test_gr_a5a5 6
1935 
        test_gr_a5a5 7
1936 
 
1937 
        ;; Now check the result of the move to memory.
1938 
        cmp.l   @long_src, @long_dst
1939 
        beq     .Lnext95
1940 
        fail
1941 
.Lnext95:
1942 
        ;; Now clear the destination location, and verify that.
1943 
        mov.l   #0, @long_dst
1944 
        cmp.l   @long_src, @long_dst
1945 
        bne     .Lnext96
1946 
        fail
1947 
.Lnext96:                       ; OK, pass on.
1948 
 
1949 
mov_l_disp2_to_disp2:           ; reg 2-bit disp, memory to memory
1950 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1951 
        set_ccr_zero
1952 
 
1953 
        ;; mov.l @(dd:2, ers), @(dd:2, erd)
1954 
 
1955 
        mov.l   #long_src-4, er1
1956 
        mov.l   #long_dst-8, er0
1957 
        mov.l   @(4:2, er1), @(8:2, er0)
1958 
;;;     .word   0x0108
1959 
;;;     .word   0x1120
1960 
 
1961 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
1962 
        test_neg_clear
1963 
        test_zero_clear
1964 
        test_ovf_clear
1965 
        test_carry_clear
1966 
 
1967 
        ;; Verify the affected registers.
1968 
 
1969 
        test_h_gr32  long_dst-8 er0
1970 
        test_h_gr32  long_src-4 er1
1971 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
1972 
        test_gr_a5a5 3
1973 
        test_gr_a5a5 4
1974 
        test_gr_a5a5 5
1975 
        test_gr_a5a5 6
1976 
        test_gr_a5a5 7
1977 
 
1978 
        ;; Now check the result of the move to memory.
1979 
        cmp.l   @long_src, @long_dst
1980 
        beq     .Lnext105
1981 
        fail
1982 
.Lnext105:
1983 
        ;; Now clear the destination location, and verify that.
1984 
        mov.l   #0, @long_dst
1985 
        cmp.l   @long_src, @long_dst
1986 
        bne     .Lnext106
1987 
        fail
1988 
.Lnext106:                      ; OK, pass on.
1989 
 
1990 
mov_l_disp16_to_disp16:         ; reg 16-bit disp, memory to memory
1991 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
1992 
        set_ccr_zero
1993 
 
1994 
        ;; mov.l @(dd:16, ers), @(dd:16, erd)
1995 
 
1996 
        mov.l   #long_src-1, er1
1997 
        mov.l   #long_dst-2, er0
1998 
        mov.l   @(1:16, er1), @(2:16, er0)
1999 
;;;     .word   0x0108
2000 
;;;     .word   0xc1c0
2001 
;;;     .word   0x0001
2002 
;;;     .word   0x0002
2003 
 
2004 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
2005 
        test_neg_clear
2006 
        test_zero_clear
2007 
        test_ovf_clear
2008 
        test_carry_clear
2009 
 
2010 
        ;; Verify the affected registers.
2011 
 
2012 
        test_h_gr32  long_dst-2 er0
2013 
        test_h_gr32  long_src-1 er1
2014 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
2015 
        test_gr_a5a5 3
2016 
        test_gr_a5a5 4
2017 
        test_gr_a5a5 5
2018 
        test_gr_a5a5 6
2019 
        test_gr_a5a5 7
2020 
 
2021 
        ;; Now check the result of the move to memory.
2022 
        cmp.l   @long_src, @long_dst
2023 
        beq     .Lnext115
2024 
        fail
2025 
.Lnext115:
2026 
        ;; Now clear the destination location, and verify that.
2027 
        mov.l   #0, @long_dst
2028 
        cmp.l   @long_src, @long_dst
2029 
        bne     .Lnext116
2030 
        fail
2031 
.Lnext116:                      ; OK, pass on.
2032 
 
2033 
mov_l_disp32_to_disp32:         ; reg 32-bit disp, memory to memory
2034 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
2035 
        set_ccr_zero
2036 
 
2037 
        ;; mov.l @(dd:32, ers), @(dd:32, erd)
2038 
 
2039 
        mov.l   #long_src-1, er1
2040 
        mov.l   #long_dst-2, er0
2041 
        mov.l   @(1:32, er1), @(2:32, er0)
2042 
;;;     .word   0x0108
2043 
;;;     .word   0xc9c8
2044 
;;;     .long   1
2045 
;;;     .long   2
2046 
 
2047 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
2048 
        test_neg_clear
2049 
        test_zero_clear
2050 
        test_ovf_clear
2051 
        test_carry_clear
2052 
 
2053 
        ;; Verify the affected registers.
2054 
 
2055 
        test_h_gr32  long_dst-2 er0
2056 
        test_h_gr32  long_src-1 er1
2057 
        test_gr_a5a5 2          ; Make sure other general regs not disturbed
2058 
        test_gr_a5a5 3
2059 
        test_gr_a5a5 4
2060 
        test_gr_a5a5 5
2061 
        test_gr_a5a5 6
2062 
        test_gr_a5a5 7
2063 
 
2064 
        ;; Now check the result of the move to memory.
2065 
        cmp.l   @long_src, @long_dst
2066 
        beq     .Lnext125
2067 
        fail
2068 
.Lnext125:
2069 
        ;; Now clear the destination location, and verify that.
2070 
        mov.l   #0, @long_dst
2071 
        cmp.l   @long_src, @long_dst
2072 
        bne     .Lnext126
2073 
        fail
2074 
.Lnext126:                              ; OK, pass on.
2075 
 
2076 
mov_l_abs16_to_abs16:           ; 16-bit absolute addr, memory to memory
2077 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
2078 
        set_ccr_zero
2079 
 
2080 
        ;; mov.l @aa:16, @aa:16
2081 
 
2082 
        mov.l   @long_src:16, @long_dst:16
2083 
;;;     .word   0x0108
2084 
;;;     .word   0x4040
2085 
;;;     .word   @long_src
2086 
;;;     .word   @long_dst
2087 
 
2088 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
2089 
        test_neg_clear
2090 
        test_zero_clear
2091 
        test_ovf_clear
2092 
        test_carry_clear
2093 
 
2094 
 
2095 
        test_gr_a5a5 0           ; Make sure *NO* general registers are changed
2096 
        test_gr_a5a5 1
2097 
        test_gr_a5a5 2
2098 
        test_gr_a5a5 3
2099 
        test_gr_a5a5 4
2100 
        test_gr_a5a5 5
2101 
        test_gr_a5a5 6
2102 
        test_gr_a5a5 7
2103 
 
2104 
        ;; Now check the result of the move to memory.
2105 
        cmp.l   @long_src, @long_dst
2106 
        beq     .Lnext135
2107 
        fail
2108 
.Lnext135:
2109 
        ;; Now clear the destination location, and verify that.
2110 
        mov.l   #0, @long_dst
2111 
        cmp.l   @long_src, @long_dst
2112 
        bne     .Lnext136
2113 
        fail
2114 
.Lnext136:                              ; OK, pass on.
2115 
 
2116 
mov_l_abs32_to_abs32:           ; 32-bit absolute addr, memory to memory
2117 
        set_grs_a5a5            ; Fill all general regs with a fixed pattern
2118 
        set_ccr_zero
2119 
 
2120 
        ;; mov.l @aa:32, @aa:32
2121 
 
2122 
        mov.l   @long_src:32, @long_dst:32
2123 
;;;     .word   0x0108
2124 
;;;     .word   0x4848
2125 
;;;     .long   @long_src
2126 
;;;     .long   @long_dst
2127 
 
2128 
        ;; test ccr             ; H=0 N=0 Z=0 V=0 C=0
2129 
        test_neg_clear
2130 
        test_zero_clear
2131 
        test_ovf_clear
2132 
        test_carry_clear
2133 
 
2134 
        test_gr_a5a5 0           ; Make sure *NO* general registers are changed
2135 
        test_gr_a5a5 1
2136 
        test_gr_a5a5 2
2137 
        test_gr_a5a5 3
2138 
        test_gr_a5a5 4
2139 
        test_gr_a5a5 5
2140 
        test_gr_a5a5 6
2141 
        test_gr_a5a5 7
2142 
 
2143 
        ;; Now check the result of the move to memory.
2144 
        cmp.l   @long_src, @long_dst
2145 
        beq     .Lnext145
2146 
        fail
2147 
.Lnext145:
2148 
        ;; Now clear the destination location, and verify that.
2149 
        mov.l   #0, @long_dst
2150 
        cmp.l   @long_src, @long_dst
2151 
        bne     .Lnext146
2152 
        fail
2153 
.Lnext146:                              ; OK, pass on.
2154 
 
2155 
 
2156 
.endif
2157 
 
2158 
        pass
2159 
 
2160 
        exit 0

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.