![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 8086.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [PGP] / pgp / src|
Return to 8086.asm CVS log | Up to [PGP] / pgp / src |
1.1 ! root 1: ; Assembly primitives for RSA multiprecision library ! 2: ; ! 3: ; Tested with Turbo Assembler 1.0 and masm 1.00 ! 4: ; ! 5: ; Written by Branko Lankester ([email protected]) 10/10/91 ! 6: ! 7: ; define LDATA and LCODE as follows: ! 8: ; model: small compact medium large ! 9: ; LDATA 0 1 0 1 ! 10: ; LCODE 0 0 1 1 ! 11: ! 12: LDATA equ 1 ! 13: LCODE equ 1 ! 14: ! 15: IF LDATA ! 16: DSTPTR equ es:[bx+si] ! 17: ELSE ! 18: DSTPTR equ [bx+si] ! 19: ENDIF ! 20: ! 21: IF LCODE ! 22: prec equ [bp+6] ; 1st arg ! 23: r1 equ [bp+6] ; 1st arg ! 24: IF LDATA ! 25: r2 equ [bp+10] ; 2nd arg ! 26: carry equ [bp+14] ; 3rd arg ! 27: scarry equ [bp+10] ; carry for shift (arg 2) ! 28: ELSE ! 29: r2 equ [bp+8] ! 30: carry equ [bp+10] ! 31: scarry equ [bp+8] ! 32: ENDIF ! 33: ELSE ; small code model ! 34: prec equ [bp+4] ! 35: r1 equ [bp+4] ! 36: IF LDATA ! 37: r2 equ [bp+8] ! 38: carry equ [bp+12] ! 39: scarry equ [bp+8] ! 40: ELSE ! 41: r2 equ [bp+6] ! 42: carry equ [bp+8] ! 43: scarry equ [bp+6] ! 44: ENDIF ! 45: ENDIF ! 46: ! 47: ! 48: _TEXT segment byte public 'CODE' ! 49: DGROUP group _DATA,_BSS ! 50: assume cs:_TEXT,ds:DGROUP ! 51: _TEXT ends ! 52: ! 53: _DATA segment word public 'DATA' ! 54: _DATA ends ! 55: ! 56: _BSS segment word public 'BSS' ! 57: prec16 dw ? ; precision / 16 (seems to be / 256?) ! 58: unitprec dw ? ; precision / 16, really ! 59: addp dw ? ; jump offset ! 60: subp dw ? ! 61: rotp dw ? ! 62: mulp dw ? ! 63: _BSS ends ! 64: ! 65: _TEXT segment byte public 'CODE' ! 66: ! 67: public _P_SETP ! 68: public _P_ADDC ! 69: public _P_SUBB ! 70: public _P_ROTL ! 71: ! 72: IF LCODE ! 73: fprims proc far ; dummy proc ! 74: ELSE ! 75: fprims proc near ! 76: ENDIF ! 77: ! 78: ; ! 79: ; ******************** set precision ******************** ! 80: ; ! 81: _P_SETP: ! 82: push bp ! 83: mov bp,sp ! 84: mov ax, prec ; precision in bits ! 85: add ax, 0fh ! 86: mov cl,4 ! 87: shr ax,cl ; prec. in units ! 88: mov unitprec,ax ! 89: push ax ! 90: shr ax,cl ! 91: mov prec16,ax ; precision / 16 ! 92: pop ax ! 93: and ax,0fh ; al = prec % 16 ! 94: mov bx,ax ! 95: mov cx,ax ! 96: shl bx,1 ; multiply by 4 (=number of bytes ! 97: shl bx,1 ; in instruction sequence) ! 98: mov dx,bx ! 99: IFE LDATA ! 100: sub dx,ax ; small model only 3 for add/sub ! 101: ENDIF ! 102: mov ax,offset add_ref ! 103: sub ax,dx ! 104: mov addp,ax ! 105: ! 106: mov ax,offset sub_ref ! 107: sub ax,dx ! 108: mov subp,ax ! 109: ! 110: mov ax,offset rot_ref ! 111: sub ax,bx ! 112: mov rotp,ax ! 113: ! 114: mov ax,offset mul_ref ! 115: shl bx,1 ; MULU macro is 17 bytes for large data ! 116: shl bx,1 ! 117: sub ax,bx ! 118: sub ax,cx ! 119: mov mulp,ax ! 120: ! 121: pop bp ! 122: ret ! 123: ! 124: ! 125: ! 126: ; ! 127: ; ******************** mpi add with carry ******************** ! 128: ; ! 129: ADDU macro n ! 130: rept n ! 131: lodsw ! 132: adc DSTPTR,ax ! 133: endm ! 134: endm ! 135: ! 136: ! 137: _P_ADDC: ! 138: push bp ! 139: mov bp,sp ! 140: push si ! 141: mov cx, prec16 ! 142: mov dx, addp ! 143: IF LDATA ! 144: push ds ! 145: lds si, dword ptr r2 ! 146: les bx, dword ptr r1 ! 147: ELSE ! 148: mov si, r2 ! 149: mov bx, r1 ! 150: ENDIF ! 151: sub bx, si ; calculate relative offset ! 152: dec bx ! 153: dec bx ! 154: cld ! 155: shr byte ptr carry,1 ; load carry ! 156: jcxz add_units ! 157: add_16u: ! 158: ADDU 16 ! 159: loop add_16u ! 160: add_units: ! 161: jmp dx ! 162: ADDU 15 ! 163: add_ref: ! 164: rcl ax,1 ; return carry ! 165: and ax,1 ! 166: IF LDATA ! 167: pop ds ! 168: ENDIF ! 169: pop si ! 170: pop bp ! 171: ret ! 172: ! 173: ! 174: ! 175: ; ! 176: ; ******************** mpi subtract with borrow ******************** ! 177: ; ! 178: SUBU macro n ! 179: rept n ! 180: lodsw ! 181: sbb DSTPTR,ax ! 182: endm ! 183: endm ! 184: ! 185: ! 186: _P_SUBB: ! 187: push bp ! 188: mov bp,sp ! 189: push si ! 190: mov cx, prec16 ! 191: mov dx, subp ! 192: IF LDATA ! 193: push ds ! 194: lds si, dword ptr r2 ! 195: les bx, dword ptr r1 ! 196: ELSE ! 197: mov si, r2 ! 198: mov bx, r1 ! 199: ENDIF ! 200: sub bx, si ; calculate relative offset ! 201: dec bx ! 202: dec bx ! 203: cld ! 204: shr byte ptr carry,1 ! 205: jcxz sub_units ! 206: sub_16u: ! 207: SUBU 16 ! 208: loop sub_16u ! 209: sub_units: ! 210: jmp dx ! 211: SUBU 15 ! 212: sub_ref: ! 213: rcl ax,1 ; return carry ! 214: and ax,1 ! 215: IF LDATA ! 216: pop ds ! 217: ENDIF ! 218: pop si ! 219: pop bp ! 220: ret ! 221: ! 222: ! 223: ! 224: ; ! 225: ; ******************** mpi rotate left ******************** ! 226: ; ! 227: _P_ROTL: ! 228: push bp ! 229: mov bp,sp ! 230: mov cx, prec16 ! 231: mov dx, rotp ! 232: IF LDATA ! 233: push ds ! 234: lds bx, dword ptr r1 ! 235: ELSE ! 236: mov bx, r1 ! 237: ENDIF ! 238: shr byte ptr scarry,1 ! 239: jcxz rot_units ! 240: rot_16u: ! 241: i = 0 ! 242: rept 16 ! 243: rcl word ptr [bx + i],1 ! 244: i = i + 2 ! 245: endm ! 246: lahf ! 247: add bx,32 ! 248: sahf ! 249: loop rot_16u ! 250: rot_units: ! 251: jmp dx ! 252: rept 15 ! 253: rcl word ptr [bx],1 ! 254: inc bx ! 255: inc bx ! 256: endm ! 257: rot_ref: ! 258: ! 259: rcl ax,1 ! 260: and ax,1 ! 261: IF LDATA ! 262: pop ds ! 263: ENDIF ! 264: pop bp ! 265: ret ! 266: ! 267: fprims endp ! 268: ! 269: _TEXT ends ! 270: ! 271: ! 272: ! 273: ; *************************************************************** ! 274: ; P_SMUL (MULTUNIT *prod, MULTUNIT *multiplicand, MULTUNIT multiplier) ! 275: ; mp_smul routine from Upton's modmult, converted to assembler ! 276: ; ! 277: ; Multiply the single-word multiplier times the multiprecision integer ! 278: ; in multiplicand, accumulating result in prod. The resulting ! 279: ; multiprecision prod will be 1 word longer than the multiplicand. ! 280: ; multiplicand is unit_prec words long. We add into prod, so caller ! 281: ; should zero it out first. ! 282: ; ! 283: ; NOTE: Unlike other functions in the multiprecision arithmetic ! 284: ; library, both multiplicand and prod are pointing at the LSB, ! 285: ; regardless of byte order of the machine. On an 80x86, this makes ! 286: ; no difference. But if this assembly function is implemented ! 287: ; on a 680x0, it becomes important. ! 288: ; *************************************************************** ! 289: ; Variable assignments: ! 290: ; multiplier = [bp+14] ! 291: ; multiplicand = [ds:di] 32-bit pointer ! 292: ; prod = [es:si] 32-bit pointer ! 293: ; unit_prec = cx ! 294: ; p = ax-dx ! 295: ; carry = bx ! 296: UPTON_TEXT SEGMENT WORD PUBLIC 'CODE' ! 297: UPTON_TEXT ENDS ! 298: UPTON_TEXT SEGMENT ! 299: ASSUME CS: UPTON_TEXT ! 300: ASSUME DS: DGROUP ! 301: PUBLIC _P_SMUL ! 302: ! 303: MULU macro n ! 304: rept n ! 305: lodsw ;multiplicand ! 306: mul bp ;multiplier, results (p) to AX/DX ! 307: add ax,bx ;carry ! 308: adc dx,0 ! 309: add ax,WORD PTR es:[di] ! 310: adc dx,0 ! 311: mov bx,dx ;carry ! 312: stosw ! 313: endm ! 314: endm ! 315: ! 316: _P_SMUL PROC FAR ! 317: push bp ! 318: mov bp,sp ! 319: push di ! 320: push si ! 321: push ds ! 322: mov cx,prec16 ! 323: mov ax,mulp ! 324: push ax ! 325: ! 326: sub bx,bx ;carry = 0, store in bx ! 327: ! 328: les di,DWORD PTR [bp+6] ;prod in es:di ! 329: lds si,DWORD PTR [bp+10] ;multiplicand in ds:si ! 330: cld ! 331: mov bp,[bp+14] ! 332: ! 333: or cx,cx ! 334: jnz mul_16u ! 335: jmp mul_units ! 336: mul_16u: ! 337: MULU 16 ! 338: dec cx ! 339: jz mul_units ! 340: jmp mul_16u ! 341: mul_units: ! 342: pop cx ! 343: jmp cx ! 344: MULU 15 ! 345: mul_ref: ! 346: ! 347: ; We know that the high-order word of prod will always be 0 ! 348: mov WORD PTR es:[di],bx ;store carry in prod empty high word ! 349: ! 350: pop ds ! 351: pop si ! 352: pop di ! 353: pop bp ! 354: ret ! 355: ! 356: _P_SMUL ENDP ! 357: UPTON_TEXT ends ! 358: end ! 359:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.