sim/testsuite/sim/h8300/movb.s

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