Annotation of pgp/src/68000_32.s, revision 1.1.1.2

1.1.1.2 ! root        1: ;FPRIMS32.S - rsalib assembler primitives for MC680x0
        !             2: ;             (Pure-C/Atari ST version, 32-bit units)
        !             3: ;
        !             4: ;Written by Stephan Baucke 19-Oct-91
        !             5: ;Assembler: Pure-PASM
        !             6: ;
        !             7: ;On systems with 68020 or higher it might be faster to use 32-Bit units
        !             8: ;instead of 16 Bits (I didn't yet test this, but there is no improvement
        !             9: ;on a plain 68000).
        !            10: ;
        !            11: ;Note that the function P_SETP of the Intel primitives is not needed here.
        !            12: ;`set_precision' has to be defined just like in `PORTABLE' mode in rsalib.h
        !            13: 
        !            14:             IMPORT global_precision
        !            15:             EXPORT P_ADDC, P_SUBB, P_ROTL, P_SETP, P_SMUL
        !            16: 
        !            17:             TEXT
        !            18: 
        !            19: ;boolean P_ADDC(unitptr r1, unitptr r2, boolean carry);
        !            20: ; /* multiprecision add with carry r2 to r1, result in r1 */
        !            21: ;Parameters: A0.l: r1, A1.l: r2, D0.b: carry
        !            22: ;Result:     D0.b: new carry
        !            23: ;Modifies: D0-D2/A0-A1
        !            24: 
        !            25: P_ADDC:     move.b  d0,d1       ;boolean carry
        !            26:             sne     d1          ;set bit 0 to carry
        !            27:             move.w  global_precision,d2 ;# of units
        !            28:             move.w  d2,d0       ;make copy
        !            29:             lsl.w   #2,d2       ;calc # of bytes (4 per unit)
        !            30:             add.w   d2,a0       ;point r1 to least significant unit
        !            31:             add.w   d2,a1       ;point r2 to least significant unit
        !            32:             lsr.w   #1,d2       ;divide back (now 2 * units)
        !            33:             and.w   #2*7,d2     ;yields 2 * (units % 8)
        !            34:             neg.w   d2          ;negative offset (for 2-Byte instructions)
        !            35:             lsr.w   #3,d0       ;units / 8
        !            36:             beq.s   .onebyone   ;skip loop if zero count
        !            37: 
        !            38:             subq.w  #1,d0       ;one off (dbf counter)
        !            39:             lsr.b   d1          ;set X if carry
        !            40: .loop:      REPT    8               ;8 units per run
        !            41:               addx.l -(a1),-(a0)
        !            42:             ENDM
        !            43:             dbf     d0,.loop
        !            44:             jmp     .base(pc,d2.w)  ;do remaining units
        !            45: 
        !            46: .onebyone:  lsr.b   d1              ;set X if carry
        !            47:             jmp     .base(pc,d2.w)  ;do remaining units
        !            48: 
        !            49:             REPT    7               ;max 7 units remaining
        !            50:               addx.l -(a1),-(a0)    ;(2-byte instruction)
        !            51:             ENDM
        !            52: .base:      scs     d0              ;set returned carry
        !            53:             rts
        !            54: 
        !            55: ;boolean P_SUBB(unitptr r1, unitptr r2, boolean borrow);
        !            56: ; /* multiprecision subtract with borrow, r2 from r1, result in r1 */
        !            57: ;Parameters: A0.l: r1, A1.l: r2, D0.b: borrow
        !            58: ;Result:     D0.b: new borrow
        !            59: ;Modifies: D0-D2/A0/A1
        !            60: 
        !            61: P_SUBB:     move.b  d0,d1       ;boolean carry
        !            62:             sne     d1          ;set bit 0 to carry
        !            63:             move.w  global_precision,d2 ;# of units
        !            64:             move.w  d2,d0       ;make copy
        !            65:             lsl.w   #2,d2       ;calc # of bytes (4 per unit)
        !            66:             add.w   d2,a0       ;point r1 to least significant unit
        !            67:             add.w   d2,a1       ;point r2 to least significant unit
        !            68:             lsr.w   #1,d2       ;divide back (now 2 * units)
        !            69:             and.w   #2*7,d2     ;yields 2 * (units % 8)
        !            70:             neg.w   d2          ;negative offset (for 2-byte instructions)
        !            71:             lsr.w   #3,d0       ;units / 8
        !            72:             beq.s   .onebyone   ;skip loop if zero count
        !            73: 
        !            74:             subq.w  #1,d0       ;one off (dbf counter)
        !            75:             lsr.b   d1          ;set X if carry
        !            76: .loop:      REPT    8               ;8 units per run
        !            77:               subx.l -(a1),-(a0)
        !            78:             ENDM
        !            79:             dbf     d0,.loop
        !            80:             jmp     .base(pc,d2.w)  ;do remaining units
        !            81: 
        !            82: .onebyone:  lsr.b   d1              ;set X if carry
        !            83:             jmp     .base(pc,d2.w)  ;do remaining units
        !            84: 
        !            85:             REPT    7               ;max 7 units remaining
        !            86:               subx.l -(a1),-(a0)    ;(2-byte instruction)
        !            87:             ENDM
        !            88: .base:      scs     d0              ;set returned carry
        !            89:             rts
        !            90: 
        !            91: ;boolean P_ROTL(unitptr r1, boolean carry);
        !            92: ; /* multiprecision rotate left 1 bit with carry, result in r1. */
        !            93: ;Parameters: A0.l: r1, D0.b: carry
        !            94: ;Result:     D0.b: new carry
        !            95: ;Modifies: D0-D2/A0
        !            96: 
        !            97: P_ROTL:     move.b  d0,d1       ;boolean carry
        !            98:             sne     d1          ;set bit 0 to carry
        !            99:             move.w  global_precision,d2 ;# of units
        !           100:             move.w  d2,d0       ;make copy
        !           101:             lsl.w   #2,d2       ;calc # of bytes (4 per unit)
        !           102:             add.w   d2,a0       ;point r1 to least significant unit
        !           103:             and.w   #4*7,d2     ;yields 4 * (units % 8)
        !           104:             neg.w   d2          ;negative offset (for 4-byte instructions)
        !           105:             lsr.w   #3,d0       ;units / 8
        !           106:             beq.s   .onebyone   ;skip loop if zero count
        !           107: 
        !           108:             subq.w  #1,d0       ;one off (dbf counter)
        !           109:             lsr.b   d1          ;set X if carry
        !           110: .loop:      REPT    8           ;8 units per run
        !           111:               roxl.w -(a0)      ;(roxl.l <ea> is not allowed on the 68000)
        !           112:               roxl.w -(a0)
        !           113:             ENDM
        !           114:             dbf     d0,.loop
        !           115:             jmp     .base(pc,d2.w)  ;do remaining units
        !           116: 
        !           117: .onebyone:  lsr.b   d1              ;set X if carry
        !           118:             jmp     .base(pc,d2.w)  ;do remaining units
        !           119: 
        !           120:             REPT    7               ;max 7 units remaining
        !           121:               roxl.w -(a0)          ;(4 bytes instructions per unit)
        !           122:               roxl.w -(a0)
        !           123:             ENDM
        !           124: .base:      scs     d0              ;set returned carry
        !           125:             rts
        !           126: 
        !           127:             
        !           128: ;void P_SETP(short nbits);
        !           129: ; /* sets working precision to specified number of bits. */
        !           130: ; /* only to minimize portation differences              */
        !           131: ;Parameters: --
        !           132: ;Result:     --
        !           133:          
        !           134: P_SETP:                rts
        !           135: 
        !           136: ; ***NOT TESTED***
        !           137: ;
        !           138: ;void P_SMUL(MULTUNIT *prod, MULTUNIT *multiplicand, MULTUNIT multiplier)
        !           139: ; /* multiprecision multiply */
        !           140: ;Parameters: A0.l: prod, A1.l: multiplicand, D0.w: multiplier
        !           141: ;Modifies: D0-D3/A0-A1
        !           142: ;Result:     --
        !           143: 
        !           144: P_SMUL: move.w  global_precision,d3
        !           145:         lsl.w   #1,d3
        !           146:         subq.w  #1,d3
        !           147:         clr.l   d2
        !           148:         clr.l   d1
        !           149: 
        !           150: .loop:  move.w  -(a1),d1
        !           151:         mulu.l  d0,d1
        !           152:         add.l   d2,d1
        !           153:         add.w   d1,-(a0)
        !           154:         scs     d2
        !           155:         lsr.l   #16,d1
        !           156:         add.w   d1,d2
        !           157:         dbf     d3,.loop
        !           158: 
        !           159:         move.w  d2,(a0)
        !           160:         rts
        !           161: 
        !           162: 
        !           163:             END
        !           164: 

unix.superglobalmegacorp.com

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