home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 177.lha / DRes_v1.3 / src / mem.asm < prev    next >
Encoding:
Assembly Source File  |  1988-04-28  |  4.5 KB  |  187 lines
  1.  
  2.         ;   MEM.ASM
  3.  
  4.         public    _lBZero     ; Zero a block of memory
  5.         public    _lBSet        ; Set a block of memory to (byte val)
  6.         public    _lBMov        ; move a block of memory
  7.         public    _lBCmp        ; compare two blocks of memory
  8.  
  9.         ;   BSET(buffer:D0, len:D1, byte:A0.B)
  10.         ;   BZERO(buffer:D0, len:D1)
  11.  
  12. _lBZero:    move.w    #0,A0
  13. _lBSet:     exg    A0,D0        ; A0 = buffer   (D0=byte)
  14.         exg    D0,D1        ; D0 = length   (D1=byte)
  15.         add.l    D0,A0        ; start at end of address
  16.         cmp.l    #40,D0        ; unscientifically chosen
  17.         bls    .bs2
  18.         bra    .bs10
  19. .bs1        move.b    D1,-(A0)    ; any count < 65536
  20. .bs2        dbf    D0,.bs1
  21.         rts
  22.  
  23.                     ; at least 2 bytes in count (D0)
  24. .bs10        movem.l D2-D7/A2-A6,-(sp)   ;ant count > 4
  25.         move.l    A0,D2
  26.         btst.l    #0,D2        ; is it aligned?
  27.         beq    .bs22
  28.         move.b    D1,-(A0)    ; no, copy one byte
  29.         subq.l    #1,D0
  30.  
  31. .bs22        andi.l    #$FF,D1     ; expand data D1.B -> D2-D7/A1-A6
  32.         move.l    D1,D2        ; D1 000000xx   D2 000000xx
  33.         asl.w    #8,D2        ;               0000xx00
  34.         or.w    D2,D1        ;     0000xxxx
  35.         move.w    D1,D2        ;     0000xxxx      0000xxxx
  36.         swap    D2        ;     0000xxxx      xxxx0000
  37.         or.l    D1,D2        ; D2.L
  38.         move.l    D2,D3
  39.         move.l    D2,D4
  40.         move.l    D2,D5
  41.         move.l    D2,D6
  42.         move.l    D2,D7
  43.         move.l    D2,A1
  44.         move.l    D2,A2
  45.         move.l    D2,A3
  46.         move.l    D2,A4
  47.         move.l    D2,A5
  48.         move.l    D2,A6        ; D2-D7/A1-A6   (12 registers)
  49.         move.l    #12*4,D1    ; bytes per transfer (48)
  50. .bs30        sub.l    D1,D0        ; pre subtract
  51.         bmi    .bs40
  52. .bs31        movem.l D2-D7/A1-A6,-(A0)
  53.         sub.l    D1,D0
  54.         bpl    .bs31
  55. .bs40        add.w    D1,D0        ; less than 48 bytes remaining
  56.  
  57.         move.w    #4,D1        ; by 4's
  58.         sub.w    D1,D0
  59.         bmi    .bs50
  60. .bs41        move.l    D2,-(A0)
  61.         sub.w    D1,D0
  62.         bpl    .bs41
  63. .bs50        add.w    D1,D0
  64.         bra    .bs52
  65. .bs51        move.b    D2,-(A0)    ; by 1's
  66. .bs52        dbf    D0,.bs51
  67.         movem.l (sp)+,D2-D7/A2-A6
  68.         rts
  69.  
  70.         ;   BCMP(src:D0, dst:D1, len:A0)
  71.  
  72. _lBCmp:     exg    A0,D0        ;A0 = src, D0 = len
  73.         exg    A1,D1        ;A1 = dst
  74.  
  75.         tst.l    D0
  76.         beq    .bcsucc
  77.         cmp.w    D0,D0        ;force Z bit
  78.         bra    .bc2
  79. .bc1        cmpm.b    (A0)+,(A1)+
  80. .bc2        dbne    D0,.bc1
  81.         bne    .bcfail
  82.         sub.l    #$10000,D0
  83.         bcc    .bc1
  84. .bcsucc     moveq.l #1,D0        ;success!
  85.         rts
  86. .bcfail     moveq.l #0,D0        ;failure!
  87.         rts
  88.  
  89.         ;   BMOV(src:D0, dst:D1, len:A0)
  90.         ;
  91.         ;   The memory move algorithm is somewhat more of a mess
  92.         ;   since we must do it either ascending or decending.
  93.  
  94. _lBMov:     exg    A0,D0        ;A0 = src, D0 = len
  95.         exg    A1,D1        ;A1 = dst
  96.         cmp.l    A0,A1
  97.         beq    .bmend
  98.         bls    .bmup
  99. .bmdown     adda.l    D0,A0        ;descending copy
  100.         adda.l    D0,A1
  101.         move.w    A0,D1        ;CHECK WORD ALIGNED
  102.         btst.l    #0,D1
  103.         bne    .bmdown1
  104.         move.w    A1,D1
  105.         btst.l    #0,D1
  106.         bne    .bmdown1
  107.         cmp.l    #259,D0         ;chosen by calculation.
  108.         blo    .bmdown8
  109.  
  110.         move.l    D0,D1            ;overhead for bmd44: ~360
  111.         divu    #44,D1
  112.         bvs    .bmdown8        ;too big (> 2,883,540)
  113.         movem.l D2-D7/A2-A6,-(sp)   ;use D2-D7/A2-A6 (11 regs)
  114.         move.l    #11*4,D0
  115.         bra    .bmd44b
  116. .bmd44a     sub.l    D0,A0            ;8        total 214/44bytes
  117.         movem.l (A0),D2-D7/A2-A6    ;12 + 8*11  4.86 cycles/byte
  118.         movem.l D2-D7/A2-A6,-(A1)   ; 8 + 8*11
  119. .bmd44b     dbf    D1,.bmd44a        ;10
  120.         swap    D1            ;D0<15:7> already contain 0
  121.         move.w    D1,D0            ;D0 = remainder
  122.         movem.l (sp)+,D2-D7/A2-A6
  123.  
  124. .bmdown8    move.w    D0,D1            ;D1<2:0> = #bytes left later
  125.         lsr.l    #3,D0            ;divide by 8
  126.         bra    .bmd8b
  127. .bmd8a        move.l    -(A0),-(A1)         ;20         total 50/8bytes
  128.         move.l    -(A0),-(A1)         ;20         = 6.25 cycles/byte
  129. .bmd8b        dbf    D0,.bmd8a        ;10
  130.         sub.l    #$10000,D0
  131.         bcc    .bmd8a
  132.         move.w    D1,D0            ;D0 = 0 to 7 bytes
  133.         and.l    #7,D0
  134.         bne    .bmdown1
  135.         rts
  136.  
  137. .bmd1a        move.b    -(A0),-(A1)         ;12         total 22/byte
  138. .bmdown1                    ;        = 22 cycles/byte
  139. .bmd1b        dbf    D0,.bmd1a        ;10
  140.         sub.l    #$10000,D0
  141.         bcc    .bmd1a
  142.         rts
  143.  
  144. .bmup        move.w    A0,D1            ;CHECK WORD ALIGNED
  145.         btst.l    #0,D1
  146.         bne    .bmup1
  147.         move.w    A1,D1
  148.         btst.l    #0,D1
  149.         bne    .bmup1
  150.         cmp.l    #259,D0         ;chosen by calculation
  151.         blo    .bmup8
  152.  
  153.         move.l    D0,D1            ;overhead for bmu44: ~360
  154.         divu    #44,D1
  155.         bvs    .bmup8            ;too big (> 2,883,540)
  156.         movem.l D2-D7/A2-A6,-(sp)   ;use D2-D7/A2-A6 (11 regs)
  157.         move.l    #11*4,D0
  158.         bra    .bmu44b
  159. .bmu44a     movem.l (A0)+,D2-D7/A2-A6   ;12 + 8*11  ttl 214/44bytes
  160.         movem.l D2-D7/A2-A6,(A1)    ;8  + 8*11  4.86 cycles/byte
  161.         add.l    D0,A1            ;8
  162. .bmu44b     dbf    D1,.bmu44a        ;10
  163.         swap    D1            ;D0<15:7> already contain 0
  164.         move.w    D1,D0            ;D0 = remainder
  165.         movem.l (sp)+,D2-D7/A2-A6
  166.  
  167. .bmup8        move.w    D0,D1            ;D1<2:0> = #bytes left later
  168.         lsr.l    #3,D0            ;divide by 8
  169.         bra    .bmu8b
  170. .bmu8a        move.l    (A0)+,(A1)+         ;20         total 50/8bytes
  171.         move.l    (A0)+,(A1)+         ;20         = 6.25 cycles/byte
  172. .bmu8b        dbf    D0,.bmu8a        ;10
  173.         sub.l    #$10000,D0
  174.         bcc    .bmu8a
  175.         move.w    D1,D0            ;D0 = 0 to 7 bytes
  176.         and.l    #7,D0
  177.         bne    .bmup1
  178.         rts
  179.  
  180. .bmu1a        move.b    (A0)+,(A1)+
  181. .bmup1
  182. .bmu1b        dbf    D0,.bmu1a
  183.         sub.l    #$10000,D0
  184.         bcc    .bmu1a
  185. .bmend        rts
  186.  
  187.