![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to largeint.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / largeint / mips|
Return to largeint.s CVS log | Up to [WindowsNT SDKs] / mstools / samples / largeint / mips |
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: #include "ksmips.h" ! 22: ! 23: SBTTL("Large Integer Add") ! 24: //++ ! 25: // ! 26: // LARGE_INTEGER ! 27: // LargeIntegerAdd ( ! 28: // IN LARGE_INTEGER Addend1, ! 29: // IN LARGE_INTEGER Addend2 ! 30: // ) ! 31: // ! 32: // Routine Description: ! 33: // ! 34: // This function adds a signed large integer to a signed large integer and ! 35: // returns the signed large integer result. ! 36: // ! 37: // Arguments: ! 38: // ! 39: // Addend1 (a2, a3) - Supplies the first addend value. ! 40: // ! 41: // Addend2 (4 * 4(sp), 4 * 5(sp)) - Supplies the second addend value. ! 42: // ! 43: // Return Value: ! 44: // ! 45: // The large integer result is stored at the address supplied by a0. ! 46: // ! 47: //-- ! 48: ! 49: LEAF_ENTRY(LargeIntegerAdd) ! 50: ! 51: lw t0,4 * 4(sp) // get low part of addend2 value ! 52: lw t1,4 * 5(sp) // get high part of addend2 value ! 53: addu t0,t0,a2 // add low parts of large integer ! 54: addu t1,t1,a3 // add high parts of large integer ! 55: sltu t2,t0,a2 // generate carry from low part ! 56: addu t1,t1,t2 // add carry to high part ! 57: sw t0,0(a0) // store low part of result ! 58: sw t1,4(a0) // store high part of result ! 59: move v0,a0 // set function return register ! 60: j ra // return ! 61: ! 62: .end LargeIntegerAdd ! 63: ! 64: SBTTL("Convert Long to Large Integer") ! 65: //++ ! 66: // ! 67: // LARGE_INTEGER ! 68: // ConvertLongToLargeInteger ( ! 69: // IN LONG SignedInteger ! 70: // ) ! 71: // ! 72: // Routine Description: ! 73: // ! 74: // This function converts the a signed integer to a signed large integer ! 75: // and returns the result. ! 76: // ! 77: // Arguments: ! 78: // ! 79: // SignedInteger (a1) - Supplies the value to convert. ! 80: // ! 81: // Return Value: ! 82: // ! 83: // The large integer result is stored at the address supplied by a0. ! 84: // ! 85: //-- ! 86: ! 87: LEAF_ENTRY(ConvertLongToLargeInteger) ! 88: ! 89: sra a2,a1,31 // compute high part of result ! 90: sw a1,0(a0) // store low part of result ! 91: sw a2,4(a0) // store high part of result ! 92: move v0,a0 // set function return register ! 93: j ra // return ! 94: ! 95: .end ConvertLongToLargeInteger ! 96: ! 97: SBTTL("Convert Ulong to Large Integer") ! 98: //++ ! 99: // ! 100: // LARGE_INTEGER ! 101: // ConvertUlongToLargeInteger ( ! 102: // IN LONG UnsignedInteger ! 103: // ) ! 104: // ! 105: // Routine Description: ! 106: // ! 107: // This function converts the an unsigned integer to a signed large ! 108: // integer and returns the result. ! 109: // ! 110: // Arguments: ! 111: // ! 112: // UnsignedInteger (a1) - Supplies the value to convert. ! 113: // ! 114: // Return Value: ! 115: // ! 116: // The large integer result is stored at the address supplied by a0. ! 117: // ! 118: //-- ! 119: ! 120: LEAF_ENTRY(ConvertUlongToLargeInteger) ! 121: ! 122: sw a1,0(a0) // store low part of result ! 123: sw zero,4(a0) // store high part of result ! 124: move v0,a0 // set function return register ! 125: j ra // return ! 126: ! 127: .end ConvertUlongToLargeInteger ! 128: ! 129: SBTTL("Enlarged Signed Integer Multiply") ! 130: //++ ! 131: // ! 132: // LARGE_INTEGER ! 133: // EnlargedIntegerMultiply ( ! 134: // IN LONG Multiplicand, ! 135: // IN LONG Multiplier ! 136: // ) ! 137: // ! 138: // Routine Description: ! 139: // ! 140: // This function multiplies a signed integer by an signed integer and ! 141: // returns a signed large integer result. ! 142: // ! 143: // Arguments: ! 144: // ! 145: // Multiplicand (a1) - Supplies the multiplicand value. ! 146: // ! 147: // Multiplier (a2) - Supplies the multiplier value. ! 148: // ! 149: // Return Value: ! 150: // ! 151: // The large integer result is stored at the address supplied by a0. ! 152: // ! 153: //-- ! 154: ! 155: LEAF_ENTRY(EnlargedIntegerMultiply) ! 156: ! 157: mult a1,a2 // multiply longword value ! 158: mflo t0 // get low 32-bits of result ! 159: mfhi t1 // get high 32-bits of result ! 160: sw t0,0(a0) // set low part of result ! 161: sw t1,4(a0) // set high part of result ! 162: move v0,a0 // set function return register ! 163: j ra // return ! 164: ! 165: .end EnlargedIntegerMultiply) ! 166: ! 167: SBTTL("Enlarged Unsigned Integer Multiply") ! 168: //++ ! 169: // ! 170: // LARGE_INTEGER ! 171: // EnlargedUnsignedMultiply ( ! 172: // IN ULONG Multiplicand, ! 173: // IN ULONG Multiplier ! 174: // ) ! 175: // ! 176: // Routine Description: ! 177: // ! 178: // This function multiplies an unsigned integer by an unsigned integer ! 179: // and returns a signed large integer result. ! 180: // ! 181: // Arguments: ! 182: // ! 183: // Multiplicand (a1) - Supplies the multiplicand value. ! 184: // ! 185: // Multiplier (a2) - Supplies the multiplier value. ! 186: // ! 187: // Return Value: ! 188: // ! 189: // The large integer result is stored at the address supplied by a0. ! 190: // ! 191: //-- ! 192: ! 193: LEAF_ENTRY(EnlargedUnsignedMultiply) ! 194: ! 195: multu a1,a2 // multiply longword value ! 196: mflo t0 // get low 32-bits of result ! 197: mfhi t1 // get high 32-bits of result ! 198: sw t0,0(a0) // set low part of result ! 199: sw t1,4(a0) // set high part of result ! 200: move v0,a0 // set function return register ! 201: j ra // return ! 202: ! 203: .end EnlargedUnsignedMultiply) ! 204: ! 205: SBTTL("Enlarged Unsigned Divide") ! 206: //++ ! 207: // ! 208: // ULONG ! 209: // EnlargedUnsignedDivide ( ! 210: // IN ULARGE_INTEGER Dividend, ! 211: // IN ULONG Divisor, ! 212: // IN PULONG Remainder. ! 213: // ) ! 214: // ! 215: // Routine Description: ! 216: // ! 217: // This function divides an unsigned large integer by an unsigned long ! 218: // and returns the resultant quotient and optionally the remainder. ! 219: // ! 220: // N.B. It is assumed that no overflow will occur. ! 221: // ! 222: // Arguments: ! 223: // ! 224: // Dividend (a0, a1) - Supplies the dividend value. ! 225: // ! 226: // Divisor (a2) - Supplies the divisor value. ! 227: // ! 228: // Remainder (a3) - Supplies an optional pointer to a variable that ! 229: // receives the remainder. ! 230: // ! 231: // Return Value: ! 232: // ! 233: // The unsigned long integer quotient is returned as the function value. ! 234: // ! 235: //-- ! 236: ! 237: LEAF_ENTRY(EnlargedUnsignedDivide) ! 238: ! 239: .set noreorder ! 240: .set noat ! 241: beq zero,a2,20f // if eq, attempted division by zero ! 242: sltu v1,a1,a2 // check if overflow will occur ! 243: beq zero,v1,30f // if eq, overflow will occur ! 244: li t1,31 // set loop count ! 245: 10: sra t2,a1,31 // replicate partial remainder high bit ! 246: sll a1,a1,1 // shift next dividend bit ! 247: srl t0,a0,31 // into the partial remainder ! 248: or a1,a1,t0 // ! 249: sltu t0,a1,a2 // check if partial remainder less ! 250: subu t0,t0,1 // convert to 0 or -1 ! 251: or t0,t0,t2 // merge with partial remainder high bit ! 252: and t3,t0,a2 // select divisor or zero ! 253: sll a0,a0,1 // left shift quotient ! 254: subu a0,a0,t0 // merge quotient bit ! 255: subu a1,a1,t3 // subtract out divisor ! 256: bne zero,t1,10b // if ne, more iterations to go ! 257: subu t1,t1,1 // decrement iteration count ! 258: beq zero,a3,40f // if eq, remainder not requested ! 259: move v0,a0 // set quotient value ! 260: j ra // return ! 261: sw a1,0(a3) // store longword remainder ! 262: .set at ! 263: .set reorder ! 264: ! 265: 20: break DIVIDE_BY_ZERO_BREAKPOINT // attempted division by zero ! 266: j ra // ! 267: ! 268: 30: break DIVIDE_OVERFLOW_BREAKPOINT // division value overflows result ! 269: 40: j ra // ! 270: ! 271: .end EnlargedUnsignedDivide ! 272: ! 273: SBTTL("Extended Large Integer Divide") ! 274: //++ ! 275: // ! 276: // LARGE_INTEGER ! 277: // ExtendedLargeIntegerDivide ( ! 278: // IN LARGE_INTEGER Dividend, ! 279: // IN ULONG Divisor, ! 280: // IN PULONG Remainder. ! 281: // ) ! 282: // ! 283: // Routine Description: ! 284: // ! 285: // This function divides an unsigned large integer by an unsigned long ! 286: // and returns the resultant quotient and optionally the remainder. ! 287: // ! 288: // Arguments: ! 289: // ! 290: // Dividend (a2, a3) - Supplies the dividend value. ! 291: // ! 292: // Divisor (4 * 4(sp)) - Supplies the divisor value. ! 293: // ! 294: // Remainder (4 * 5(sp)- Supplies an optional pointer to a variable ! 295: // that receives the remainder. ! 296: // ! 297: // Return Value: ! 298: // ! 299: // The large integer result is stored at the address supplied by a0. ! 300: // ! 301: //-- ! 302: ! 303: LEAF_ENTRY(ExtendedLargeIntegerDivide) ! 304: ! 305: .set noreorder ! 306: .set noat ! 307: move v0,a0 // set function return register ! 308: lw a1,4 * 4(sp) // get divisor value ! 309: lw t0,4 * 5(sp) // get address to store remainder ! 310: beq zero,a1,30f // if eq, attempted division by zero ! 311: li t1,63 // set loop count ! 312: move t2,zero // clear partial remainder ! 313: 10: sra t3,t2,31 // replicate partial remainder high bit ! 314: sll t2,t2,1 // shift next dividend bit ! 315: srl t4,a3,31 // into the partial remainder ! 316: or t2,t2,t4 // ! 317: sll a3,a3,1 // double left shift dividend ! 318: srl t4,a2,31 // ! 319: or a3,a3,t4 // ! 320: sltu t4,t2,a1 // check if partial remainder less ! 321: subu t4,t4,1 // convert to 0 or -1 ! 322: or t4,t4,t3 // merge with partial remainder high bit ! 323: and t5,t4,a1 // select divisor or 0 ! 324: sll a2,a2,1 // ! 325: subu a2,a2,t4 // merge quotient bit ! 326: subu t2,t2,t5 // subtract out divisor ! 327: bne zero,t1,10b // if ne, more iterations to go ! 328: subu t1,t1,1 // decrement iteration count ! 329: beq zero,t0,20f // if eq, remainder not requested ! 330: sw a2,0(a0) // store low part of quotient ! 331: sw t2,0(t0) // store longword remainder ! 332: 20: j ra // return ! 333: sw a3,4(a0) // store high part of quotient ! 334: .set at ! 335: .set reorder ! 336: ! 337: 30: break DIVIDE_BY_ZERO_BREAKPOINT // attempted division by zero ! 338: j ra // ! 339: ! 340: .end ExtendedLargeIntegerDivide ! 341: ! 342: SBTTL("Extended Magic Divide") ! 343: //++ ! 344: // ! 345: // LARGE_INTEGER ! 346: // ExtendedMagicDivide ( ! 347: // IN LARGE_INTEGER Dividend, ! 348: // IN LARGE_INTEGER MagicDivisor, ! 349: // IN CCHAR ShiftCount ! 350: // ) ! 351: // ! 352: // Routine Description: ! 353: // ! 354: // This function divides a signed large integer by an unsigned large integer ! 355: // and returns the signed large integer result. The division is performed ! 356: // using reciprocal multiplication of a signed large integer value by an ! 357: // unsigned large integer fraction which represents the most significant ! 358: // 64-bits of the reciprocal divisor rounded up in its least significant bit ! 359: // and normalized with respect to bit 63. A shift count is also provided ! 360: // which is used to truncate the fractional bits from the result value. ! 361: // ! 362: // Arguments: ! 363: // ! 364: // Dividend (a2, a3) - Supplies the dividend value. ! 365: // ! 366: // MagicDivisor (4 * 4(sp), 4 * 5(sp)) - Supplies the magic divisor value ! 367: // which is a 64-bit multiplicative reciprocal. ! 368: // ! 369: // Shiftcount (4 * 6(sp)) - Supplies the right shift adjustment value. ! 370: // ! 371: // Return Value: ! 372: // ! 373: // The large integer result is stored at the address supplied by a0. ! 374: // ! 375: //-- ! 376: ! 377: LEAF_ENTRY(ExtendedMagicDivide) ! 378: ! 379: move t0,a2 // assume dividend is positive ! 380: move t1,a3 // ! 381: bgez a3,10f // if gez, positive dividend ! 382: subu t0,zero,t0 // negate low part of dividend ! 383: subu t1,zero,t1 // negate high part of dividend ! 384: sltu t2,zero,t0 // set borrow from high part ! 385: subu t1,t1,t2 // subtract out out borrow ! 386: 10: lw a1,4 * 4(sp) // get low part of magic dividor ! 387: lw t2,4 * 5(sp) // get high part of magic divisor ! 388: lbu v0,4 * 6(sp) // get shift count ! 389: ! 390: // ! 391: // Compute low 32-bits of dividend times low 32-bits of divisor. ! 392: // ! 393: ! 394: multu t0,a1 // ! 395: mfhi t3 // save high 32-bits of product ! 396: ! 397: // ! 398: // Compute low 32-bits of dividend time high 32-bits of divisor. ! 399: // ! 400: ! 401: multu t0,t2 // ! 402: mflo t4 // save low 32-bits of product ! 403: mfhi t5 // save high 32-bits of product ! 404: ! 405: // ! 406: // Compute high 32-bits of dividend times low 32-bits of divisor. ! 407: // ! 408: ! 409: multu t1,a1 // ! 410: mflo t6 // save loow 32-bits of product ! 411: mfhi t7 // save high 32-bits of product ! 412: ! 413: // ! 414: // Compute high 32-bits of dividend times high 32-bits of divisor. ! 415: // ! 416: ! 417: multu t1,t2 // ! 418: mflo t8 // save low 32-bits of product ! 419: mfhi t9 // save high 32-bits of product ! 420: ! 421: // ! 422: // Add partial results to form high 64-bits of result. ! 423: // ! 424: ! 425: addu t0,t3,t4 // ! 426: sltu t1,t0,t4 // generate carry ! 427: addu t0,t0,t6 // ! 428: sltu t2,t0,t6 // generate carry ! 429: addu t2,t1,t2 // combine carries ! 430: addu t1,t2,t5 // ! 431: sltu t2,t1,t5 // generate carry ! 432: addu t1,t1,t7 // ! 433: sltu t3,t1,t7 // generate carry ! 434: addu t2,t2,t3 // combine carries ! 435: addu t1,t1,t8 // ! 436: sltu t3,t1,t8 // generate carry ! 437: addu t2,t2,t3 // combine carries ! 438: addu t2,t2,t9 // ! 439: ! 440: // ! 441: // Right shift the result by the specified shift count and negate result ! 442: // if necessary. ! 443: // ! 444: ! 445: li v1,32 // compute left shift count ! 446: subu v1,v1,v0 // ! 447: bgtz v1,20f // if gtz, shift less that 32-bits ! 448: ! 449: // ! 450: // Shift count is greater than or equal 32 bits - high half of result is zero, ! 451: // low half is the high half shifted right by remaining count. ! 452: // ! 453: ! 454: move t1,zero // set high half of result ! 455: srl t0,t2,v0 // set low half of result ! 456: b 30f // ! 457: ! 458: // ! 459: // Shift count is less than 32-bits - high half of result is the high half ! 460: // of product shifted right by count, low half of result is the shifted out ! 461: // bits of the high half combined with the rigth shifted low half of the ! 462: // product. ! 463: // ! 464: ! 465: 20: srl t0,t1,v0 // shift low half right count bits ! 466: srl t1,t2,v0 // shift high half right count bits ! 467: beq zero,v0,30f // if eq, no more shifts necessary ! 468: sll t2,t2,v1 // isolate shifted out bits of high half ! 469: or t0,t0,t2 // combine bits for low half of result ! 470: ! 471: // ! 472: // Negate result if neccessary. ! 473: // ! 474: ! 475: 30: bgez a3,40f // if gez, positive result ! 476: subu t0,zero,t0 // negate low half of result ! 477: subu t1,zero,t1 // negate high half of result ! 478: beq zero,t0,40f // if eq, negation complete ! 479: subu t1,t1,1 // convert high part to ones complement ! 480: 40: sw t0,0(a0) // store low half of result ! 481: sw t1,4(a0) // store high half of result ! 482: move v0,a0 // set function return register ! 483: j ra // return ! 484: ! 485: .end ExtendedMagicDivide ! 486: ! 487: SBTTL("Large Integer Divide") ! 488: //++ ! 489: // ! 490: // LARGE_INTEGER ! 491: // LargeIntegerDivide ( ! 492: // IN LARGE_INTEGER Dividend, ! 493: // IN LARGE_INTEGER Divisor, ! 494: // IN PLARGE_INTEGER Remainder. ! 495: // ) ! 496: // ! 497: // Routine Description: ! 498: // ! 499: // This function divides an unsigned large integer by an unsigned ! 500: // large and returns the resultant quotient and optionally the remainder. ! 501: // ! 502: // Arguments: ! 503: // ! 504: // Dividend (a2, a3) - Supplies the dividend value. ! 505: // ! 506: // Divisor (4 * 4(sp), 4 * 5(sp)) - Supplies the divisor value. ! 507: // ! 508: // Remainder (4 * 6(sp)- Supplies an optional pointer to a variable ! 509: // that receives the remainder. ! 510: // ! 511: // Return Value: ! 512: // ! 513: // The large integer result is stored at the address supplied by a0. ! 514: // ! 515: //-- ! 516: ! 517: LEAF_ENTRY(LargeIntegerDivide) ! 518: ! 519: .set noreorder ! 520: .set noat ! 521: move v0,a0 // set function return register ! 522: lw a1,4 * 4(sp) // get low part of divisor ! 523: lw t0,4 * 5(sp) // get high part of divisor ! 524: lw t1,4 * 6(sp) // get address to store remainder ! 525: or v1,t0,a1 // combine low and high parts ! 526: beq zero,v1,60f // if eq, attempted division by zero ! 527: li t2,63 // set loop count ! 528: move t3,zero // clear partial remainder ! 529: move t4,zero // ! 530: 10: sll t4,t4,1 // shift next dividend bit ! 531: srl t5,t3,31 // into the partial remainder ! 532: or t4,t4,t5 // ! 533: sll t3,t3,1 // ! 534: srl t5,a3,31 // ! 535: or t3,t3,t5 // ! 536: sll a3,a3,1 // double left shift dividend ! 537: srl t5,a2,31 // ! 538: or a3,a3,t5 // ! 539: sltu t5,t4,t0 // check if partial remainder less ! 540: beq zero,t5,20f // if eq, partial remainder not less ! 541: sll a2,a2,1 // ! 542: bne zero,t2,10b // if ne, more iterations to go ! 543: subu t2,t2,1 // decrement iteration count ! 544: beq zero,t1,50f // if eq, remainder not requested ! 545: sw a2,0(a0) // store low part of quotient ! 546: sw t3,0(t1) // store large integer remainder ! 547: sw t4,4(t1) // ! 548: j ra // return ! 549: sw a3,4(a0) // store high part of quotient ! 550: ! 551: 20: bne t0,t4,30f // if ne, partial remainder greater ! 552: sltu t5,t3,a1 // check is partial remainder less ! 553: bne zero,t5,40f // if ne, partial remainder less ! 554: nop // ! 555: 30: or a2,a2,1 // merge quotient bit ! 556: subu t4,t4,t0 // subtract out divisor high part ! 557: sltu t5,t3,a1 // set borrow from high part ! 558: subu t4,t4,t5 // subtract borrow from high part ! 559: subu t3,t3,a1 // subtract out divisor low ! 560: 40: bne zero,t2,10b // if ne, more iterations to go ! 561: subu t2,t2,1 // decrement iteration count ! 562: beq zero,t1,50f // if eq, remainder not requested ! 563: sw a2,0(a0) // store low part of quotient ! 564: sw t3,0(t1) // store large integer remainder ! 565: sw t4,4(t1) // ! 566: 50: j ra // return ! 567: sw a3,4(a0) // store high part of quotient ! 568: .set at ! 569: .set reorder ! 570: ! 571: 60: break DIVIDE_BY_ZERO_BREAKPOINT // attempted division by zero ! 572: j ra // ! 573: ! 574: .end LargeIntegerDivide ! 575: ! 576: SBTTL("Extended Integer Multiply") ! 577: //++ ! 578: // ! 579: // LARGE_INTEGER ! 580: // ExtendedIntegerMultiply ( ! 581: // IN LARGE_INTEGER Multiplicand, ! 582: // IN ULONG Multiplier ! 583: // ) ! 584: // ! 585: // Routine Description: ! 586: // ! 587: // This function multiplies a signed large integer by a signed integer and ! 588: // returns the signed large integer result. ! 589: // ! 590: // Arguments: ! 591: // ! 592: // Multiplicand (a2, a3) - Supplies the multiplicand value. ! 593: // ! 594: // Multiplier (4 * 4(sp)) - Supplies the multiplier value. ! 595: // ! 596: // Return Value: ! 597: // ! 598: // The large integer result is stored at the address supplied by a0. ! 599: // ! 600: //-- ! 601: ! 602: LEAF_ENTRY(ExtendedIntegerMultiply) ! 603: ! 604: lw a1,4 * 4(sp) // get multiplier value ! 605: xor t9,a1,a3 // compute sign of result ! 606: move t0,a1 // assume multiplier positive ! 607: bgez a1,10f // if gez, positive multiplier ! 608: subu t0,zero,t0 // negate multiplier ! 609: 10: move t1,a2 // assume multiplicand positive ! 610: move t2,a3 // ! 611: bgez a3,20f // if gez, positive multiplicand ! 612: subu t1,zero,t1 // negate multiplicand ! 613: subu t2,zero,t2 // ! 614: sltu t3,zero,t1 // compute borrow from high part ! 615: subu t2,t2,t3 // subtract out borrow ! 616: ! 617: // ! 618: // Compute low 32-bits of multiplier times the low 32-bit of multiplicand. ! 619: // ! 620: ! 621: 20: multu t0,t1 // ! 622: mflo t4 // save low 32-bits of product ! 623: mfhi t5 // save high 32-bits of product ! 624: ! 625: // ! 626: // Compute low 32-bits of multiplier times the high 32-bits of multiplicand. ! 627: // ! 628: ! 629: multu t0,t2 // ! 630: mflo t6 // save low 32-bits of product ! 631: mfhi t7 // save high 32-bits of product ! 632: ! 633: // ! 634: // Add partial results to form high 64-bits of result. ! 635: // ! 636: ! 637: addu t5,t5,t6 // ! 638: sltu t3,t5,t6 // generate carry ! 639: addu t6,t3,t7 // ! 640: ! 641: // ! 642: // Negate result if neccessary. ! 643: // ! 644: ! 645: bgez t9,40f // if gez, positive result ! 646: subu t4,zero,t4 // negate low half of result ! 647: subu t5,zero,t5 // negate high half of result ! 648: subu t6,zero,t6 // negate extended part of result ! 649: beq zero,t4,30f // if eq, negation complete ! 650: subu t5,t5,1 // convert high part to ones complement ! 651: subu t6,t6,1 // convert extended part to ones complement ! 652: b 40f // ! 653: ! 654: 30: beq zero,t5,40f // if eq, negation complete ! 655: subu t6,t6,1 // convert extended part to ones complement ! 656: ! 657: // ! 658: // Check for result overflow. ! 659: // ! 660: ! 661: 40: sra t0,t5,31 // compute sign of high part ! 662: beq t0,t6,50f // if eq, no overflow ! 663: lui t0,0x8000 // get largest negative number ! 664: add t0,t0,t0 // cause overflow exception ! 665: 50: sw t4,0(a0) // store low half of result ! 666: sw t5,4(a0) // store high half of result ! 667: move v0,a0 // set function return register ! 668: j ra // return ! 669: ! 670: .end ExtendedIntegerMultiply ! 671: ! 672: SBTTL("Large Integer Negate") ! 673: //++ ! 674: // ! 675: // LARGE_INTEGER ! 676: // LargeIntegerNegate ( ! 677: // IN LARGE_INTEGER Subtrahend ! 678: // ) ! 679: // ! 680: // Routine Description: ! 681: // ! 682: // This function negates a signed large integer and returns the signed ! 683: // large integer result. ! 684: // ! 685: // Arguments: ! 686: // ! 687: // Subtrahend (a2, a3) - Supplies the subtrahend value. ! 688: // ! 689: // Return Value: ! 690: // ! 691: // The large integer result is stored at the address supplied by a0. ! 692: // ! 693: //-- ! 694: ! 695: LEAF_ENTRY(LargeIntegerNegate) ! 696: ! 697: subu a2,zero,a2 // negate low part of subtrahend ! 698: subu a3,zero,a3 // negate high part of subtrahend ! 699: sltu t0,zero,a2 // compute borrow from high part ! 700: subu a3,a3,t0 // subtract borrow from high part ! 701: sw a2,0(a0) // store low part of result ! 702: sw a3,4(a0) // store high part of result ! 703: move v0,a0 // set function return register ! 704: j ra // return ! 705: ! 706: .end LargeIntegerNegate ! 707: ! 708: SBTTL("Large Integer Subtract") ! 709: //++ ! 710: // ! 711: // LARGE_INTEGER ! 712: // LargeIntegerSubtract ( ! 713: // IN LARGE_INTEGER Minuend, ! 714: // IN LARGE_INTEGER Subtrahend ! 715: // ) ! 716: // ! 717: // Routine Description: ! 718: // ! 719: // This function subtracts a signed large integer from a signed large ! 720: // integer and returns the signed large integer result. ! 721: // ! 722: // Arguments: ! 723: // ! 724: // Minuend (a2, a3) - Supplies the minuend value. ! 725: // ! 726: // Subtrahend (4 * 4(sp), 4 * 5(sp)) - Supplies the subtrahend value. ! 727: // ! 728: // Return Value: ! 729: // ! 730: // The large integer result is stored at the address supplied by a0. ! 731: // ! 732: //-- ! 733: ! 734: LEAF_ENTRY(LargeIntegerSubtract) ! 735: ! 736: lw a1,4 * 4(sp) // get low part of subtrahend ! 737: lw t2,4 * 5(sp) // get high part of subtrahend ! 738: subu t0,a2,a1 // subtract low parts ! 739: subu t1,a3,t2 // subtract high parts ! 740: sltu t3,a2,a1 // generate borrow from high part ! 741: subu t1,t1,t3 // subtract borrow ! 742: sw t0,0(a0) // store low part of result ! 743: sw t1,4(a0) // store high part of result ! 744: move v0,a0 // set function return register ! 745: j ra // return ! 746: ! 747: .end LargeIntegerSubtract ! 748: ! 749: SBTTL("Large Integer Shift Left") ! 750: //++ ! 751: // ! 752: // LARGE_INTEGER ! 753: // LargeIntegerShiftLeft ( ! 754: // IN LARGE_INTEGER LargeInteger, ! 755: // IN CCHAR ShiftCount ! 756: // ) ! 757: // ! 758: // Routine Description: ! 759: // ! 760: // This function shifts a signed large integer left by an unsigned ! 761: // integer modulo 64 and returns the shifted signed large integer ! 762: // result. ! 763: // ! 764: // N.B. No test is made for significant bits shifted out of the result. ! 765: // ! 766: // Arguments: ! 767: // ! 768: // LargeInteger (a2, a3) - Supplies the large integer to be shifted. ! 769: // ! 770: // ShiftCount (4 * 4(sp)) - Supplies the left shift count. ! 771: // ! 772: // Return Value: ! 773: // ! 774: // The large integer result is stored at the address supplied by a0. ! 775: // ! 776: //-- ! 777: ! 778: LEAF_ENTRY(LargeIntegerShiftLeft) ! 779: ! 780: lw a1,4 * 4(sp) // get shift count ! 781: move v0,a0 // set function return register ! 782: and a1,a1,0x3f // truncate shift count mod 64 ! 783: ! 784: // ! 785: // Left shift the operand by the specified shift count. ! 786: // ! 787: ! 788: li v1,32 // compute right shift count ! 789: subu v1,v1,a1 // ! 790: bgtz v1,10f // if gtz, shift less that 32-bits ! 791: ! 792: // ! 793: // Shift count is greater than or equal 32 bits - low half of result is zero, ! 794: // high half is the low half shifted left by remaining count. ! 795: // ! 796: ! 797: sll a3,a2,a1 // set high half of result ! 798: sw zero,0(a0) // store low part of reuslt ! 799: sw a3,4(a0) // store high part of result ! 800: j ra // return ! 801: ! 802: // ! 803: // Shift count is less than 32-bits - high half of result is the high half ! 804: // of operand shifted left by count combined with the low half of the operand ! 805: // shifted right, low half of result is the low half shifted left. ! 806: // ! 807: ! 808: 10: sll a3,a3,a1 // shift high half left count bits ! 809: beq zero,a1,20f // if eq, no more shifts necessary ! 810: srl t0,a2,v1 // isolate shifted out bits of low half ! 811: sll a2,a2,a1 // shift low half left count bits ! 812: or a3,a3,t0 // combine bits for high half of result ! 813: 20: sw a2,0(a0) // store low part of reuslt ! 814: sw a3,4(a0) // store high part of result ! 815: j ra // return ! 816: ! 817: .end LargeIntegerShiftLeft ! 818: ! 819: SBTTL("Large Integer Logical Shift Right") ! 820: //++ ! 821: // ! 822: // LARGE_INTEGER ! 823: // LargeIntegerShiftRight ( ! 824: // IN LARGE_INTEGER LargeInteger, ! 825: // IN CCHAR ShiftCount ! 826: // ) ! 827: // ! 828: // Routine Description: ! 829: // ! 830: // This function shifts an unsigned large integer right by an unsigned ! 831: // integer modulo 64 and returns the shifted unsigned large integer ! 832: // result. ! 833: // ! 834: // Arguments: ! 835: // ! 836: // LargeInteger (a2, a3) - Supplies the large integer to be shifted. ! 837: // ! 838: // ShiftCount (4 * 4(sp)) - Supplies the right shift count. ! 839: // ! 840: // Return Value: ! 841: // ! 842: // The large integer result is stored at the address supplied by a0. ! 843: // ! 844: //-- ! 845: ! 846: LEAF_ENTRY(LargeIntegerShiftRight) ! 847: ! 848: lw a1,4 * 4(sp) // get shift count ! 849: move v0,a0 // set function return register ! 850: and a1,a1,0x3f // truncate shift count mod 64 ! 851: ! 852: // ! 853: // Right shift the operand by the specified shift count. ! 854: // ! 855: ! 856: li v1,32 // compute left shift count ! 857: subu v1,v1,a1 // ! 858: bgtz v1,10f // if gtz, shift less that 32-bits ! 859: ! 860: // ! 861: // Shift count is greater than or equal 32 bits - high half of result is ! 862: // zero, low half is the high half shifted right by remaining count. ! 863: // ! 864: ! 865: srl a2,a3,a1 // set low half of result ! 866: sw a2,0(a0) // store low part of reuslt ! 867: sw zero,4(a0) // store high part of result ! 868: j ra // return ! 869: ! 870: // ! 871: // Shift count is less than 32-bits - high half of result is the high half ! 872: // of operand shifted right by count, low half of result is the shifted out ! 873: // bits of the high half combined with the right shifted low half of the ! 874: // operand. ! 875: // ! 876: ! 877: 10: srl a2,a2,a1 // shift low half right count bits ! 878: beq zero,a1,20f // if eq, no more shifts necessary ! 879: sll t0,a3,v1 // isolate shifted out bits of high half ! 880: srl a3,a3,a1 // shift high half right count bits ! 881: or a2,a2,t0 // combine bits for low half of result ! 882: 20: sw a2,0(a0) // store low part of reuslt ! 883: sw a3,4(a0) // store high part of result ! 884: j ra // return ! 885: ! 886: .end LargeIntegerShiftRight ! 887: ! 888: SBTTL("Large Integer Arithmetic Shift Right") ! 889: //++ ! 890: // ! 891: // LARGE_INTEGER ! 892: // LargeIntegerArithmeticShift ( ! 893: // IN LARGE_INTEGER LargeInteger, ! 894: // IN CCHAR ShiftCount ! 895: // ) ! 896: // ! 897: // Routine Description: ! 898: // ! 899: // This function shifts a signed large integer right by an unsigned ! 900: // integer modulo 64 and returns the shifted signed large integer ! 901: // result. ! 902: // ! 903: // Arguments: ! 904: // ! 905: // LargeInteger (a1, a2) - Supplies the large integer to be shifted. ! 906: // ! 907: // ShiftCount (a3) - Supplies the right shift count. ! 908: // ! 909: // Return Value: ! 910: // ! 911: // The large integer result is stored at the address supplied by a0. ! 912: // ! 913: //-- ! 914: ! 915: LEAF_ENTRY(LargeIntegerArithmeticShift) ! 916: ! 917: lw a1,4 * 4(sp) // get shift count ! 918: move v0,a0 // set function return register ! 919: and a1,a1,0x3f // truncate shift count mod 64 ! 920: ! 921: // ! 922: // Right shift the operand by the specified shift count. ! 923: // ! 924: ! 925: li v1,32 // compute left shift count ! 926: subu v1,v1,a1 // ! 927: bgtz v1,10f // if gtz, shift less that 32-bits ! 928: ! 929: // ! 930: // Shift count is greater than or equal 32 bits - high half of result is ! 931: // zero, low half is the high half shifted right by remaining count. ! 932: // ! 933: ! 934: sra a2,a3,a1 // set low half of result ! 935: sra a3,a3,31 // set high half of result ! 936: sw a2,0(a0) // store low part of reuslt ! 937: sw a3,4(a0) // store high part of result ! 938: j ra // return ! 939: ! 940: // ! 941: // Shift count is less than 32-bits - high half of result is the high half ! 942: // of operand shifted right by count, low half of result is the shifted out ! 943: // bits of the high half combined with the right shifted low half of the ! 944: // operand. ! 945: // ! 946: ! 947: 10: srl a2,a2,a1 // shift low half right count bits ! 948: beq zero,a1,20f // if eq, no more shifts necessary ! 949: sll t0,a3,v1 // isolate shifted out bits of high half ! 950: sra a3,a3,a1 // shift high half right count bits ! 951: or a2,a2,t0 // combine bits for low half of result ! 952: 20: sw a2,0(a0) // store low part of reuslt ! 953: sw a3,4(a0) // store high part of result ! 954: j ra // return ! 955: ! 956: .end LargeIntegerArithmeticShift
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.