home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / oct93 / develop / math68hc11.lha / Math68hc11 / MATH16B.ASM < prev    next >
Assembly Source File  |  1990-04-05  |  7KB  |  197 lines
  1. *============================================================================*
  2. *               1 6   B I T   M A T H   P A C K A G E
  3. *          for the Motorola 6805 family of microprocessors.
  4. *
  5. *                            D G Weiss
  6. *                          Motorola Inc
  7. *                      Microprocessor Group
  8. *                 Midrange Strategic Engineering
  9. *                          13 Nov 1985
  10. *
  11. *   This is a collection of routines for maintaining a 32-bit pseudo-
  12. *   accumulator.  Each routine uses the X register to locate an operand;
  13. *   the math routines use the pseudo-accumulator as the other operand.
  14. *
  15. *============================================================================*
  16.         ORG     $40       Beginning of RAM
  17. ACCUM3  RMB     1         Accumulator high order byte
  18. ACCUM2  RMB     1
  19. ACCUM1  RMB     1
  20. ACCUM0  RMB     1         Accumulator low order byte
  21. CTR     RMB     1         Iteration counter
  22. TEMP1   RMB     1         Miscelleneous temps
  23. TEMP0   RMB     1
  24. *----------------------------------------------------------------------------*
  25. * Load 16-bit value pointed to by X register into Accumulator.
  26. *    Accepts:
  27. *       value to be loaded: X^[0..1]
  28. *    Yields:
  29. *       loaded value:       Accum[1..0]
  30. *----------------------------------------------------------------------------*
  31.         ORG     $800
  32. LOAD16  EQU     *
  33.         LDA     0,X
  34.         STA     ACCUM1
  35.         LDA     1,X
  36.         STA     ACCUM0
  37.         RTS 
  38. *----------------------------------------------------------------------------*
  39. * Store 16-bit value from Accumulator to location pointed to by X register.
  40. *    Accepts:
  41. *       value to be stored: Accum[1..0]
  42. *    Yields:
  43. *       stored value:       X^[0..1]
  44. *----------------------------------------------------------------------------*
  45. STORE16 EQU     *
  46.         LDA     ACCUM1
  47.         STA     0,X
  48.         LDA     ACCUM0
  49.         STA     1,X
  50.         RTS 
  51. *----------------------------------------------------------------------------*
  52. * Add 16-bit value pointed to by X register into Accumulator.  
  53. *    Accepts:
  54. *       Addend: Accum[1..0]
  55. *       Augend: X^[0..1]
  56. *    Yields:
  57. *       Sum:    Accum[1..0]
  58. *----------------------------------------------------------------------------*
  59. ADD16   EQU     *
  60.         LDA     ACCUM0
  61.         ADD     1,X
  62.         STA     ACCUM0
  63.         LDA     ACCUM1
  64.         ADC     0,X
  65.         STA     ACCUM1
  66.         RTS 
  67. *----------------------------------------------------------------------------*
  68. * Subtract 16-bit value pointed to by X register from Accumulator.
  69. *    Accepts:
  70. *       Minuend:    Accum[1..0]
  71. *       Subtrahend: X^[0..1]
  72. *    Yields:
  73. *       Difference: Accum[1..0]
  74. *----------------------------------------------------------------------------*
  75. SUB16   EQU     *
  76.         LDA     ACCUM0
  77.         SUB     1,X
  78.         STA     ACCUM0
  79.         LDA     ACCUM1
  80.         SBC     0,X
  81.         STA     ACCUM1
  82.         RTS
  83. *
  84. *----------------------------------------------------------------------------*
  85. * Multiply 16-bit value in Accumulator by 16-bit value pointed to by X
  86. *   register.
  87. *
  88. *    Accepts:
  89. *       Multiplier:    Accum[1..0]
  90. *       Multiplicand:  X^[0..1]
  91. *    Yields:
  92. *       Product:       Accum[3..0]
  93. *----------------------------------------------------------------------------*
  94. PROD3   EQU     ACCUM3    Product high order byte
  95. PROD2   EQU     ACCUM2
  96. PROD1   EQU     ACCUM1
  97. PROD0   EQU     ACCUM0    Product low order byte
  98. MPR1    EQU     TEMP1     Multiplier high order byte
  99. MPR0    EQU     TEMP0     Multiplier low order byte
  100. MPD1    EQU     0         Multiplicand high order byte offset
  101. MPD0    EQU     1         Multiplicand low order byte offset
  102.  
  103. MPY16   EQU     *
  104.         LDA     PROD0                 .Mpr[1..0] := Prod[1..0]
  105.         STA     MPR0
  106.         LDA     PROD1
  107.         STA     MPR1
  108.         CLR     PROD0                 .Prod[2..0] := 0
  109.         CLR     PROD1
  110.         CLR     PROD2
  111.         LDA     #16                   .For ctr := 16 Downto 1 Do
  112.         STA     CTR
  113.  
  114. MPY16A  BRCLR   7,MPR1,MPY16C         .   If mpr msb = 1
  115.         LDA     PROD0                 .       Then prod += mpd
  116.         ADD     MPD0,X
  117.         STA     PROD0
  118.         LDA     PROD1
  119.         ADC     MPD1,X
  120.         STA     PROD1
  121.         LDA     PROD2
  122.         ADC     #0
  123.         STA     PROD2
  124.  
  125. MPY16C  DEC     CTR                   .   If (ctr -= 1) = 0 Then Exit
  126.         BEQ     MPY16E
  127.         ASL     PROD0                 .   shift prod left
  128.         ROL     PROD1
  129.         ROL     PROD2
  130.         ROL     PROD3
  131.         ASL     MPR0                  .   shift mpr left
  132.         ROL     MPR1
  133.         BRA     MPY16A
  134.  
  135. MPY16E  RTS
  136. *
  137. *----------------------------------------------------------------------------*
  138. * Divide 32 by 16 bit unsigned integer
  139. *
  140. *    Accepts:
  141. *       Dividend:      Accum[3..0]
  142. *       Divisor:       X^[0..1]
  143. *    Yields:
  144. *       Quotient:      Accum[1..0]
  145. *       Remainder:     Accum[3..2]
  146. *----------------------------------------------------------------------------*
  147. DVDND3  EQU     ACCUM3  Dividend high order byte
  148. DVDND2  EQU     ACCUM2
  149. DVDND1  EQU     ACCUM1
  150. DVDND0  EQU     ACCUM0  Dividend low order byte
  151. RMNDR1  EQU     ACCUM3  Remainder high order byte
  152. RMNDR0  EQU     ACCUM2  Remainder low order byte
  153. QUOT1   EQU     ACCUM1  Quotient high order byte
  154. QUOT0   EQU     ACCUM0  Quotient low order byte
  155. DVSOR1  EQU     0       Divisor high order byte offset
  156. DVSOR0  EQU     1       Divisor low order byte offset
  157. *
  158. DIV16   EQU     *
  159.         LDA     #16                       .For Ctr := 16 Downto 1 do
  160.         STA     CTR
  161.  
  162. DIV16A  LDA     DVDND3                    .    shift dividend left one place
  163.         ROLA
  164.         ROL     DVDND0
  165.         ROL     DVDND1
  166.         ROL     DVDND2
  167.         ROL     DVDND3
  168.  
  169.         LDA     DVDND2                    .    subtract divisor from remainder
  170.         SUB     DVSOR0,X
  171.         STA     DVDND2
  172.         LDA     DVDND3
  173.         SBC     DVSOR1,X
  174.         STA     DVDND3
  175.         LDA     DVDND0                    .{dividend low bit holds subtract carry}
  176.         SBC     #0
  177.         STA     DVDND0
  178.  
  179.         BRCLR   0,DVDND0,DIV16C           .    if subtract carry = 1
  180.         LDA     DVDND2                    .        Then add divisor back in
  181.         ADD     DVSOR0,X
  182.         STA     DVDND2
  183.         LDA     DVDND3
  184.         ADC     DVSOR1,X
  185.         STA     DVDND3
  186.         LDA     DVDND0
  187.         ADC     #0
  188.         STA     DVDND0
  189.         BRA     DIV16D
  190.  
  191. DIV16C  BSET    0,DVDND0                  .        Else set hi bit := 1
  192.  
  193. DIV16D  DEC     CTR
  194.         BNE     DIV16A
  195.         RTS
  196.         END
  197.