xref: /arkcompiler/ets_runtime/ecmascript/js_bigint.cpp

68 JSHandle<BigInt> BigInt::CreateUint64MaxBigInt(JSThread *thread)
70     JSHandle<BigInt> bigint = CreateBigint(thread, 3); // 3:The number of digits in an object of type BigInt
71     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
78 JSHandle<BigInt> BigInt::CreateInt64MaxBigInt(JSThread *thread)
80     JSHandle<BigInt> bigint = CreateBigint(thread, 2); // 2:The number of digits in an object of type BigInt
81     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
87 JSHandle<BigInt> BigInt::GetUint64MaxBigInt(JSThread *thread)
89     return JSHandle<BigInt>::Cast(thread->GlobalConstants()->GetHandledUint64MaxBigInt());
92 JSHandle<BigInt> BigInt::GetInt64MaxBigInt(JSThread *thread)
94     return JSHandle<BigInt>::Cast(thread->GlobalConstants()->GetHandledInt64MaxBigInt());
97 JSHandle<BigInt> BigIntHelper::SetBigInt(JSThread *thread, const CString &numStr, uint32_t currentRadix)
118         bigint = BigInt::CreateBigint(thread, len);
119         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
123         bigint = BigInt::CreateBigint(thread, len);
124         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
146     return BigIntHelper::RightTruncate(thread, bigint);
149 JSHandle<BigInt> BigIntHelper::RightTruncate(JSThread *thread, JSHandle<BigInt> x)
169         return BigInt::Int32ToBigInt(thread, 0);
172         return BigInt::Copy(thread, x, index + 1);
197 JSHandle<BigInt> BigInt::CreateBigint(JSThread *thread, uint32_t length)
200         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
201         THROW_RANGE_ERROR_AND_RETURN(thread, "Maximum BigInt size exceeded", bigint);
203     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
243 JSHandle<BigInt> BigInt::BitwiseOp(JSThread *thread, Operate op, JSHandle<BigInt> x, JSHandle<BigInt> y)
256     JSHandle<BigInt> bigint = BigInt::CreateBigint(thread, maxLen);
257     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
279     return BigIntHelper::RightTruncate(thread, bigint);
282 JSHandle<BigInt> OneIsNegativeAND(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
284     JSHandle<BigInt> yVal = BigInt::BitwiseSubOne(thread, y, y->GetLength());
285     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
292     JSHandle<BigInt> newBigint = BigInt::CreateBigint(thread, xLength);
293     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
304     return BigIntHelper::RightTruncate(thread, newBigint);
308 JSHandle<BigInt> BigInt::BitwiseAND(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
312         JSHandle<BigInt> xVal = BitwiseSubOne(thread, x, x->GetLength());
313         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
314         JSHandle<BigInt> yVal = BitwiseSubOne(thread, y, y->GetLength());
315         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
316         JSHandle<BigInt> temp = BitwiseOp(thread, Operate::OR, xVal, yVal);
317         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
318         JSHandle<BigInt> res = BitwiseAddOne(thread, temp);
319         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
325             return OneIsNegativeAND(thread, x, y);
327             return OneIsNegativeAND(thread, y, x);
330     return BitwiseOp(thread, Operate::AND, x, y);
333 JSHandle<BigInt> OneIsNegativeXOR(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
335     JSHandle<BigInt> yVal = BigInt::BitwiseSubOne(thread, y, y->GetLength());
336     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
337     JSHandle<BigInt> temp = BigInt::BitwiseOp(thread, Operate::XOR, x, yVal);
338     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
339     JSHandle<BigInt> res = BigInt::BitwiseAddOne(thread, temp);
340     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
345 JSHandle<BigInt> BigInt::BitwiseXOR(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
349         JSHandle<BigInt> xVal = BitwiseSubOne(thread, x, x->GetLength());
350         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
351         JSHandle<BigInt> yVal = BitwiseSubOne(thread, y, y->GetLength());
352         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
353         return BitwiseOp(thread, Operate::XOR, xVal, yVal);
358             return OneIsNegativeXOR(thread, x, y);
360             return OneIsNegativeXOR(thread, y, x);
363     return BitwiseOp(thread, Operate::XOR, x, y);
366 JSHandle<BigInt> BigInt::BitwiseSubOne(JSThread *thread, JSHandle<BigInt> bigint, uint32_t maxLen)
371     JSHandle<BigInt> newBigint = BigInt::CreateBigint(thread, maxLen);
372     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
381     return BigIntHelper::RightTruncate(thread, newBigint);
384 JSHandle<BigInt> BigInt::BitwiseAddOne(JSThread *thread, JSHandle<BigInt> bigint)
399     JSHandle<BigInt> newBigint = BigInt::CreateBigint(thread, newLength);
400     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
411     return BigIntHelper::RightTruncate(thread, newBigint);
414 JSHandle<BigInt> OneIsNegativeOR(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
421     JSHandle<BigInt> yVal = BigInt::BitwiseSubOne(thread, y, maxLen);
422     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
428     JSHandle<BigInt> newBigint = BigInt::CreateBigint(thread, yLength);
429     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
440     JSHandle<BigInt> temp = BigIntHelper::RightTruncate(thread, newBigint);
441     JSHandle<BigInt> res = BigInt::BitwiseAddOne(thread, temp);
442     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
448 JSHandle<BigInt> BigInt::BitwiseOR(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
455         JSHandle<BigInt> xVal = BitwiseSubOne(thread, x, maxLen);
456         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
457         JSHandle<BigInt> yVal = BitwiseSubOne(thread, y, yLen);
458         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
459         JSHandle<BigInt> temp = BitwiseOp(thread, Operate::AND, xVal, yVal);
460         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
461         JSHandle<BigInt> res = BitwiseAddOne(thread, temp);
462         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
469             return OneIsNegativeOR(thread, x, y);
471             return OneIsNegativeOR(thread, y, x);
474     return BitwiseOp(thread, Operate::OR, x, y);
478 JSHandle<EcmaString> BigInt::ToString(JSThread *thread, JSHandle<BigInt> bigint, uint32_t conversionToRadix)
480     ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
495 JSTaggedValue BigInt::NumberToBigInt(JSThread *thread, JSHandle<JSTaggedValue> number)
498         THROW_RANGE_ERROR_AND_RETURN(thread, "The number cannot be converted to a BigInt because it is not an integer",
503         return Int32ToBigInt(thread, 0).GetTaggedValue();
505     return DoubleToBigInt(thread, num);
508 JSTaggedValue BigInt::DoubleToBigInt(JSThread *thread, double num)
520     JSHandle<BigInt> bigint = CreateBigint(thread, mayNeedLen);
521     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
543     return BigIntHelper::RightTruncate(thread, bigint).GetTaggedValue();
546 JSHandle<BigInt> BigInt::Int32ToBigInt(JSThread *thread, const int &number)
548     JSHandle<BigInt> bigint = CreateBigint(thread, 1);
549     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
562 JSHandle<BigInt> BigInt::Uint32ToBigInt(JSThread *thread, const uint32_t &number)
564     JSHandle<BigInt> bigint = CreateBigint(thread, 1);
565     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
570 JSHandle<BigInt> BigInt::Int64ToBigInt(JSThread *thread, const int64_t &number)
579     JSHandle<BigInt> bigint = Uint64ToBigInt(thread, value);
580     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
582     return BigIntHelper::RightTruncate(thread, bigint);
585 JSHandle<BigInt> BigInt::Uint64ToBigInt(JSThread *thread, const uint64_t &number)
587     JSHandle<BigInt> bigint = CreateBigint(thread, 2); // 2 : one int64_t bits need two uint32_t bits
588     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
593     return BigIntHelper::RightTruncate(thread, bigint);
618 void BigInt::BigIntToInt64(JSThread *thread, JSHandle<JSTaggedValue> bigint, int64_t *cValue, bool *lossless)
623         bigint = JSHandle<JSTaggedValue>(thread, JSTaggedValue::ToBigInt(thread, bigint));
624         RETURN_IF_ABRUPT_COMPLETION(thread);
626         JSHandle<BigInt> bigInt64(thread, JSTaggedValue::ToBigInt64(thread, bigint));
627         RETURN_IF_ABRUPT_COMPLETION(thread);
631     JSHandle<BigInt> bigInt64(thread, JSTaggedValue::ToBigInt64(thread, bigint));
632     RETURN_IF_ABRUPT_COMPLETION(thread);
641 void BigInt::BigIntToUint64(JSThread *thread, JSHandle<JSTaggedValue> bigint, uint64_t *cValue, bool *lossless)
646         bigint = JSHandle<JSTaggedValue>(thread, JSTaggedValue::ToBigInt(thread, bigint));
647         RETURN_IF_ABRUPT_COMPLETION(thread);
649         JSHandle<BigInt> bigInt64(thread, JSTaggedValue::ToBigUint64(thread, bigint));
650         RETURN_IF_ABRUPT_COMPLETION(thread);
654     JSHandle<BigInt> bigUint64(thread, JSTaggedValue::ToBigUint64(thread, bigint));
655     RETURN_IF_ABRUPT_COMPLETION(thread);
664 JSHandle<BigInt> BigInt::CreateBigWords(JSThread *thread, bool sign, uint32_t size, const uint64_t *words)
668         return Uint64ToBigInt(thread, 0);
673         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
674         THROW_RANGE_ERROR_AND_RETURN(thread, "Maximum BigInt size exceeded", bigint);
676     JSHandle<BigInt> bigint = CreateBigint(thread, needLen);
677     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
685     return BigIntHelper::RightTruncate(thread, bigint);
688 JSHandle<BigInt> BigInt::Add(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
695         return BigintAdd(thread, x, y, xSignFlag);
704         return BigintSub(thread, x, y, xSignFlag);
710             return BigintSub(thread, x, y, xSignFlag);
712             return BigintSub(thread, y, x, ySignFlag);
715         return BigintSub(thread, y, x, ySignFlag);
718 JSHandle<BigInt> BigInt::Subtract(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
725         return BigintAdd(thread, x, y, xSignFlag);
735         return BigintSub(thread, x, y, xSignFlag);
741             return BigintSub(thread, x, y, xSignFlag);
743             return BigintSub(thread, y, x, !ySignFlag);
746         return BigintSub(thread, y, x, !ySignFlag);
750 JSHandle<BigInt> BigInt::BigintAdd(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y, bool resultSign)
753         return BigintAdd(thread, y, x, resultSign);
755     JSHandle<BigInt> bigint = BigInt::CreateBigint(thread, x->GetLength() + 1);
756     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
776     return BigIntHelper::RightTruncate(thread, bigint);
788 JSHandle<BigInt> BigInt::BigintSub(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y, bool resultSign)
790     JSHandle<BigInt> bigint = BigInt::CreateBigint(thread, x->GetLength());
791     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
810     return BigIntHelper::RightTruncate(thread, bigint);
813 JSHandle<BigInt> BigInt::BigintAddOne(JSThread *thread, JSHandle<BigInt> x)
815     JSHandle<BigInt> temp = Int32ToBigInt(thread, 1);
816     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
817     return Add(thread, x, temp);
820 JSHandle<BigInt> BigInt::BigintSubOne(JSThread *thread, JSHandle<BigInt> x)
822     JSHandle<BigInt> temp = Int32ToBigInt(thread, 1);
823     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
824     return Subtract(thread, x, temp);
870 JSHandle<BigInt> BigInt::SignedRightShift(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
876         return LeftShiftHelper(thread, x, y);
878         return RightShiftHelper(thread, x, y);
882 JSHandle<BigInt> BigInt::ReturnIfRightShiftOverMax(JSThread *thread, bool sign)
885         return Int32ToBigInt(thread, -1);
887     return Int32ToBigInt(thread, 0);
936 JSHandle<BigInt> BigInt::RightShiftHelper(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
940         return ReturnIfRightShiftOverMax(thread, sign);
946         return ReturnIfRightShiftOverMax(thread, sign);
955     JSHandle<BigInt> bigint = CreateBigint(thread, needLen);
956     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
959     bigint = BigIntHelper::RightTruncate(thread, bigint);
963             return BitwiseAddOne(thread, bigint);
969 JSHandle<BigInt> BigInt::LeftShift(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
972         return RightShiftHelper(thread, x, y);
974         return LeftShiftHelper(thread, x, y);
978 JSHandle<BigInt> BigInt::LeftShiftHelper(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
989     JSHandle<BigInt> bigint = CreateBigint(thread, needLen);
990     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1012     return BigIntHelper::RightTruncate(thread, bigint);
1015 JSTaggedValue BigInt::UnsignedRightShift(JSThread *thread)
1017     THROW_TYPE_ERROR_AND_RETURN(thread, "BigInt have no unsigned right shift, use >> instead",
1021 JSHandle<BigInt> BigInt::Copy(JSThread *thread, JSHandle<BigInt> x, uint32_t len)
1024     JSHandle<BigInt> newBig = CreateBigint(thread, len);
1025     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1031 JSHandle<BigInt> BigInt::UnaryMinus(JSThread *thread, JSHandle<BigInt> x)
1036     JSHandle<BigInt> y = Copy(thread, x, x->GetLength());
1042 JSHandle<BigInt> BigInt::BitwiseNOT(JSThread *thread, JSHandle<BigInt> x)
1046     JSHandle<BigInt> result = BigintAddOne(thread, x);
1047     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1056 JSHandle<BigInt> BigInt::Exponentiate(JSThread *thread, JSHandle<BigInt> base, JSHandle<BigInt> exponent)
1059         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
1060         THROW_RANGE_ERROR_AND_RETURN(thread, "Exponent must be positive", bigint);
1064         return Int32ToBigInt(thread, 1);
1072             return BigInt::UnaryMinus(thread, base);
1078         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
1079         THROW_RANGE_ERROR_AND_RETURN(thread, "Maximum BigInt size exceeded", bigint);
1084         JSHandle<BigInt> bigint = CreateBigint(thread, needLength);
1085         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1093     JSMutableHandle<BigInt> result(thread, JSTaggedValue::Null());
1094     JSMutableHandle<BigInt> temp(thread, base);
1100         temp.Update(BigInt::Multiply(thread, temp, temp));
1101         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1106                 result.Update(BigInt::Multiply(thread, result, temp));
1107                 RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1135 JSHandle<BigInt> BigInt::Multiply(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
1144     JSHandle<BigInt> bigint = BigInt::CreateBigint(thread, needLength);
1145     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1186     return BigIntHelper::RightTruncate(thread, bigint);
1273 JSHandle<BigInt> BigInt::FormatLeftShift(JSThread *thread, uint32_t shift, JSHandle<BigInt> bigint, bool neeedAddOne)
1283     JSHandle<BigInt> result = CreateBigint(thread, needLen);
1284     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1376 JSHandle<BigInt> BigInt::DivideAndRemainderWithBigintDivisor(JSThread *thread, JSHandle<BigInt> dividend,
1383     JSMutableHandle<BigInt> quotient(thread, JSTaggedValue::Null());
1385         quotient.Update(CreateBigint(thread, quotientLen + 1));
1386         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1392     JSHandle<BigInt> v = FormatLeftShift(thread, leadingZeros, divisor, false);
1393     JSHandle<BigInt> u = FormatLeftShift(thread, leadingZeros, dividend, true);
1395     JSHandle<BigInt> qv = CreateBigint(thread, divisorLen + 1);
1396     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1433 JSHandle<BigInt> BigInt::DivideAndRemainderWithUint32Divisor(JSThread *thread, JSHandle<BigInt> dividend,
1437     JSMutableHandle<BigInt> quotient(thread, JSTaggedValue::Null());
1441             remainder.Update(Uint32ToBigInt(thread, r));
1444         quotient.Update(CreateBigint(thread, dividend->GetLength()));
1445         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1455 JSHandle<BigInt> BigInt::Divide(JSThread *thread, JSHandle<BigInt> x, JSHandle<BigInt> y)
1458         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
1459         THROW_RANGE_ERROR_AND_RETURN(thread, "Division by zero", bigint);
1462     JSMutableHandle<BigInt> quotient(thread, JSTaggedValue::Null());
1466         return Int32ToBigInt(thread, 0);
1469         quotient.Update(Int32ToBigInt(thread, 1));
1478         return UnaryMinus(thread, x);
1480     JSMutableHandle<BigInt> remainder(thread, JSTaggedValue::Null());
1483         quotient.Update(DivideAndRemainderWithUint32Divisor(thread, x, y->GetDigit(0), remainder));
1486         JSHandle<BigInt> newBigint = DivideAndRemainderWithBigintDivisor(thread, x, y, remainder);
1487         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1492     return BigIntHelper::RightTruncate(thread, quotient);
1495 JSHandle<BigInt> BigInt::Remainder(JSThread *thread, JSHandle<BigInt> n, JSHandle<BigInt> d)
1498         JSHandle<BigInt> bigint(thread, JSTaggedValue::Exception());
1499         THROW_RANGE_ERROR_AND_RETURN(thread, "Division by zero", bigint);
1506         return Int32ToBigInt(thread, 0);
1508     JSMutableHandle<BigInt> remainder(thread, JSTaggedValue::Undefined());
1511         DivideAndRemainderWithUint32Divisor(thread, n, d->GetDigit(0), remainder);
1514         DivideAndRemainderWithBigintDivisor(thread, n, d, remainder);
1515         RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1519     return BigIntHelper::RightTruncate(thread, remainder);
1522 JSHandle<BigInt> BigInt::FloorMod(JSThread *thread, JSHandle<BigInt> leftVal, JSHandle<BigInt> rightVal)
1524     JSHandle<BigInt> remainder = Remainder(thread, leftVal, rightVal);
1525     RETURN_HANDLE_IF_ABRUPT_COMPLETION(BigInt, thread);
1527         return Add(thread, remainder, rightVal);
1532 JSTaggedValue BigInt::AsUintN(JSThread *thread, JSTaggedNumber &bits, JSHandle<BigInt> bigint)
1534     JSTaggedNumber number = JSTaggedValue::ToNumber(thread, bits);
1535     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
1538         return Int32ToBigInt(thread, 0).GetTaggedValue();
1543     JSHandle<BigInt> exponent = Uint64ToBigInt(thread, bit);
1544     JSHandle<BigInt> base = Int64ToBigInt(thread, 2); // 2 : base value
1548     JSHandle<BigInt> tValue = Exponentiate(thread, base, exponent);
1549     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
1550     return FloorMod(thread, bigint, tValue).GetTaggedValue();
1553 JSTaggedValue BigInt::AsintN(JSThread *thread, JSTaggedNumber &bits, JSHandle<BigInt> bigint)
1555     JSTaggedNumber number = JSTaggedValue::ToNumber(thread, bits);
1556     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
1559         return Int32ToBigInt(thread, 0).GetTaggedValue();
1564     JSHandle<BigInt> exp = Int64ToBigInt(thread, bit);
1565     JSHandle<BigInt> exponent = Int64ToBigInt(thread, bit - 1);
1566     JSHandle<BigInt> base = Int64ToBigInt(thread, 2); // 2 : base value
1570     JSHandle<BigInt> tValue = Exponentiate(thread, base, exp);
1571     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
1572     JSHandle<BigInt> modValue = FloorMod(thread, bigint, tValue);
1573     JSHandle<BigInt> resValue = Exponentiate(thread, base, exponent);
1574     RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
1577         return Subtract(thread, modValue, tValue).GetTaggedValue();

Indexes created Thu Nov 07 10:32:03 CST 2024