|
|
// TITLE("Large Integer Arithmetic")//++//// Copyright (c) 1990 Microsoft Corporation// Copyright (c) 1993 Digital Equipment Corporation//// Module Name://// largeint.s//// Abstract://// This module implements routines for performing extended integer// arithmetic.//// Author://// David N. Cutler (davec) 18-Apr-1990//// Environment://// Any mode.//// Revision History://// Thomas Van Baak (tvb) 9-May-1992//// Adapted for Alpha AXP.////--
#include "ksalpha.h"
//// Alpha AXP Implementation Notes://// The LargeInteger functions defined below implement a set of portable// 64-bit integer arithmetic operations for x86, Mips, and Alpha systems// using the LARGE_INTEGER data type. Code using LARGE_INTEGER variables// and calling these functions will be portable across all NT platforms.// This is the recommended approach to 64-bit arithmetic on NT.//// However, if performance is more important than portability, then for// Alpha systems, the native 64-bit integer data types may be used instead// of the LARGE_INTEGER type and the LargeInteger functions. The Alpha C// compilers support a __int64 data type (renamed LONGLONG in the system// header files). All C integer arithmetic operators may be used with// these quadword types. This eliminates the need for, and the overhead// of, any of the portable LargeInteger functions.//// In general, a LARGE_INTEGER cannot simply be converted to a LONGLONG// because of explicit references in application code to the 32-bit LowPart// and HighPart members of the LARGE_INTEGER structure.//// The performance difference between using the portable LARGE_INTEGER// types with LargeInteger functions and the Alpha LONGLONG types and// operations is often not significant enough to warrant modifying otherwise// portable code. In addition, future compiler optimization and inlining may// actually result in identical performance between portable LARGE_INTEGER// code and Alpha specific LONGLONG code. Therefore it is recommended to// keep NT source code portable.//// The Alpha source for the large integer functions below differs from the// Mips version since for Alpha a 64-bit argument or return value is passed// through a 64-bit integer register. In addition, most operations are// implemented with a single instruction. The division routines below,// however, like Mips, use a simple shift/subtract algorithm which is// considerably slower than the algorithm used by Alpha runtime division// routines.// SBTTL("Convert Long to Large Integer")//++//// LARGE_INTEGER// RtlConvertLongToLargeInteger (// IN LONG SignedInteger// )//// Routine Description://// This function converts a signed integer to a signed large integer// and returns the result.//// Arguments://// SignedInteger (a0) - Supplies the value to convert.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlConvertLongToLargeInteger)
addl a0, 0, v0 // ensure canonical (signed long) form ret zero, (ra) // return
.end RtlConvertLongToLargeInteger SBTTL("Convert Ulong to Large Integer")//++//// LARGE_INTEGER// RtlConvertUlongToLargeInteger (// IN ULONG UnsignedInteger// )//// Routine Description://// This function converts an unsigned integer to a signed large// integer and returns the result.//// Arguments://// UnsignedInteger (a0) - Supplies the value to convert.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlConvertUlongToLargeInteger)
zap a0, 0xf0, v0 // convert canonical ULONG to quadword ret zero, (ra) // return
.end RtlConvertUlongToLargeInteger SBTTL("Enlarged Signed Integer Multiply")//++//// LARGE_INTEGER// RtlEnlargedIntegerMultiply (// IN LONG Multiplicand,// IN LONG Multiplier// )//// Routine Description://// This function multiplies a signed integer by a signed integer and// returns a signed large integer result.//// N.B. An overflow is not possible.//// Arguments://// Multiplicand (a0) - Supplies the multiplicand value.//// Multiplier (a1) - Supplies the multiplier value.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlEnlargedIntegerMultiply)
addl a0, 0, a0 // ensure canonical (signed long) form addl a1, 0, a1 // ensure canonical (signed long) form mulq a0, a1, v0 // multiply signed both quadwords ret zero, (ra) // return
.end RtlEnlargedIntegerMultiply SBTTL("Enlarged Unsigned Divide")//++//// ULONG// RtlEnlargedUnsignedDivide (// IN ULARGE_INTEGER Dividend,// IN ULONG Divisor,// IN OUT PULONG Remainder OPTIONAL// )//// Routine Description://// This function divides an unsigned large integer by an unsigned long// and returns the resultant quotient and optionally the remainder.//// N.B. An overflow or divide by zero exception is possible.//// Arguments://// Dividend (a0) - Supplies the unsigned 64-bit dividend value.//// Divisor (a1) - Supplies the unsigned 32-bit divisor value.//// Remainder (a2) - Supplies an optional pointer to a variable that// receives the unsigned 32-bit remainder.//// Return Value://// The unsigned long integer quotient is returned as the function value.////--
LEAF_ENTRY(RtlEnlargedUnsignedDivide)
//// Check for division by zero.//
zap a1, 0xf0, a1 // convert ULONG divisor to quadword beq a1, 30f // trap if divisor is zero
//// Check for overflow. If the divisor is less than the upper half of the// dividend the quotient would be wider than 32 bits.//
srl a0, 32, t0 // get upper longword of dividend cmpule a1, t0, t1 // is divisor <= upper dividend? bne t1, 40f // if ne[true], then overflow trap
//// Perform the shift/subtract loop 8 times and 4 bits per loop.//// t0 - Temp used for 0/1 results of compares.// t1 - High 64-bits of 128-bit (t1, a0) dividend.// t2 - Loop counter.//
ldiq t2, 32/4 // set iteration count
srl a0, 32, t1 // get top 32 bits of carry-out sll a0, 32, a0 // preshift first 32 bits left
10: cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
subq t2, 1, t2 // any more iterations? bne t2, 10b //
//// Finished with remainder value in t1 and quotient value in a0.//
addl a0, 0, v0 // set longword quotient return value beq a2, 20f // skip optional remainder store stl t1, 0(a2) // store longword remainder
20: ret zero, (ra) // return
//// Generate an exception for divide by zero and return a zero quotient if the// caller continues execution.//
30: ldil a0, GENTRAP_INTEGER_DIVIDE_BY_ZERO
GENERATE_TRAP
ldil v0, 0 // return zero quotient ret zero, (ra) // return
//// Generate an exception for overflow.//
40: ldiq a0, 0x8000000000000000 // subqv zero, a0, v0 // negate in order to overflow trapb // wait for trap to occur ret zero, (ra) // return
.end RtlEnlargedUnsignedDivide SBTTL("Enlarged Unsigned Integer Multiply")//++//// LARGE_INTEGER// RtlEnlargedUnsignedMultiply (// IN ULONG Multiplicand,// IN ULONG Multiplier// )//// Routine Description://// This function multiplies an unsigned integer by an unsigned integer// and returns a signed large integer result.//// Arguments://// Multiplicand (a0) - Supplies the multiplicand value.//// Multiplier (a1) - Supplies the multiplier value.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlEnlargedUnsignedMultiply)
zap a0, 0xf0, a0 // convert canonical ULONG to quadword zap a1, 0xf0, a1 // convert canonical ULONG to quadword mulq a0, a1, v0 // multiply signed both quadwords ret zero, (ra) // return
.end RtlEnlargedUnsignedMultiply SBTTL("Extended Integer Multiply")//++//// LARGE_INTEGER// RtlExtendedIntegerMultiply (// IN LARGE_INTEGER Multiplicand,// IN LONG Multiplier// )//// Routine Description://// This function multiplies a signed large integer by a signed integer and// returns the signed large integer result.//// N.B. An overflow is possible, but no exception is generated.//// Arguments://// Multiplicand (a0) - Supplies the multiplicand value.//// Multiplier (a1) - Supplies the multiplier value.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlExtendedIntegerMultiply)
addl a1, 0, a1 // ensure canonical (signed long) form mulq a0, a1, v0 // multiply signed both quadwords ret zero, (ra) // return
.end RtlExtendedIntegerMultiply SBTTL("Extended Large Integer Divide")//++//// LARGE_INTEGER// RtlExtendedLargeIntegerDivide (// IN LARGE_INTEGER Dividend,// IN ULONG Divisor,// IN OUT PULONG Remainder OPTIONAL// )//// Routine Description://// This function divides an unsigned large integer by an unsigned long// and returns the quadword quotient and optionally the long remainder.//// N.B. A divide by zero exception is possible.//// Arguments://// Dividend (a0) - Supplies the dividend value.//// Divisor (a1) - Supplies the divisor value.//// Remainder (a2) - Supplies an optional pointer to a variable that// receives the remainder.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlExtendedLargeIntegerDivide)
//// Check for division by zero.//
zap a1, 0xf0, a1 // convert canonical ULONG to quadword beq a1, 30f // trap if divisor is zero
//// Perform the shift/subtract loop 16 times and 4 bits per loop.//// t0 - Temp used for 0/1 results of compares.// t1 - High 64-bits of 128-bit (t1, a0) dividend.// t2 - Loop counter.//
ldiq t2, 64/4 // set iteration count
ldiq t1, 0 // zero-extend dividend to 128 bits
10: cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
subq t2, 1, t2 // any more iterations? bne t2, 10b //
//// Finished with remainder value in t1 and quotient value in a0.//
mov a0, v0 // set quadword quotient return value beq a2, 20f // skip optional remainder store stl t1, 0(a2) // store longword remainder
20: ret zero, (ra) // return
//// Generate an exception for divide by zero.//
30: ldil a0, GENTRAP_INTEGER_DIVIDE_BY_ZERO
GENERATE_TRAP
br zero, 30b // in case they continue
.end RtlExtendedLargeIntegerDivide SBTTL("Extended Magic Divide")//++//// LARGE_INTEGER// RtlExtendedMagicDivide (// IN LARGE_INTEGER Dividend,// IN LARGE_INTEGER MagicDivisor,// IN CCHAR ShiftCount// )//// Routine Description://// This function divides a signed large integer by an unsigned large integer// and returns the signed large integer result. The division is performed// using reciprocal multiplication of a signed large integer value by an// unsigned large integer fraction which represents the most significant// 64-bits of the reciprocal divisor rounded up in its least significant bit// and normalized with respect to bit 63. A shift count is also provided// which is used to truncate the fractional bits from the result value.//// Arguments://// Dividend (a0) - Supplies the dividend value.//// MagicDivisor (a1) - Supplies the magic divisor value which// is a 64-bit multiplicative reciprocal.//// Shiftcount (a2) - Supplies the right shift adjustment value.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlExtendedMagicDivide)
//// Make the dividend positive for the reciprocal multiplication to work.//
negq a0, t0 // negate dividend cmovgt a0, a0, t0 // get absolute value in t0
//// Multiply both quadword arguments together and take only the upper 64 bits of// the resulting 128 bit product. This can be done using the umulh instruction.//// Division of a dividend by a constant divisor through reciprocal// multiplication works because a/b is equivalent to (a*x)/(b*x) for any// value of x. Now if b is a constant, some "magic" integer x can be chosen,// based on the value of b, so that (b*x) is very close to a large power of// two (e.g., 2^64). Then a/b = (a*x)/(b*x) = (a*x)/(2^64) = (a*x)>>64. This// effectively turns the problem of division by a constant into multiplication// by a constant which is a much faster operation.//
umulh t0, a1, t1 // multiply high both quadword arguments sra t1, a2, t1 // shift result right by requested amount
//// Make the result negative if the dividend was negative.//
negq t1, t0 // negate result cmovgt a0, t1, t0 // restore sign of dividend
mov t0, v0 // set quadword result return value ret zero, (ra) // return
.end RtlExtendedMagicDivide SBTTL("Large Integer Add")//++//// LARGE_INTEGER// RtlLargeIntegerAdd (// IN LARGE_INTEGER Addend1,// IN LARGE_INTEGER Addend2// )//// Routine Description://// This function adds a signed large integer to a signed large integer and// returns the signed large integer result.//// N.B. An overflow is possible, but no exception is generated.//// Arguments://// Addend1 (a0) - Supplies the first addend value.//// Addend2 (a1) - Supplies the second addend value.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlLargeIntegerAdd)
addq a0, a1, v0 // add both quadword arguments ret zero, (ra) // return
.end RtlLargeIntegerAdd SBTTL("Large Integer Arithmetic Shift Right")//++//// LARGE_INTEGER// RtlLargeIntegerArithmeticShift (// IN LARGE_INTEGER LargeInteger,// IN CCHAR ShiftCount// )//// Routine Description://// This function shifts a signed large integer right by an unsigned integer// modulo 64 and returns the shifted signed large integer result.//// Arguments://// LargeInteger (a0) - Supplies the large integer to be shifted.//// ShiftCount (a1) - Supplies the right shift count.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlLargeIntegerArithmeticShift)
sra a0, a1, v0 // shift the quadword right/arithmetic ret zero, (ra) // return
.end RtlLargeIntegerArithmeticShift SBTTL("Large Integer Divide")//++//// LARGE_INTEGER// RtlLargeIntegerDivide (// IN LARGE_INTEGER Dividend,// IN LARGE_INTEGER Divisor,// IN OUT PLARGE_INTEGER Remainder OPTIONAL// )//// Routine Description://// This function divides an unsigned large integer by an unsigned large// integer and returns the quadword quotient and optionally the quadword// remainder.//// N.B. A divide by zero exception is possible.//// Arguments://// Dividend (a0) - Supplies the dividend value.//// Divisor (a1) - Supplies the divisor value.//// Remainder (a2) - Supplies an optional pointer to a variable that// receives the remainder.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlLargeIntegerDivide)
//// Check for division by zero.//
beq a1, 30f // trap if divisor is zero
//// Perform the shift/subtract loop 16 times and 4 bits per loop.//// t0 - Temp used for 0/1 results of compares.// t1 - High 64-bits of 128-bit (t1, a0) dividend.// t2 - Loop counter.//
ldiq t2, 64/4 // set iteration count
ldiq t1, 0 // zero-extend dividend to 128 bits
10: cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
cmplt a0, 0, t0 // predict low-dividend shift carry-out addq a0, a0, a0 // shift low-dividend left addq t1, t1, t1 // shift high-dividend left bis t1, t0, t1 // merge in carry-out of low-dividend
cmpule a1, t1, t0 // if dividend >= divisor, addq a0, t0, a0 // then set quotient bit subq t1, a1, t0 // subtract divisor from dividend, cmovlbs a0, t0, t1 // if dividend >= divisor
subq t2, 1, t2 // any more iterations? bne t2, 10b //
//// Finished with remainder value in t1 and quotient value in a0.//
mov a0, v0 // set quadword quotient return value beq a2, 20f // skip optional remainder store stq t1, 0(a2) // store quadword remainder
20: ret zero, (ra) // return
//// Generate an exception for divide by zero.//
30: ldil a0, GENTRAP_INTEGER_DIVIDE_BY_ZERO
GENERATE_TRAP
br zero, 30b // in case they continue
.end RtlLargeIntegerDivide SBTTL("Large Integer Negate")//++//// LARGE_INTEGER// RtlLargeIntegerNegate (// IN LARGE_INTEGER Subtrahend// )//// Routine Description://// This function negates a signed large integer and returns the signed// large integer result.//// N.B. An overflow is possible, but no exception is generated.//// Arguments://// Subtrahend (a0) - Supplies the subtrahend value.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlLargeIntegerNegate)
subq zero, a0, v0 // negate the quadword argument ret zero, (ra) // return
.end RtlLargeIntegerNegate SBTTL("Large Integer Shift Left")//++//// LARGE_INTEGER// RtlLargeIntegerShiftLeft (// IN LARGE_INTEGER LargeInteger,// IN CCHAR ShiftCount// )//// Routine Description://// This function shifts a signed large integer left by an unsigned integer// modulo 64 and returns the shifted signed large integer result.//// Arguments://// LargeInteger (a0) - Supplies the large integer to be shifted.//// ShiftCount (a1) - Supplies the left shift count.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlLargeIntegerShiftLeft)
sll a0, a1, v0 // shift the quadword argument left ret zero, (ra) // return
.end RtlLargeIntegerShiftLeft SBTTL("Large Integer Logical Shift Right")//++//// LARGE_INTEGER// RtlLargeIntegerShiftRight (// IN LARGE_INTEGER LargeInteger,// IN CCHAR ShiftCount// )//// Routine Description://// This function shifts an unsigned large integer right by an unsigned// integer modulo 64 and returns the shifted unsigned large integer result.//// Arguments://// LargeInteger (a0) - Supplies the large integer to be shifted.//// ShiftCount (a1) - Supplies the right shift count.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlLargeIntegerShiftRight)
srl a0, a1, v0 // shift the quadword right/logical ret zero, (ra) // return
.end RtlLargeIntegerShiftRight SBTTL("Large Integer Subtract")//++//// LARGE_INTEGER// RtlLargeIntegerSubtract (// IN LARGE_INTEGER Minuend,// IN LARGE_INTEGER Subtrahend// )//// Routine Description://// This function subtracts a signed large integer from a signed large// integer and returns the signed large integer result.//// N.B. An overflow is possible, but no exception is generated.//// Arguments://// Minuend (a0) - Supplies the minuend value.//// Subtrahend (a1) - Supplies the subtrahend value.//// Return Value://// The large integer result is returned as the function value in v0.////--
LEAF_ENTRY(RtlLargeIntegerSubtract)
subq a0, a1, v0 // subtract the quadword arguments ret zero, (ra) // return
.end RtlLargeIntegerSubtract SBTTL("128-bit Signed Integer Multiplication")//++//// VOID// Rtlp128BitSignedMultiply (// IN LONGLONG Multiplicand,// IN LONGLONG Multiplier,// IN OUT PULONGLONG ProductLower,// IN OUT PLONGLONG ProductUpper// )//// Routine Description://// This function multiplies a signed quadword (or signed large integer)// by a signed quadword (or signed large integer) and returns the full// 128-bit signed product indirectly through pointers to two quadwords.//// N.B. Signed multiplication is implemented with an unsigned multiply// followed by up to two subtractions. The subtractions are necessary for// the following reason. Within an N-bit register, a negative N-bit two's// compliment signed integer (-x), is equal to (2^N - x). So in this case// of 64x64 bit multiplication, the following holds://// (-x) * (-y) =// (2^64 - x) * (2^64 - y) =// 2^128 - (2^64)*x - (2^64)*y + (x*y)//// The lower 64-bits of the 128-bit product is determined solely by the// (x*y) term. For a 128-bit result, the 2^128 term is irrelevant. And if// either the x and/or the y operand is negative, then either y and/or x// must be subtracted from the upper 64 bits of the 128-bit product.//// Arguments://// Multiplicand (a0) - Supplies the multiplicand value.//// Multiplier (a1) - Supplies the multiplier value.//// ProductLower (a2) - Supplies a pointer to an unsigned quadword variable// that receives the lower 64-bits of the product.//// ProductLower (a3) - Supplies a pointer to a signed quadword variable// that receives the upper 64-bits of the product.//// Return Value://// None.////--
LEAF_ENTRY(Rtlp128BitSignedMultiply)
mulq a0, a1, t0 // get lower 64 bits of product stq t0, 0(a2) // store lower half of 128-bit product
umulh a0, a1, t1 // get upper 64 bits of product subq t1, a0, t2 // subtract first operand from product cmovge a1, t1, t2 // if second operand is negative subq t2, a1, t3 // subtract second operand from product cmovge a0, t2, t3 // if first operand is negative stq t3, 0(a3) // store upper half of 128-bit product
ret zero, (ra) // return
.end Rtlp128BitSignedMultiply SBTTL("128-bit Unsigned Integer Multiplication")//++//// VOID// Rtlp128BitUnsignedMultiply (// IN ULONGLONG Multiplicand,// IN ULONGLONG Multiplier,// IN OUT PULONGLONG ProductLower,// IN OUT PULONGLONG ProductUpper// )//// Routine Description://// This function multiplies an unsigned quadword (or large integer) by an// unsigned quadword (or large integer) and returns the full 128-bit unsigned// product indirectly through pointers to two unsigned quadwords.//// Arguments://// Multiplicand (a0) - Supplies the multiplicand value.//// Multiplier (a1) - Supplies the multiplier value.//// ProductLower (a2) - Supplies a pointer to an unsigned quadword variable// that receives the lower 64-bits of the product.//// ProductLower (a3) - Supplies a pointer to an unsigned quadword variable// that receives the upper 64-bits of the product.//// Return Value://// None.////--
LEAF_ENTRY(Rtlp128BitUnsignedMultiply)
mulq a0, a1, t0 // get lower 64 bits of product stq t0, 0(a2) // store lower half of 128-bit product
umulh a0, a1, t1 // get upper 64 bits of product stq t1, 0(a3) // store upper half of 128-bit product
ret zero, (ra) // return
.end Rtlp128BitUnsignedMultiply
|
