![[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 / alpha|
Return to largeint.s CVS log | Up to [WindowsNT SDKs] / mstools / samples / largeint / alpha |
1.1 root 1: // TITLE("Large Integer Arithmetic")
2: //++
3: //
4: // Copyright (c) 1990 Microsoft Corporation
5: // Copyright (c) 1993 Digital Equipment Corporation
6: //
7: // Module Name:
8: //
9: // largeint.s
10: //
11: // Abstract:
12: //
13: // This module implements routines for performing extended integer
14: // arithmetic.
15: //
16: // Author:
17: //
18: // David N. Cutler (davec) 18-Apr-1990
19: //
20: // Environment:
21: //
22: // Any mode.
23: //
24: // Revision History:
25: //
26: // Thomas Van Baak (tvb) 9-May-1992
27: //
28: // Adapted for Alpha AXP.
29: //
30: //--
31:
32: #include "ksalpha.h"
33:
34: //
35: // Alpha AXP Implementation Notes:
36: //
37: // The LargeInteger functions defined below implement a set of portable
38: // 64-bit integer arithmetic operations for x86, Mips, and Alpha systems
39: // using the LARGE_INTEGER data type. Code using LARGE_INTEGER variables
40: // and calling these functions will be portable across all NT platforms.
41: // This is the recommended approach to 64-bit arithmetic on NT.
42: //
43: // However, if performance is more important than portability, then for
44: // Alpha systems, the native 64-bit integer data types may be used instead
45: // of the LARGE_INTEGER type and the LargeInteger functions. The Alpha C
46: // compilers support a __int64 data type (renamed LONGLONG in the system
47: // header files). All C integer arithmetic operators may be used with
48: // these quadword types. This eliminates the need for, and the overhead
49: // of, any of the portable LargeInteger functions.
50: //
51: // In general, a LARGE_INTEGER cannot simply be converted to a LONGLONG
52: // because of explicit references in application code to the 32-bit LowPart
53: // and HighPart members of the LARGE_INTEGER structure.
54: //
55: // The performance difference between using the portable LARGE_INTEGER
56: // types with LargeInteger functions and the Alpha LONGLONG types and
57: // operations is often not significant enough to warrant modifying otherwise
58: // portable code. In addition, future compiler optimization and inlining may
59: // actually result in identical performance between portable LARGE_INTEGER
60: // code and Alpha specific LONGLONG code. Therefore it is recommended to
61: // keep NT source code portable.
62: //
63: // The Alpha source for the large integer functions below differs from the
64: // Mips version since for Alpha a 64-bit argument or return value is passed
65: // through a 64-bit integer register. In addition, most operations are
66: // implemented with a single instruction. The division routines below,
67: // however, like Mips, use a simple shift/subtract algorithm which is
68: // considerably slower than the algorithm used by Alpha runtime division
69: // routines.
70: //
71:
72: SBTTL("Convert Long to Large Integer")
73: //++
74: //
75: // LARGE_INTEGER
76: // ConvertLongToLargeInteger (
77: // IN LONG SignedInteger
78: // )
79: //
80: // Routine Description:
81: //
82: // This function converts a signed integer to a signed large integer
83: // and returns the result.
84: //
85: // Arguments:
86: //
87: // SignedInteger (a0) - Supplies the value to convert.
88: //
89: // Return Value:
90: //
91: // The large integer result is returned as the function value in v0.
92: //
93: //--
94:
95: LEAF_ENTRY(ConvertLongToLargeInteger)
96:
97: addl a0, 0, v0 // ensure canonical (signed long) form
98: ret zero, (ra) // return
99:
100: .end ConvertLongToLargeInteger
101:
102: SBTTL("Convert Ulong to Large Integer")
103: //++
104: //
105: // LARGE_INTEGER
106: // ConvertUlongToLargeInteger (
107: // IN ULONG UnsignedInteger
108: // )
109: //
110: // Routine Description:
111: //
112: // This function converts an unsigned integer to a signed large
113: // integer and returns the result.
114: //
115: // Arguments:
116: //
117: // UnsignedInteger (a0) - Supplies the value to convert.
118: //
119: // Return Value:
120: //
121: // The large integer result is returned as the function value in v0.
122: //
123: //--
124:
125: LEAF_ENTRY(ConvertUlongToLargeInteger)
126:
127: zap a0, 0xf0, v0 // convert canonical ULONG to quadword
128: ret zero, (ra) // return
129:
130: .end ConvertUlongToLargeInteger
131:
132: SBTTL("Enlarged Signed Integer Multiply")
133: //++
134: //
135: // LARGE_INTEGER
136: // EnlargedIntegerMultiply (
137: // IN LONG Multiplicand,
138: // IN LONG Multiplier
139: // )
140: //
141: // Routine Description:
142: //
143: // This function multiplies a signed integer by a signed integer and
144: // returns a signed large integer result.
145: //
146: // N.B. An overflow is not possible.
147: //
148: // Arguments:
149: //
150: // Multiplicand (a0) - Supplies the multiplicand value.
151: //
152: // Multiplier (a1) - Supplies the multiplier value.
153: //
154: // Return Value:
155: //
156: // The large integer result is returned as the function value in v0.
157: //
158: //--
159:
160: LEAF_ENTRY(EnlargedIntegerMultiply)
161:
162: addl a0, 0, a0 // ensure canonical (signed long) form
163: addl a1, 0, a1 // ensure canonical (signed long) form
164: mulq a0, a1, v0 // multiply signed both quadwords
165: ret zero, (ra) // return
166:
167: .end EnlargedIntegerMultiply
168:
169: SBTTL("Enlarged Unsigned Divide")
170: //++
171: //
172: // ULONG
173: // EnlargedUnsignedDivide (
174: // IN ULARGE_INTEGER Dividend,
175: // IN ULONG Divisor,
176: // IN OUT PULONG Remainder OPTIONAL
177: // )
178: //
179: // Routine Description:
180: //
181: // This function divides an unsigned large integer by an unsigned long
182: // and returns the resultant quotient and optionally the remainder.
183: //
184: // N.B. An overflow or divide by zero exception is possible.
185: //
186: // Arguments:
187: //
188: // Dividend (a0) - Supplies the unsigned 64-bit dividend value.
189: //
190: // Divisor (a1) - Supplies the unsigned 32-bit divisor value.
191: //
192: // Remainder (a2) - Supplies an optional pointer to a variable that
193: // receives the unsigned 32-bit remainder.
194: //
195: // Return Value:
196: //
197: // The unsigned long integer quotient is returned as the function value.
198: //
199: //--
200:
201: LEAF_ENTRY(EnlargedUnsignedDivide)
202:
203: //
204: // Check for division by zero.
205: //
206:
207: zap a1, 0xf0, a1 // convert ULONG divisor to quadword
208: beq a1, 30f // trap if divisor is zero
209:
210: //
211: // Check for overflow. If the divisor is less than the upper half of the
212: // dividend the quotient would be wider than 32 bits.
213: //
214:
215: srl a0, 32, t0 // get upper longword of dividend
216: cmpule a1, t0, t1 // is divisor <= upper dividend?
217: bne t1, 40f // if ne[true], then overflow trap
218:
219: //
220: // Perform the shift/subtract loop 8 times and 4 bits per loop.
221: //
222: // t0 - Temp used for 0/1 results of compares.
223: // t1 - High 64-bits of 128-bit (t1, a0) dividend.
224: // t2 - Loop counter.
225: //
226:
227: ldiq t2, 32/4 // set iteration count
228:
229: srl a0, 32, t1 // get top 32 bits of carry-out
230: sll a0, 32, a0 // preshift first 32 bits left
231:
232: 10: cmplt a0, 0, t0 // predict low-dividend shift carry-out
233: addq a0, a0, a0 // shift low-dividend left
234: addq t1, t1, t1 // shift high-dividend left
235: bis t1, t0, t1 // merge in carry-out of low-dividend
236:
237: cmpule a1, t1, t0 // if dividend >= divisor,
238: addq a0, t0, a0 // then set quotient bit
239: subq t1, a1, t0 // subtract divisor from dividend,
240: cmovlbs a0, t0, t1 // if dividend >= divisor
241:
242: cmplt a0, 0, t0 // predict low-dividend shift carry-out
243: addq a0, a0, a0 // shift low-dividend left
244: addq t1, t1, t1 // shift high-dividend left
245: bis t1, t0, t1 // merge in carry-out of low-dividend
246:
247: cmpule a1, t1, t0 // if dividend >= divisor,
248: addq a0, t0, a0 // then set quotient bit
249: subq t1, a1, t0 // subtract divisor from dividend,
250: cmovlbs a0, t0, t1 // if dividend >= divisor
251:
252: cmplt a0, 0, t0 // predict low-dividend shift carry-out
253: addq a0, a0, a0 // shift low-dividend left
254: addq t1, t1, t1 // shift high-dividend left
255: bis t1, t0, t1 // merge in carry-out of low-dividend
256:
257: cmpule a1, t1, t0 // if dividend >= divisor,
258: addq a0, t0, a0 // then set quotient bit
259: subq t1, a1, t0 // subtract divisor from dividend,
260: cmovlbs a0, t0, t1 // if dividend >= divisor
261:
262: cmplt a0, 0, t0 // predict low-dividend shift carry-out
263: addq a0, a0, a0 // shift low-dividend left
264: addq t1, t1, t1 // shift high-dividend left
265: bis t1, t0, t1 // merge in carry-out of low-dividend
266:
267: cmpule a1, t1, t0 // if dividend >= divisor,
268: addq a0, t0, a0 // then set quotient bit
269: subq t1, a1, t0 // subtract divisor from dividend,
270: cmovlbs a0, t0, t1 // if dividend >= divisor
271:
272: subq t2, 1, t2 // any more iterations?
273: bne t2, 10b //
274:
275: //
276: // Finished with remainder value in t1 and quotient value in a0.
277: //
278:
279: addl a0, 0, v0 // set longword quotient return value
280: beq a2, 20f // skip optional remainder store
281: stl t1, 0(a2) // store longword remainder
282:
283: 20: ret zero, (ra) // return
284:
285: //
286: // Generate an exception for divide by zero and return a zero quotient if the
287: // caller continues execution.
288: //
289:
290: 30: ldil a0, GENTRAP_INTEGER_DIVIDE_BY_ZERO
291:
292: GENERATE_TRAP
293:
294: ldil v0, 0 // return zero quotient
295: ret zero, (ra) // return
296:
297: //
298: // Generate an exception for overflow.
299: //
300:
301: 40: ldiq a0, 0x8000000000000000 //
302: subqv zero, a0, v0 // negate in order to overflow
303: trapb // wait for trap to occur
304: ret zero, (ra) // return
305:
306: .end EnlargedUnsignedDivide
307:
308: SBTTL("Enlarged Unsigned Integer Multiply")
309: //++
310: //
311: // LARGE_INTEGER
312: // EnlargedUnsignedMultiply (
313: // IN ULONG Multiplicand,
314: // IN ULONG Multiplier
315: // )
316: //
317: // Routine Description:
318: //
319: // This function multiplies an unsigned integer by an unsigned integer
320: // and returns a signed large integer result.
321: //
322: // Arguments:
323: //
324: // Multiplicand (a0) - Supplies the multiplicand value.
325: //
326: // Multiplier (a1) - Supplies the multiplier value.
327: //
328: // Return Value:
329: //
330: // The large integer result is returned as the function value in v0.
331: //
332: //--
333:
334: LEAF_ENTRY(EnlargedUnsignedMultiply)
335:
336: zap a0, 0xf0, a0 // convert canonical ULONG to quadword
337: zap a1, 0xf0, a1 // convert canonical ULONG to quadword
338: mulq a0, a1, v0 // multiply signed both quadwords
339: ret zero, (ra) // return
340:
341: .end EnlargedUnsignedMultiply
342:
343: SBTTL("Extended Integer Multiply")
344: //++
345: //
346: // LARGE_INTEGER
347: // ExtendedIntegerMultiply (
348: // IN LARGE_INTEGER Multiplicand,
349: // IN LONG Multiplier
350: // )
351: //
352: // Routine Description:
353: //
354: // This function multiplies a signed large integer by a signed integer and
355: // returns the signed large integer result.
356: //
357: // N.B. An overflow is possible, but no exception is generated.
358: //
359: // Arguments:
360: //
361: // Multiplicand (a0) - Supplies the multiplicand value.
362: //
363: // Multiplier (a1) - Supplies the multiplier value.
364: //
365: // Return Value:
366: //
367: // The large integer result is returned as the function value in v0.
368: //
369: //--
370:
371: LEAF_ENTRY(ExtendedIntegerMultiply)
372:
373: addl a1, 0, a1 // ensure canonical (signed long) form
374: mulq a0, a1, v0 // multiply signed both quadwords
375: ret zero, (ra) // return
376:
377: .end ExtendedIntegerMultiply
378:
379: SBTTL("Extended Large Integer Divide")
380: //++
381: //
382: // LARGE_INTEGER
383: // ExtendedLargeIntegerDivide (
384: // IN LARGE_INTEGER Dividend,
385: // IN ULONG Divisor,
386: // IN OUT PULONG Remainder OPTIONAL
387: // )
388: //
389: // Routine Description:
390: //
391: // This function divides an unsigned large integer by an unsigned long
392: // and returns the quadword quotient and optionally the long remainder.
393: //
394: // N.B. A divide by zero exception is possible.
395: //
396: // Arguments:
397: //
398: // Dividend (a0) - Supplies the dividend value.
399: //
400: // Divisor (a1) - Supplies the divisor value.
401: //
402: // Remainder (a2) - Supplies an optional pointer to a variable that
403: // receives the remainder.
404: //
405: // Return Value:
406: //
407: // The large integer result is returned as the function value in v0.
408: //
409: //--
410:
411: LEAF_ENTRY(ExtendedLargeIntegerDivide)
412:
413: //
414: // Check for division by zero.
415: //
416:
417: zap a1, 0xf0, a1 // convert canonical ULONG to quadword
418: beq a1, 30f // trap if divisor is zero
419:
420: //
421: // Perform the shift/subtract loop 16 times and 4 bits per loop.
422: //
423: // t0 - Temp used for 0/1 results of compares.
424: // t1 - High 64-bits of 128-bit (t1, a0) dividend.
425: // t2 - Loop counter.
426: //
427:
428: ldiq t2, 64/4 // set iteration count
429:
430: ldiq t1, 0 // zero-extend dividend to 128 bits
431:
432: 10: cmplt a0, 0, t0 // predict low-dividend shift carry-out
433: addq a0, a0, a0 // shift low-dividend left
434: addq t1, t1, t1 // shift high-dividend left
435: bis t1, t0, t1 // merge in carry-out of low-dividend
436:
437: cmpule a1, t1, t0 // if dividend >= divisor,
438: addq a0, t0, a0 // then set quotient bit
439: subq t1, a1, t0 // subtract divisor from dividend,
440: cmovlbs a0, t0, t1 // if dividend >= divisor
441:
442: cmplt a0, 0, t0 // predict low-dividend shift carry-out
443: addq a0, a0, a0 // shift low-dividend left
444: addq t1, t1, t1 // shift high-dividend left
445: bis t1, t0, t1 // merge in carry-out of low-dividend
446:
447: cmpule a1, t1, t0 // if dividend >= divisor,
448: addq a0, t0, a0 // then set quotient bit
449: subq t1, a1, t0 // subtract divisor from dividend,
450: cmovlbs a0, t0, t1 // if dividend >= divisor
451:
452: cmplt a0, 0, t0 // predict low-dividend shift carry-out
453: addq a0, a0, a0 // shift low-dividend left
454: addq t1, t1, t1 // shift high-dividend left
455: bis t1, t0, t1 // merge in carry-out of low-dividend
456:
457: cmpule a1, t1, t0 // if dividend >= divisor,
458: addq a0, t0, a0 // then set quotient bit
459: subq t1, a1, t0 // subtract divisor from dividend,
460: cmovlbs a0, t0, t1 // if dividend >= divisor
461:
462: cmplt a0, 0, t0 // predict low-dividend shift carry-out
463: addq a0, a0, a0 // shift low-dividend left
464: addq t1, t1, t1 // shift high-dividend left
465: bis t1, t0, t1 // merge in carry-out of low-dividend
466:
467: cmpule a1, t1, t0 // if dividend >= divisor,
468: addq a0, t0, a0 // then set quotient bit
469: subq t1, a1, t0 // subtract divisor from dividend,
470: cmovlbs a0, t0, t1 // if dividend >= divisor
471:
472: subq t2, 1, t2 // any more iterations?
473: bne t2, 10b //
474:
475: //
476: // Finished with remainder value in t1 and quotient value in a0.
477: //
478:
479: mov a0, v0 // set quadword quotient return value
480: beq a2, 20f // skip optional remainder store
481: stl t1, 0(a2) // store longword remainder
482:
483: 20: ret zero, (ra) // return
484:
485: //
486: // Generate an exception for divide by zero.
487: //
488:
489: 30: ldil a0, GENTRAP_INTEGER_DIVIDE_BY_ZERO
490:
491: GENERATE_TRAP
492:
493: br zero, 30b // in case they continue
494:
495: .end ExtendedLargeIntegerDivide
496:
497: SBTTL("Extended Magic Divide")
498: //++
499: //
500: // LARGE_INTEGER
501: // ExtendedMagicDivide (
502: // IN LARGE_INTEGER Dividend,
503: // IN LARGE_INTEGER MagicDivisor,
504: // IN CCHAR ShiftCount
505: // )
506: //
507: // Routine Description:
508: //
509: // This function divides a signed large integer by an unsigned large integer
510: // and returns the signed large integer result. The division is performed
511: // using reciprocal multiplication of a signed large integer value by an
512: // unsigned large integer fraction which represents the most significant
513: // 64-bits of the reciprocal divisor rounded up in its least significant bit
514: // and normalized with respect to bit 63. A shift count is also provided
515: // which is used to truncate the fractional bits from the result value.
516: //
517: // Arguments:
518: //
519: // Dividend (a0) - Supplies the dividend value.
520: //
521: // MagicDivisor (a1) - Supplies the magic divisor value which
522: // is a 64-bit multiplicative reciprocal.
523: //
524: // Shiftcount (a2) - Supplies the right shift adjustment value.
525: //
526: // Return Value:
527: //
528: // The large integer result is returned as the function value in v0.
529: //
530: //--
531:
532: LEAF_ENTRY(ExtendedMagicDivide)
533:
534: //
535: // Make the dividend positive for the reciprocal multiplication to work.
536: //
537:
538: negq a0, t0 // negate dividend
539: cmovgt a0, a0, t0 // get absolute value in t0
540:
541: //
542: // Multiply both quadword arguments together and take only the upper 64 bits of
543: // the resulting 128 bit product. This can be done using the umulh instruction.
544: //
545: // Division of a dividend by a constant divisor through reciprocal
546: // multiplication works because a/b is equivalent to (a*x)/(b*x) for any
547: // value of x. Now if b is a constant, some "magic" integer x can be chosen,
548: // based on the value of b, so that (b*x) is very close to a large power of
549: // two (e.g., 2^64). Then a/b = (a*x)/(b*x) = (a*x)/(2^64) = (a*x)>>64. This
550: // effectively turns the problem of division by a constant into multiplication
551: // by a constant which is a much faster operation.
552: //
553:
554: umulh t0, a1, t1 // multiply high both quadword arguments
555: sra t1, a2, t1 // shift result right by requested amount
556:
557: //
558: // Make the result negative if the dividend was negative.
559: //
560:
561: negq t1, t0 // negate result
562: cmovgt a0, t1, t0 // restore sign of dividend
563:
564: mov t0, v0 // set quadword result return value
565: ret zero, (ra) // return
566:
567: .end ExtendedMagicDivide
568:
569: SBTTL("Large Integer Add")
570: //++
571: //
572: // LARGE_INTEGER
573: // LargeIntegerAdd (
574: // IN LARGE_INTEGER Addend1,
575: // IN LARGE_INTEGER Addend2
576: // )
577: //
578: // Routine Description:
579: //
580: // This function adds a signed large integer to a signed large integer and
581: // returns the signed large integer result.
582: //
583: // N.B. An overflow is possible, but no exception is generated.
584: //
585: // Arguments:
586: //
587: // Addend1 (a0) - Supplies the first addend value.
588: //
589: // Addend2 (a1) - Supplies the second addend value.
590: //
591: // Return Value:
592: //
593: // The large integer result is returned as the function value in v0.
594: //
595: //--
596:
597: LEAF_ENTRY(LargeIntegerAdd)
598:
599: addq a0, a1, v0 // add both quadword arguments
600: ret zero, (ra) // return
601:
602: .end LargeIntegerAdd
603:
604: SBTTL("Large Integer Arithmetic Shift Right")
605: //++
606: //
607: // LARGE_INTEGER
608: // LargeIntegerArithmeticShift (
609: // IN LARGE_INTEGER LargeInteger,
610: // IN CCHAR ShiftCount
611: // )
612: //
613: // Routine Description:
614: //
615: // This function shifts a signed large integer right by an unsigned integer
616: // modulo 64 and returns the shifted signed large integer result.
617: //
618: // Arguments:
619: //
620: // LargeInteger (a0) - Supplies the large integer to be shifted.
621: //
622: // ShiftCount (a1) - Supplies the right shift count.
623: //
624: // Return Value:
625: //
626: // The large integer result is returned as the function value in v0.
627: //
628: //--
629:
630: LEAF_ENTRY(LargeIntegerArithmeticShift)
631:
632: sra a0, a1, v0 // shift the quadword right/arithmetic
633: ret zero, (ra) // return
634:
635: .end LargeIntegerArithmeticShift
636:
637: SBTTL("Large Integer Divide")
638: //++
639: //
640: // LARGE_INTEGER
641: // LargeIntegerDivide (
642: // IN LARGE_INTEGER Dividend,
643: // IN LARGE_INTEGER Divisor,
644: // IN OUT PLARGE_INTEGER Remainder OPTIONAL
645: // )
646: //
647: // Routine Description:
648: //
649: // This function divides an unsigned large integer by an unsigned large
650: // integer and returns the quadword quotient and optionally the quadword
651: // remainder.
652: //
653: // N.B. A divide by zero exception is possible.
654: //
655: // Arguments:
656: //
657: // Dividend (a0) - Supplies the dividend value.
658: //
659: // Divisor (a1) - Supplies the divisor value.
660: //
661: // Remainder (a2) - Supplies an optional pointer to a variable that
662: // receives the remainder.
663: //
664: // Return Value:
665: //
666: // The large integer result is returned as the function value in v0.
667: //
668: //--
669:
670: LEAF_ENTRY(LargeIntegerDivide)
671:
672: //
673: // Check for division by zero.
674: //
675:
676: beq a1, 30f // trap if divisor is zero
677:
678: //
679: // Perform the shift/subtract loop 16 times and 4 bits per loop.
680: //
681: // t0 - Temp used for 0/1 results of compares.
682: // t1 - High 64-bits of 128-bit (t1, a0) dividend.
683: // t2 - Loop counter.
684: //
685:
686: ldiq t2, 64/4 // set iteration count
687:
688: ldiq t1, 0 // zero-extend dividend to 128 bits
689:
690: 10: cmplt a0, 0, t0 // predict low-dividend shift carry-out
691: addq a0, a0, a0 // shift low-dividend left
692: addq t1, t1, t1 // shift high-dividend left
693: bis t1, t0, t1 // merge in carry-out of low-dividend
694:
695: cmpule a1, t1, t0 // if dividend >= divisor,
696: addq a0, t0, a0 // then set quotient bit
697: subq t1, a1, t0 // subtract divisor from dividend,
698: cmovlbs a0, t0, t1 // if dividend >= divisor
699:
700: cmplt a0, 0, t0 // predict low-dividend shift carry-out
701: addq a0, a0, a0 // shift low-dividend left
702: addq t1, t1, t1 // shift high-dividend left
703: bis t1, t0, t1 // merge in carry-out of low-dividend
704:
705: cmpule a1, t1, t0 // if dividend >= divisor,
706: addq a0, t0, a0 // then set quotient bit
707: subq t1, a1, t0 // subtract divisor from dividend,
708: cmovlbs a0, t0, t1 // if dividend >= divisor
709:
710: cmplt a0, 0, t0 // predict low-dividend shift carry-out
711: addq a0, a0, a0 // shift low-dividend left
712: addq t1, t1, t1 // shift high-dividend left
713: bis t1, t0, t1 // merge in carry-out of low-dividend
714:
715: cmpule a1, t1, t0 // if dividend >= divisor,
716: addq a0, t0, a0 // then set quotient bit
717: subq t1, a1, t0 // subtract divisor from dividend,
718: cmovlbs a0, t0, t1 // if dividend >= divisor
719:
720: cmplt a0, 0, t0 // predict low-dividend shift carry-out
721: addq a0, a0, a0 // shift low-dividend left
722: addq t1, t1, t1 // shift high-dividend left
723: bis t1, t0, t1 // merge in carry-out of low-dividend
724:
725: cmpule a1, t1, t0 // if dividend >= divisor,
726: addq a0, t0, a0 // then set quotient bit
727: subq t1, a1, t0 // subtract divisor from dividend,
728: cmovlbs a0, t0, t1 // if dividend >= divisor
729:
730: subq t2, 1, t2 // any more iterations?
731: bne t2, 10b //
732:
733: //
734: // Finished with remainder value in t1 and quotient value in a0.
735: //
736:
737: mov a0, v0 // set quadword quotient return value
738: beq a2, 20f // skip optional remainder store
739: stq t1, 0(a2) // store quadword remainder
740:
741: 20: ret zero, (ra) // return
742:
743: //
744: // Generate an exception for divide by zero.
745: //
746:
747: 30: ldil a0, GENTRAP_INTEGER_DIVIDE_BY_ZERO
748:
749: GENERATE_TRAP
750:
751: br zero, 30b // in case they continue
752:
753: .end LargeIntegerDivide
754:
755: SBTTL("Large Integer Negate")
756: //++
757: //
758: // LARGE_INTEGER
759: // LargeIntegerNegate (
760: // IN LARGE_INTEGER Subtrahend
761: // )
762: //
763: // Routine Description:
764: //
765: // This function negates a signed large integer and returns the signed
766: // large integer result.
767: //
768: // N.B. An overflow is possible, but no exception is generated.
769: //
770: // Arguments:
771: //
772: // Subtrahend (a0) - Supplies the subtrahend value.
773: //
774: // Return Value:
775: //
776: // The large integer result is returned as the function value in v0.
777: //
778: //--
779:
780: LEAF_ENTRY(LargeIntegerNegate)
781:
782: subq zero, a0, v0 // negate the quadword argument
783: ret zero, (ra) // return
784:
785: .end LargeIntegerNegate
786:
787: SBTTL("Large Integer Shift Left")
788: //++
789: //
790: // LARGE_INTEGER
791: // LargeIntegerShiftLeft (
792: // IN LARGE_INTEGER LargeInteger,
793: // IN CCHAR ShiftCount
794: // )
795: //
796: // Routine Description:
797: //
798: // This function shifts a signed large integer left by an unsigned integer
799: // modulo 64 and returns the shifted signed large integer result.
800: //
801: // Arguments:
802: //
803: // LargeInteger (a0) - Supplies the large integer to be shifted.
804: //
805: // ShiftCount (a1) - Supplies the left shift count.
806: //
807: // Return Value:
808: //
809: // The large integer result is returned as the function value in v0.
810: //
811: //--
812:
813: LEAF_ENTRY(LargeIntegerShiftLeft)
814:
815: sll a0, a1, v0 // shift the quadword argument left
816: ret zero, (ra) // return
817:
818: .end LargeIntegerShiftLeft
819:
820: SBTTL("Large Integer Logical Shift Right")
821: //++
822: //
823: // LARGE_INTEGER
824: // LargeIntegerShiftRight (
825: // IN LARGE_INTEGER LargeInteger,
826: // IN CCHAR ShiftCount
827: // )
828: //
829: // Routine Description:
830: //
831: // This function shifts an unsigned large integer right by an unsigned
832: // integer modulo 64 and returns the shifted unsigned large integer result.
833: //
834: // Arguments:
835: //
836: // LargeInteger (a0) - Supplies the large integer to be shifted.
837: //
838: // ShiftCount (a1) - Supplies the right shift count.
839: //
840: // Return Value:
841: //
842: // The large integer result is returned as the function value in v0.
843: //
844: //--
845:
846: LEAF_ENTRY(LargeIntegerShiftRight)
847:
848: srl a0, a1, v0 // shift the quadword right/logical
849: ret zero, (ra) // return
850:
851: .end LargeIntegerShiftRight
852:
853: SBTTL("Large Integer Subtract")
854: //++
855: //
856: // LARGE_INTEGER
857: // LargeIntegerSubtract (
858: // IN LARGE_INTEGER Minuend,
859: // IN LARGE_INTEGER Subtrahend
860: // )
861: //
862: // Routine Description:
863: //
864: // This function subtracts a signed large integer from a signed large
865: // integer and returns the signed large integer result.
866: //
867: // N.B. An overflow is possible, but no exception is generated.
868: //
869: // Arguments:
870: //
871: // Minuend (a0) - Supplies the minuend value.
872: //
873: // Subtrahend (a1) - Supplies the subtrahend value.
874: //
875: // Return Value:
876: //
877: // The large integer result is returned as the function value in v0.
878: //
879: //--
880:
881: LEAF_ENTRY(LargeIntegerSubtract)
882:
883: subq a0, a1, v0 // subtract the quadword arguments
884: ret zero, (ra) // return
885:
886: .end LargeIntegerSubtract
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.