![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to largeint.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / largeint / i386|
Return to largeint.asm CVS log | Up to [WindowsNT SDKs] / mstools / samples / largeint / i386 |
1.1 ! root 1: TITLE "Large Integer Arithmetic" ! 2: ;++ ! 3: ; ! 4: ; Module Name: ! 5: ; ! 6: ; largeint.s ! 7: ; ! 8: ; Abstract: ! 9: ; ! 10: ; This module implements routines for performing extended integer ! 11: ; arithmtic. ! 12: ; ! 13: ; Environment: ! 14: ; ! 15: ; Any mode. ! 16: ; ! 17: ; Revision History: ! 18: ; ! 19: ;-- ! 20: ! 21: .386p ! 22: .xlist ! 23: include callconv.inc ; calling convention macros ! 24: .list ! 25: ! 26: ! 27: _TEXT SEGMENT DWORD USE32 PUBLIC 'CODE' ! 28: ASSUME CS:FLAT, DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING ! 29: ! 30: page ,132 ! 31: subttl "LargeIntegerAdd" ! 32: ;++ ! 33: ; ! 34: ; LARGE_INTEGER ! 35: ; LargeIntegerAdd ( ! 36: ; IN LARGE_INTEGER Addend1, ! 37: ; IN LARGE_INTEGER Addend2 ! 38: ; ) ! 39: ; ! 40: ; Routine Description: ! 41: ; ! 42: ; This function adds a signed large integer to a signed large integer and ! 43: ; returns the signed large integer result. ! 44: ; ! 45: ; Arguments: ! 46: ; ! 47: ; (TOS+4) = Addend1 - first addend value ! 48: ; (TOS+12) = Addend2 - second addend value ! 49: ; ! 50: ; Return Value: ! 51: ; ! 52: ; The large integer result is stored in (edx:eax) ! 53: ; ! 54: ;-- ! 55: ! 56: cPublicProc _LargeIntegerAdd ,4 ! 57: cPublicFpo 4,0 ! 58: ! 59: mov eax,[esp]+4 ; (eax)=add1.low ! 60: add eax,[esp]+12 ; (eax)=sum.low ! 61: mov edx,[esp]+8 ; (edx)=add1.hi ! 62: adc edx,[esp]+16 ; (edx)=sum.hi ! 63: stdRET _LargeIntegerAdd ! 64: ! 65: stdENDP _LargeIntegerAdd ! 66: ! 67: ! 68: page ! 69: subttl "Enlarged Integer Multiply" ! 70: ;++ ! 71: ; ! 72: ; LARGE_INTEGER ! 73: ; EnlargedIntegerMultiply ( ! 74: ; IN LONG Multiplicand, ! 75: ; IN LONG Multiplier ! 76: ; ) ! 77: ; ! 78: ; Routine Description: ! 79: ; ! 80: ; This function multiplies a signed integer by an signed integer and ! 81: ; returns a signed large integer result. ! 82: ; ! 83: ; Arguments: ! 84: ; ! 85: ; (TOS+4) = Factor1 ! 86: ; (TOS+8) = Factor2 ! 87: ; ! 88: ; Return Value: ! 89: ; ! 90: ; The large integer result is stored in (edx:eax) ! 91: ; ! 92: ;-- ! 93: ! 94: cPublicProc _EnlargedIntegerMultiply ,2 ! 95: cPublicFpo 2,0 ! 96: ! 97: mov eax,[esp]+4 ; (eax) = factor1 ! 98: imul dword ptr [esp]+8 ; (edx:eax) = signed result ! 99: stdRET _EnlargedIntegerMultiply ! 100: ! 101: stdENDP _EnlargedIntegerMultiply ! 102: ! 103: ! 104: page ! 105: subttl "Enlarged Unsigned Integer Multiply" ! 106: ;++ ! 107: ; ! 108: ; LARGE_INTEGER ! 109: ; EnlargedUnsignedMultiply ( ! 110: ; IN ULONG Multiplicand, ! 111: ; IN ULONG Multiplier ! 112: ; ) ! 113: ; ! 114: ; Routine Description: ! 115: ; ! 116: ; This function multiplies an un signed integer by an unsigned integer and ! 117: ; returns a signed large integer result. ! 118: ; ! 119: ; Arguments: ! 120: ; ! 121: ; (TOS+4) = Factor1 ! 122: ; (TOS+8) = Factor2 ! 123: ; ! 124: ; Return Value: ! 125: ; ! 126: ; The large integer result is stored in (edx:eax) ! 127: ; ! 128: ;-- ! 129: ! 130: cPublicProc _EnlargedUnsignedMultiply ,2 ! 131: cPublicFpo 2,0 ! 132: ! 133: mov eax,[esp]+4 ; (eax) = factor1 ! 134: mul dword ptr [esp]+8 ; (edx:eax) = unsigned result ! 135: stdRET _EnlargedUnsignedMultiply ! 136: ! 137: stdENDP _EnlargedUnsignedMultiply ! 138: ! 139: page ! 140: subttl "Enlarged Unsigned Integer Divide" ! 141: ! 142: ;++ ! 143: ; ! 144: ; ULONG ! 145: ; EnlargedUnsignedDivide ( ! 146: ; IN ULARGE_INTEGER Dividend, ! 147: ; IN ULONG Divisor, ! 148: ; IN PULONG Remainder ! 149: ; ) ! 150: ; ! 151: ; ! 152: ; Routine Description: ! 153: ; ! 154: ; This function divides an unsigned large integer by an unsigned long ! 155: ; and returns the resultant quotient and optionally the remainder. ! 156: ; ! 157: ; N.B. It is assumed that no overflow will occur. ! 158: ; ! 159: ; Arguments: ! 160: ; ! 161: ; Dividend - Supplies the dividend value. ! 162: ; ! 163: ; Divisor - Supplies the divisor value. ! 164: ; ! 165: ; Remainder - Supplies an optional pointer to a variable that ! 166: ; receives the remainder. ! 167: ; ! 168: ; Return Value: ! 169: ; ! 170: ; The unsigned long integer quotient is returned as the function value. ! 171: ; ! 172: ;-- ! 173: ! 174: cPublicProc _EnlargedUnsignedDivide,4 ! 175: cPublicFpo 4,0 ! 176: ! 177: mov eax, [esp+4] ; (eax) = Dividend.LowPart ! 178: mov edx, [esp+8] ; (edx) = Dividend.HighPart ! 179: mov ecx, [esp+16] ; (ecx) = pRemainder ! 180: div dword ptr [esp+12] ; divide by Divisor ! 181: ! 182: or ecx, ecx ; return remainder? ! 183: jnz short @f ! 184: ! 185: stdRET _EnlargedUnsignedDivide ; (eax) = Quotient ! 186: ! 187: align 4 ! 188: @@: mov [ecx], edx ; save remainder ! 189: stdRET _EnlargedUnsignedDivide ; (eax) = Quotient ! 190: ! 191: stdENDP _EnlargedUnsignedDivide ! 192: ! 193: page ! 194: subttl "Extended Large Integer Divide" ! 195: ! 196: ;++ ! 197: ; ! 198: ; LARGE_INTEGER ! 199: ; ExtendedLargeIntegerDivide ( ! 200: ; IN LARGE_INTEGER Dividend, ! 201: ; IN ULONG Divisor, ! 202: ; OUT PULONG Remainder OPTIONAL ! 203: ; ) ! 204: ; ! 205: ; Routine Description: ! 206: ; ! 207: ; This routine divides an unsigned 64 bit dividend by a 32 bit divisor ! 208: ; and returns a 64-bit quotient, and optionally the 32-bit remainder. ! 209: ; ! 210: ; ! 211: ; Arguments: ! 212: ; ! 213: ; Dividend - Supplies the 64 bit dividend for the divide operation. ! 214: ; ! 215: ; Divisor - Supplies the 32 bit divisor for the divide operation. ! 216: ; ! 217: ; Remainder - Supplies an optional pointer to a variable which receives ! 218: ; the remainder ! 219: ; ! 220: ; Return Value: ! 221: ; ! 222: ; The 64-bit quotient is returned as the function value. ! 223: ; ! 224: ;-- ! 225: ! 226: cPublicProc _ExtendedLargeIntegerDivide, 4 ! 227: cPublicFpo 4,3 ! 228: ! 229: push esi ! 230: push edi ! 231: push ebx ! 232: ! 233: mov eax, [esp+16] ; (eax) = Dividend.LowPart ! 234: mov edx, [esp+20] ; (edx) = Dividend.HighPart ! 235: ! 236: lid00: mov ebx, [esp+24] ; (ebx) = Divisor ! 237: or ebx, ebx ! 238: jz short lid_zero ; Attempted a divide by zero ! 239: ! 240: push ebp ! 241: ! 242: mov ecx, 64 ; Loop count ! 243: xor esi, esi ; Clear partial remainder ! 244: ! 245: ; (edx:eax) = Dividend ! 246: ; (ebx) = Divisor ! 247: ; (ecx) = Loop count ! 248: ; (esi) = partial remainder ! 249: ! 250: align 4 ! 251: lid10: shl eax, 1 ; (LowPart << 1) | 0 ! 252: rcl edx, 1 ; (HighPart << 1) | CF ! 253: rcl esi, 1 ; (Partial << 1) | CF ! 254: ! 255: sbb edi, edi ; clone CF into edi (0 or -1) ! 256: ! 257: cmp esi, ebx ; check if partial remainder less then divisor ! 258: cmc ! 259: sbb ebp, ebp ; clone CF intp ebp ! 260: or edi, ebp ; merge with remainder of high bit ! 261: ! 262: sub eax, edi ; merge quotient bit ! 263: and edi, ebx ; Select divisor or 0 ! 264: sub esi, edi ! 265: ! 266: dec ecx ; dec interration count ! 267: jnz short lid10 ; go around again ! 268: ! 269: pop ebp ! 270: pop ebx ! 271: pop edi ! 272: ! 273: mov ecx, [esp+20] ; (ecx) = Remainder ! 274: or ecx, ecx ! 275: jnz short lid20 ! 276: ! 277: pop esi ! 278: stdRET _ExtendedLargeIntegerDivide ! 279: ! 280: align 4 ! 281: lid20: ! 282: mov [ecx], esi ; store remainder ! 283: pop esi ! 284: stdRET _ExtendedLargeIntegerDivide ! 285: ! 286: lid_zero: ! 287: div dword ptr [esp+24] ; cause divide by zero exception ! 288: pop ebx ! 289: pop edi ! 290: pop esi ! 291: stdRET _ExtendedLargeIntegerDivide ! 292: stdENDP _ExtendedLargeIntegerDivide ! 293: ! 294: page ! 295: subttl "Extended Magic Divide" ! 296: ;++ ! 297: ; ! 298: ; LARGE_INTEGER ! 299: ; ExtendedMagicDivide ( ! 300: ; IN LARGE_INTEGER Dividend, ! 301: ; IN LARGE_INTEGER MagicDivisor, ! 302: ; IN CCHAR ShiftCount ! 303: ; ) ! 304: ; ! 305: ; Routine Description: ! 306: ; ! 307: ; This function divides a signed large integer by an unsigned large integer ! 308: ; and returns the signed large integer result. The division is performed ! 309: ; using reciprocal multiplication of a signed large integer value by an ! 310: ; unsigned large integer fraction which represents the most significant ! 311: ; 64-bits of the reciprocal divisor rounded up in its least significant bit ! 312: ; and normalized with respect to bit 63. A shift count is also provided ! 313: ; which is used to truncate the fractional bits from the result value. ! 314: ; ! 315: ; Arguments: ! 316: ; ! 317: ; (ebp+8) = Dividend ! 318: ; (ebp+16) = MagicDivisor value is a 64-bit multiplicative reciprocal ! 319: ; (ebp+24) = ShiftCount - Right shift adjustment value. ! 320: ; ! 321: ; Return Value: ! 322: ; ! 323: ; The large integer result is stored in (edx:eax) ! 324: ; ! 325: ;-- ! 326: ! 327: RemdDiv equ [ebp+8] ; Dividend ! 328: RemdRec equ [ebp+16] ; Reciprocal (magic divisor) ! 329: RemdShift equ [ebp+24] ! 330: RemdTmp1 equ [ebp-4] ! 331: RemdTmp2 equ [ebp-8] ! 332: RemdTmp3 equ [ebp-12] ! 333: ! 334: cPublicProc _ExtendedMagicDivide ,5 ! 335: ! 336: push ebp ! 337: mov ebp,esp ! 338: sub esp,12 ! 339: push esi ! 340: ! 341: mov esi, RemdDiv+4 ! 342: test esi,80000000h ! 343: jz remd10 ; no sign, no need to negate ! 344: ! 345: neg dword ptr RemdDiv+4 ! 346: neg dword ptr RemdDiv ! 347: sbb dword ptr RemdDiv+4,0 ; negate ! 348: ! 349: remd10: mov eax,RemdRec ! 350: mul dword ptr RemdDiv ; (edx:eax) = Div.lo * Rec.lo ! 351: mov RemdTmp1,edx ! 352: ! 353: mov eax,RemdRec ! 354: mul dword ptr RemdDiv+4 ; (edx:eax) = Div.hi * Rec.lo ! 355: mov RemdTmp2,eax ! 356: mov RemdTmp3,edx ! 357: ! 358: mov eax,RemdRec+4 ! 359: mul dword ptr RemdDiv ; (edx:eax) = Div.lo * Rec.hi ! 360: ! 361: ; ! 362: ; Col 0 doesn't matter ! 363: ; Col 1 = Hi(Div.lo * Rec.lo) + Low(Div.Hi * Rec.lo) + Low(Div.lo * Rec.hi) ! 364: ; = RemdTmp1 + RemdTmp2 + eax ! 365: ; -> Only want carry from Col 1 ! 366: ; ! 367: ! 368: xor ecx,ecx ; (ecx) = 0 ! 369: add eax,RemdTmp1 ! 370: adc ecx, 0 ; save carry in ecx ! 371: add eax,RemdTmp2 ! 372: adc ecx, 0 ; Save Carry, all we want from Col2 ! 373: ! 374: mov RemdTmp1,edx ! 375: ! 376: mov eax,RemdRec+4 ! 377: mul dword ptr RemdDiv+4 ; (edx:eax) = Div.Hi * Rec.Hi ! 378: ! 379: ; ! 380: ; TOS = carry flag from Col 1 ! 381: ; ! 382: ; Col 2 = Col1 CF + ! 383: ; Hi(Div.Hi * Rec.Lo) + Hi(Div.Lo * Rec.Hi) + Low(Div.Hi * Rec.Hi) ! 384: ; = CF + RemdTmp3 + RemdTmp1 + eax ! 385: ; ! 386: ; Col 3 = Col2 CF + Hi(Div.Hi * Rec.Hi) ! 387: ; = CF + edx ! 388: ; ! 389: ! 390: add eax,RemdTmp1 ! 391: adc edx, 0 ; add carry to edx ! 392: add eax,RemdTmp3 ; (eax) = col 2 ! 393: adc edx, 0 ; add carry to edx ! 394: add eax, ecx ! 395: adc edx, 0 ; (edx) = col 3 ! 396: ! 397: ; ! 398: ; (edx:eax) = the high 64 bits of the multiply, shift it right by ! 399: ; shift count to discard bits to right of virtual decimal pt. ! 400: ; ! 401: ; RemdShift could be as large as 63 and still not 0 the result, 386 ! 402: ; will only shift 31 bits at a time, so must do the sift multiple ! 403: ; times to get correct effect. ! 404: ; ! 405: ! 406: mov cl,RemdShift ! 407: remd20: cmp cl,31 ! 408: jbe remd30 ! 409: sub cl,31 ! 410: shrd eax,edx,31 ! 411: shr edx,31 ! 412: jmp remd20 ! 413: ! 414: remd30: shrd eax,edx,cl ! 415: shr edx,cl ! 416: ! 417: ; ! 418: ; Negate the result if need be ! 419: ; ! 420: ! 421: test esi,80000000h ! 422: jz remd40 ; no sign, go return without negate ! 423: ! 424: neg edx ! 425: neg eax ! 426: sbb edx,0 ! 427: ! 428: ; ! 429: ; Store the result ! 430: ; ! 431: ! 432: remd40: ! 433: ; results in (edx:eax) ! 434: ! 435: pop esi ! 436: mov esp,ebp ! 437: pop ebp ! 438: stdRET _ExtendedMagicDivide ! 439: ! 440: stdENDP _ExtendedMagicDivide ! 441: ! 442: ! 443: page ! 444: subttl "Extended Integer Multiply" ! 445: ;++ ! 446: ; ! 447: ; LARGE_INTEGER ! 448: ; ExtendedIntegerMultiply ( ! 449: ; IN LARGE_INTEGER Multiplicand, ! 450: ; IN ULONG Multiplier ! 451: ; ) ! 452: ; ! 453: ; Routine Description: ! 454: ; ! 455: ; This function multiplies a signed large integer by a signed integer and ! 456: ; returns the signed large integer result. ! 457: ; ! 458: ; Arguments: ! 459: ; ! 460: ; (ebp+8,12)=multiplican (MCAN) ! 461: ; (ebp+16)=multiplier (MPER) ! 462: ; ! 463: ; Return Value: ! 464: ; ! 465: ; The large integer result is stored in (edx:eax) ! 466: ; ! 467: ;-- ! 468: ! 469: ReimMCAN equ [ebp+8] ! 470: ReimMPER equ [ebp+16] ! 471: ! 472: cPublicProc _ExtendedIntegerMultiply ,3 ! 473: ! 474: push ebp ! 475: mov ebp,esp ! 476: push esi ! 477: ! 478: mov esi,ReimMPER ! 479: xor esi,ReimMCAN+4 ; (esi) = result sign ! 480: ! 481: test ReimMCAN+4,80000000h ! 482: jz short reim10 ; MCAN pos, go look at MPER ! 483: ! 484: neg dword ptr ReimMCAN+4 ! 485: neg dword ptr ReimMCAN ! 486: sbb dword ptr ReimMCAN+4,0 ; negate multiplican ! 487: ! 488: reim10: test ReimMPER,80000000h ! 489: jz short reim20 ; MPER pos, go do multiply ! 490: ! 491: neg dword ptr ReimMPER ; negate multiplier ! 492: ! 493: reim20: mov eax,ReimMPER ! 494: mul dword ptr ReimMCAN ; (edx:eax) = MPER * MCAN.low ! 495: push edx ! 496: mov ecx, eax ! 497: mov eax,ReimMPER ! 498: mul dword ptr ReimMCAN+4 ; (edx:eax) = MPER * MCAN.high ! 499: add eax,[esp] ; (eax) = hi part of MPER*MCAN.low ! 500: ; plus low part of MPER*MCAN.hi ! 501: ! 502: test esi,80000000h ! 503: jz short reim30 ; result sign is OK, go return ! 504: ! 505: neg eax ! 506: neg ecx ! 507: sbb eax,0 ; negate result ! 508: ! 509: reim30: add esp,4 ; clean eax off stack ! 510: pop esi ; restore nonvolatile reg ! 511: mov edx,eax ; (edx:ecx) = result ! 512: mov eax,ecx ; (edx:eax) = result ! 513: ! 514: pop ebp ! 515: stdRET _ExtendedIntegerMultiply ! 516: ! 517: stdENDP _ExtendedIntegerMultiply ! 518: ! 519: page ! 520: subttl "Large Integer Shift Left" ! 521: ;++ ! 522: ; ! 523: ; LARGE_INTEGER ! 524: ; LargeIntegerShiftLeft ( ! 525: ; IN LARGE_INTEGER LargeInteger, ! 526: ; IN CCHAR ShiftCount ! 527: ; ) ! 528: ; ! 529: ; ! 530: ; Routine Description: ! 531: ; ! 532: ; This routine does a left logical shift of a large integer by a ! 533: ; specified amount (ShiftCount) modulo 64. ! 534: ; ! 535: ; Arguments: ! 536: ; ! 537: ; LargeInteger - Supplies the large integer to be shifted ! 538: ; ! 539: ; ShiftCount - Supplies the left shift count ! 540: ; ! 541: ; Return Value: ! 542: ; ! 543: ; LARGE_INTEGER - Receives the shift large integer result ! 544: ; ! 545: ;-- ! 546: cPublicProc _LargeIntegerShiftLeft,3 ! 547: cPublicFpo 3,0 ! 548: ! 549: mov ecx, [esp+12] ; (ecx) = ShiftCount ! 550: and ecx, 3fh ; mod 64 ! 551: ! 552: cmp ecx, 32 ! 553: jnc short sl10 ! 554: ; ! 555: ; Shift count is less then 32 bits. ! 556: ; ! 557: mov eax, [esp+4] ; (eax) = LargeInteger.LowPart ! 558: mov edx, [esp+8] ; (edx) = LargeInteger.HighPart ! 559: shld edx, eax, cl ! 560: shl eax, cl ! 561: ! 562: stdRET _LargeIntegerShiftLeft ! 563: ! 564: align 4 ! 565: sl10: ! 566: ; ! 567: ; Shift count is greater than or equal 32 bits - low half of result is zero, ! 568: ; high half is the low half shifted left by remaining count. ! 569: ; ! 570: mov edx, [esp+4] ; (edx) = LargeInteger.LowPart ! 571: xor eax, eax ; store lowpart ! 572: shl edx, cl ; store highpart ! 573: ! 574: stdRET _LargeIntegerShiftLeft ! 575: ! 576: stdENDP _LargeIntegerShiftLeft ! 577: ! 578: page ! 579: subttl "Large Integer Shift Right" ! 580: ! 581: ;-- ! 582: ; ! 583: ;LARGE_INTEGER ! 584: ;LargeIntegerShiftRight ( ! 585: ; IN LARGE_INTEGER LargeInteger, ! 586: ; IN CCHAR ShiftCount ! 587: ; ) ! 588: ; ! 589: ;Routine Description: ! 590: ; ! 591: ; This routine does a right logical shift of a large integer by a ! 592: ; specified amount (ShiftCount) modulo 64. ! 593: ; ! 594: ;Arguments: ! 595: ; ! 596: ; LargeInteger - Supplies the large integer to be shifted ! 597: ; ! 598: ; ShiftCount - Supplies the right shift count ! 599: ; ! 600: ;Return Value: ! 601: ; ! 602: ; LARGE_INTEGER - Receives the shift large integer result ! 603: ; ! 604: ;--*/ ! 605: cPublicProc _LargeIntegerShiftRight,3 ! 606: cPublicFpo 3,0 ! 607: ! 608: mov ecx, [esp+12] ; (ecx) = ShiftCount ! 609: and ecx, 3fh ; mod 64 ! 610: ! 611: cmp ecx, 32 ! 612: jnc short sr10 ! 613: ! 614: ; ! 615: ; Shift count is less then 32 bits. ! 616: ; ! 617: mov eax, [esp+4] ; (eax) = LargeInteger.LowPart ! 618: mov edx, [esp+8] ; (edx) = LargeInteger.HighPart ! 619: shrd eax, edx, cl ! 620: shr edx, cl ! 621: ! 622: stdRET _LargeIntegerShiftRight ! 623: ! 624: align 4 ! 625: sr10: ! 626: ; ! 627: ; Shift count is greater than or equal 32 bits - high half of result is zero, ! 628: ; low half is the high half shifted right by remaining count. ! 629: ; ! 630: mov eax, [esp+8] ; (eax) = LargeInteger.HighPart ! 631: xor edx, edx ; store highpart ! 632: shr eax, cl ; store lowpart ! 633: ! 634: stdRET _LargeIntegerShiftRight ! 635: ! 636: stdENDP _LargeIntegerShiftRight ! 637: ! 638: ;++ ! 639: ; ! 640: ;LARGE_INTEGER ! 641: ;LargeIntegerArithmeticShift ( ! 642: ; IN LARGE_INTEGER LargeInteger, ! 643: ; IN CCHAR ShiftCount ! 644: ; ) ! 645: ; ! 646: ;Routine Description: ! 647: ; ! 648: ; This routine does a right arithmetic shift of a large integer by a ! 649: ; specified amount (ShiftCount) modulo 64. ! 650: ; ! 651: ;Arguments: ! 652: ; ! 653: ; LargeInteger - Supplies the large integer to be shifted ! 654: ; ! 655: ; ShiftCount - Supplies the right shift count ! 656: ; ! 657: ;Return Value: ! 658: ; ! 659: ; LARGE_INTEGER - Receives the shift large integer result ! 660: ; ! 661: ;-- ! 662: cPublicProc _LargeIntegerArithmeticShift,3 ! 663: cPublicFpo 3,0 ! 664: ! 665: mov ecx, [esp+12] ; (ecx) = ShiftCount ! 666: and ecx, 3fh ; mod 64 ! 667: ! 668: cmp ecx, 32 ! 669: jc short sar10 ! 670: ! 671: ; ! 672: ; Shift count is greater than or equal 32 bits - high half of result is sign ! 673: ; bit, low half is the high half shifted right by remaining count. ! 674: ; ! 675: mov eax, [esp+8] ; (eax) = LargeInteger.HighPart ! 676: sar eax, cl ; store highpart ! 677: bt eax, 31 ; sign bit set? ! 678: sbb edx, edx ; duplicate sign bit into highpart ! 679: ! 680: stdRET _LargeIntegerArithmeticShift ! 681: ! 682: align 4 ! 683: sar10: ! 684: ; ! 685: ; Shift count is less then 32 bits. ! 686: ; ! 687: ; ! 688: mov eax, [esp+4] ; (eax) = LargeInteger.LowPart ! 689: mov edx, [esp+8] ; (edx) = LargeInteger.HighPart ! 690: shrd eax, edx, cl ! 691: sar edx, cl ! 692: ! 693: stdRET _LargeIntegerArithmeticShift ! 694: ! 695: stdENDP _LargeIntegerArithmeticShift,3 ! 696: ! 697: ! 698: page ! 699: subttl "Large Integer Negate" ! 700: ;++ ! 701: ; ! 702: ; LARGE_INTEGER ! 703: ; LargeIntegerNegate ( ! 704: ; IN LARGE_INTEGER Subtrahend ! 705: ; ) ! 706: ; ! 707: ; Routine Description: ! 708: ; ! 709: ; This function negates a signed large integer and returns the signed ! 710: ; large integer result. ! 711: ; ! 712: ; Arguments: ! 713: ; ! 714: ; (TOS+4) = Subtrahend ! 715: ; ! 716: ; Return Value: ! 717: ; ! 718: ; The large integer result is stored in (edx:eax) ! 719: ; ! 720: ;-- ! 721: ! 722: cPublicProc _LargeIntegerNegate ,2 ! 723: cPublicFpo 2,0 ! 724: ! 725: mov eax,[esp]+4 ; (eax) = lo ! 726: mov edx,[esp]+8 ! 727: neg edx ; (edx) = 2's comp of hi part ! 728: neg eax ; if ((eax) == 0) CF = 0 ! 729: ; else CF = 1 ! 730: sbb edx,0 ; (edx) = (edx) - CF ! 731: ; (edx:eax) = result ! 732: stdRET _LargeIntegerNegate ! 733: ! 734: stdENDP _LargeIntegerNegate ! 735: ! 736: ! 737: page ! 738: subttl "Large Integer Subtract" ! 739: ;++ ! 740: ; ! 741: ; LARGE_INTEGER ! 742: ; LargeIntegerSubtract ( ! 743: ; IN LARGE_INTEGER Minuend, ! 744: ; IN LARGE_INTEGER Subtrahend ! 745: ; ) ! 746: ; ! 747: ; Routine Description: ! 748: ; ! 749: ; This function subtracts a signed large integer from a signed large ! 750: ; integer and returns the signed large integer result. ! 751: ; ! 752: ; Arguments: ! 753: ; ! 754: ; (TOS+4) = Minuend ! 755: ; (TOS+12) = Subtrahend ! 756: ; ! 757: ; Return Value: ! 758: ; ! 759: ; The large integer result is stored in (edx:eax) ! 760: ; ! 761: ;-- ! 762: ! 763: cPublicProc _LargeIntegerSubtract ,4 ! 764: cPublicFpo 4,0 ! 765: ! 766: mov eax,[esp]+4 ! 767: sub eax,[esp]+12 ; (eax) = result.low ! 768: mov edx,[esp]+8 ! 769: sbb edx,[esp]+16 ; (edx) = result.high ! 770: stdRET _LargeIntegerSubtract ! 771: ! 772: stdENDP _LargeIntegerSubtract ! 773: ! 774: page ! 775: subttl "Convert Long to Large Integer" ! 776: ;++ ! 777: ; ! 778: ; LARGE_INTEGER ! 779: ; ConvertLongToLargeInteger ( ! 780: ; IN LONG SignedInteger ! 781: ; ) ! 782: ; ! 783: ; Routine Description: ! 784: ; ! 785: ; This function converts the input signed integer to a signed large ! 786: ; integer and returns the latter as the result. ! 787: ; ! 788: ; Arguments: ! 789: ; ! 790: ; (TOS+4) = SignedInteger ! 791: ; ! 792: ; Return Value: ! 793: ; ! 794: ; The large integer result is stored (edx:eax) ! 795: ; ! 796: ;-- ! 797: ! 798: cPublicProc _ConvertLongToLargeInteger ,1 ! 799: cPublicFpo 1,0 ! 800: ! 801: mov eax,[esp]+4 ; (eax) = SignedInteger ! 802: cdq ; (edx:eax) = signed LargeInt ! 803: stdRET _ConvertLongToLargeInteger ! 804: ! 805: stdENDP _ConvertLongToLargeInteger ! 806: ! 807: ! 808: page ! 809: subttl "Convert Ulong to Large Integer" ! 810: ;++ ! 811: ; ! 812: ; LARGE_INTEGER ! 813: ; ConvertUlongToLargeInteger ( ! 814: ; IN LONG UnsignedInteger ! 815: ; ) ! 816: ; ! 817: ; Routine Description: ! 818: ; ! 819: ; This function converts the input unsigned integer to a signed large ! 820: ; integer and returns the latter as the result. ! 821: ; ! 822: ; Arguments: ! 823: ; ! 824: ; (TOS+4) = UnsignedInteger ! 825: ; ! 826: ; Return Value: ! 827: ; ! 828: ; The large integer result is stored in (edx:eax) ! 829: ; ! 830: ;-- ! 831: ! 832: cPublicProc _ConvertUlongToLargeInteger ,1 ! 833: cPublicFpo 1,0 ! 834: ! 835: mov eax,[esp]+4 ; store low ! 836: xor edx,edx ; store 0 in high ! 837: stdRET _ConvertUlongToLargeInteger ! 838: ! 839: stdENDP _ConvertUlongToLargeInteger ! 840: ! 841: ! 842: _TEXT ends ! 843: end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.