Return to movc.s CVS log

Up to [Research Unix] / researchv9 / sys / sun3

Annotation of researchv9/sys/sun3/movc.s, revision 1.1.1.1

1.1       root        1:        .data
                      2:        .asciz  "@(#)movc.s 1.1 86/02/03 Copyr 1984 Sun Micro"
                      3:        .even
                      4:        .text
                      5: 
                      6: |      Copyright (c) 1984 by Sun Microsystems, Inc.
                      7: 
                      8: #include "../machine/asm_linkage.h"
                      9: 
                     10: | Copy a block of storage - must not overlap ( from + len <= to)
                     11: | Usage: bcopy(from, to, count)
                     12:        ENTRY(bcopy)
                     13:        movl    sp@(4),a0       | from
                     14:        movl    sp@(8),a1       | to
                     15:        movl    sp@(12),d0      | get count
                     16:        jle     ret             | return if not positive
                     17: | If from address odd, move one byte to 
                     18: | try to make things even
                     19:        movw    a0,d1           | from
                     20:        btst    #0,d1           | test for odd bit in from
                     21:        jeq     1$              | even, skip
                     22:        movb    a0@+,a1@+       | move a byte
                     23:        subql   #1,d0           | adjust count
                     24: | If to address is odd now, we have to do byte moves
                     25: 1$:    movl    a1,d1           | low bit one if mutual oddness
                     26:        btst    #0,d1           | test low bit
                     27:        jne     bytes           | do it slow and easy
                     28: | The addresses are now both even 
                     29: | Now move longs
                     30:        movl    d0,d1           | save count
                     31:        lsrl    #2,d0           | get # longs
                     32:        jra     3$              | enter long move loop
                     33: | The following loop runs in loop mode on 68010
                     34: 2$:    movl    a0@+,a1@+       | move a long
                     35: 3$:    dbra    d0,2$           | decr, br if >= 0
                     36: | Now up to 3 bytes remain to be moved
                     37:        movl    d1,d0           | restore count
                     38:        andl    #3,d0           | mod sizeof long
                     39:        jra     bytes           | go do bytes
                     40: 
                     41: | Here if we have to move byte-by-byte because
                     42: | the pointers didn't line up.  68010 loop mode is used.
                     43: bloop: movb    a0@+,a1@+       | loop mode byte moves
                     44: bytes: dbra    d0,bloop
                     45: ret:   rts
                     46: 
                     47: | Block copy with possibly overlapped operands
                     48:        ENTRY(ovbcopy)
                     49:        movl    sp@(4),a0       | from
                     50:        movl    sp@(8),a1       | to
                     51:        movl    sp@(12),d0      | get count
                     52:        jle     ret             | return if not positive
                     53:        cmpl    a0,a1           | check direction of copy
                     54:        jgt     bwd             | do it backwards
                     55: | Here if from > to - copy bytes forward
                     56:        jra     2$
                     57: | Loop mode byte copy
                     58: 1$:    movb    a0@+,a1@+
                     59: 2$:    dbra    d0,1$
                     60:        rts
                     61: | Here if from < to - copy bytes backwards
                     62: bwd:   addl    d0,a0           | get end of from area
                     63:        addl    d0,a1           | get end of to area
                     64:        jra     2$              | enter loop
                     65: | Loop mode byte copy
                     66: 1$:    movb    a0@-,a1@-
                     67: 2$:    dbra    d0,1$
                     68:        rts
                     69: 
                     70: 
                     71: | Zero block of storage
                     72: | Usage: bzero(addr, length)
                     73:        ENTRY2(bzero,blkclr)
                     74:        movl    sp@(4),a1       | address
                     75:        movl    sp@(8),d0       | length
                     76:        clrl    d1              | use zero register to avoid clr fetches
                     77:        btst    #0,sp@(7)       | odd address?
                     78:        jeq     1$              | no, skip
                     79:        movb    d1,a1@+         | do one byte
                     80:        subql   #1,d0           | to adjust to even address
                     81: 1$:    movl    d0,a0           | save possibly adjusted count
                     82:        lsrl    #2,d0           | get count of longs
                     83:        jra     3$              | go to loop test
                     84: | Here is the fast inner loop - loop mode on 68010
                     85: 2$:    movl    d1,a1@+         | store long
                     86: 3$:    dbra    d0,2$           | decr count; br until done
                     87: | Now up to 3 bytes remain to be cleared
                     88:        movl    a0,d0           | restore count
                     89:        btst    #1,d0           | need a short word?
                     90:        jeq     4$              | no, skip
                     91:        movw    d1,a1@+         | do a short
                     92: 4$:    btst    #0,d0           | need another byte
                     93:        jeq     5$              | no, skip
                     94:        movb    d1,a1@+         | do a byte
                     95: 5$:    rts                     | all done

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.