Lines Matching refs:pBigNum
115 DECLINLINE(int) rtBigNumSetUsed(PRTBIGNUM pBigNum, uint32_t cNewUsed);
302 * @param pBigNum The big number.
304 DECLINLINE(void) rtBigNumScramble(PRTBIGNUM pBigNum)
306 if (pBigNum->fSensitive)
308 AssertReturnVoid(!pBigNum->fCurScrambled);
309 if (pBigNum->pauElements)
311 int rc = RTMemSaferScramble(pBigNum->pauElements, pBigNum->cAllocated * RTBIGNUM_ELEMENT_SIZE); AssertRC(rc);
312 pBigNum->fCurScrambled = RT_SUCCESS(rc);
315 pBigNum->fCurScrambled = true;
324 * @param pBigNum The big number.
326 DECLINLINE(int) rtBigNumUnscramble(PRTBIGNUM pBigNum)
328 if (pBigNum->fSensitive)
330 AssertReturn(pBigNum->fCurScrambled, VERR_INTERNAL_ERROR_2);
331 if (pBigNum->pauElements)
333 int rc = RTMemSaferUnscramble(pBigNum->pauElements, pBigNum->cAllocated * RTBIGNUM_ELEMENT_SIZE); AssertRC(rc);
334 pBigNum->fCurScrambled = !RT_SUCCESS(rc);
338 pBigNum->fCurScrambled = false;
348 * @param pBigNum The big number.
351 DECLINLINE(RTBIGNUMELEMENT) rtBigNumGetElement(PCRTBIGNUM pBigNum, uint32_t iElement)
353 if (iElement < pBigNum->cUsed)
354 return pBigNum->pauElements[iElement];
363 * @param pBigNum The big number.
367 static int rtBigNumGrow(PRTBIGNUM pBigNum, uint32_t cNewUsed, uint32_t cMinElements)
370 uint32_t const cbOld = pBigNum->cAllocated * RTBIGNUM_ELEMENT_SIZE;
377 if (pBigNum->fSensitive)
378 pvNew = RTMemSaferReallocZ(cbOld, pBigNum->pauElements, cbNew);
380 pvNew = RTMemRealloc(pBigNum->pauElements, cbNew);
385 if (pBigNum->cUsed > cNewUsed)
386 RT_BZERO((RTBIGNUMELEMENT *)pvNew + cNewUsed, (pBigNum->cUsed - cNewUsed) * RTBIGNUM_ELEMENT_SIZE);
388 pBigNum->pauElements = (RTBIGNUMELEMENT *)pvNew;
389 pBigNum->cUsed = cNewUsed;
390 pBigNum->cAllocated = cNew;
405 * @param pBigNum The big number.
408 DECLINLINE(int) rtBigNumSetUsed(PRTBIGNUM pBigNum, uint32_t cNewUsed)
410 if (pBigNum->cAllocated >= cNewUsed)
412 if (pBigNum->cUsed > cNewUsed)
413 RT_BZERO(&pBigNum->pauElements[cNewUsed], (pBigNum->cUsed - cNewUsed) * RTBIGNUM_ELEMENT_SIZE);
415 else if (pBigNum->cUsed != cNewUsed)
416 Assert(ASMMemIsAllU32(&pBigNum->pauElements[pBigNum->cUsed],
417 (cNewUsed - pBigNum->cUsed) * RTBIGNUM_ELEMENT_SIZE, 0) == NULL);
419 pBigNum->cUsed = cNewUsed;
422 return rtBigNumGrow(pBigNum, cNewUsed, cNewUsed);
431 * @param pBigNum The big number.
438 DECLINLINE(int) rtBigNumSetUsedEx(PRTBIGNUM pBigNum, uint32_t cNewUsed, uint32_t cMinElements)
440 if (pBigNum->cAllocated >= cMinElements)
442 if (pBigNum->cUsed > cNewUsed)
443 RT_BZERO(&pBigNum->pauElements[cNewUsed], (pBigNum->cUsed - cNewUsed) * RTBIGNUM_ELEMENT_SIZE);
445 else if (pBigNum->cUsed != cNewUsed)
446 Assert(ASMMemIsAllU32(&pBigNum->pauElements[pBigNum->cUsed],
447 (cNewUsed - pBigNum->cUsed) * RTBIGNUM_ELEMENT_SIZE, 0) == NULL);
449 pBigNum->cUsed = cNewUsed;
452 return rtBigNumGrow(pBigNum, cNewUsed, cMinElements);
461 * @param pBigNum The big number.
463 * array array, where those after pBigNum->cUsed must
466 DECLINLINE(int) rtBigNumEnsureExtraZeroElements(PRTBIGNUM pBigNum, uint32_t cElements)
468 if (pBigNum->cAllocated >= cElements)
470 Assert( pBigNum->cAllocated == pBigNum->cUsed
471 || ASMMemIsAllU32(&pBigNum->pauElements[pBigNum->cUsed],
472 (pBigNum->cAllocated - pBigNum->cUsed) * RTBIGNUM_ELEMENT_SIZE, 0) == NULL);
475 return rtBigNumGrow(pBigNum, pBigNum->cUsed, cElements);
484 * @param pBigNum The big number.
487 static int rtBigNumEnsureElementPresentSlow(PRTBIGNUM pBigNum, uint32_t iElement)
489 uint32_t const cOldUsed = pBigNum->cUsed;
490 int rc = rtBigNumSetUsed(pBigNum, iElement + 1);
493 RT_BZERO(&pBigNum->pauElements[cOldUsed], (iElement + 1 - cOldUsed) * RTBIGNUM_ELEMENT_SIZE);
511 * @param pBigNum The big number.
514 DECLINLINE(int) rtBigNumEnsureElementPresent(PRTBIGNUM pBigNum, uint32_t iElement)
516 if (iElement < pBigNum->cUsed)
518 return rtBigNumEnsureElementPresentSlow(pBigNum, iElement);
525 * @param pBigNum The big number to strip.
527 static void rtBigNumStripTrailingZeros(PRTBIGNUM pBigNum)
529 uint32_t i = pBigNum->cUsed;
530 while (i > 0 && pBigNum->pauElements[i - 1] == 0)
532 pBigNum->cUsed = i;
539 * @returns @a pBigNum
540 * @param pBigNum The big number.
544 DECLINLINE(PRTBIGNUM) rtBigNumInitZeroInternal(PRTBIGNUM pBigNum, uint32_t fFlags)
546 RT_ZERO(*pBigNum);
547 pBigNum->fSensitive = RT_BOOL(fFlags & RTBIGNUMINIT_F_SENSITIVE);
548 return pBigNum;
555 * @returns @a pBigNum
556 * @param pBigNum The big number.
560 DECLINLINE(PRTBIGNUM) rtBigNumInitZeroTemplate(PRTBIGNUM pBigNum, PCRTBIGNUM pTemplate)
562 RT_ZERO(*pBigNum);
563 pBigNum->fSensitive = pTemplate->fSensitive;
564 return pBigNum;
568 RTDECL(int) RTBigNumInit(PRTBIGNUM pBigNum, uint32_t fFlags, void const *pvRaw, size_t cbRaw)
573 AssertPtrReturn(pBigNum, VERR_INVALID_POINTER);
583 rtBigNumInitZeroInternal(pBigNum, fFlags);
602 pBigNum->fNegative = 1;
622 pBigNum->fNegative = 1;
639 pBigNum->cUsed = (uint32_t)cbAligned / RTBIGNUM_ELEMENT_SIZE;
640 if (pBigNum->cUsed)
642 pBigNum->cAllocated = RT_ALIGN_32(pBigNum->cUsed, RTBIGNUM_ALIGNMENT);
643 if (pBigNum->fSensitive)
644 pBigNum->pauElements = (RTBIGNUMELEMENT *)RTMemSaferAllocZ(pBigNum->cAllocated * RTBIGNUM_ELEMENT_SIZE);
646 pBigNum->pauElements = (RTBIGNUMELEMENT *)RTMemAlloc(pBigNum->cAllocated * RTBIGNUM_ELEMENT_SIZE);
647 if (RT_UNLIKELY(!pBigNum->pauElements))
659 pBigNum->pauElements[i] = RT_MAKE_U64_FROM_U8(pb[0], pb[1], pb[2], pb[3], pb[4], pb[5], pb[6], pb[7]);
661 pBigNum->pauElements[i] = RT_MAKE_U32_FROM_U8(pb[0], pb[1], pb[2], pb[3]);
672 RTBIGNUMELEMENT uLast = pBigNum->fNegative ? ~(RTBIGNUMELEMENT)0 : 0;
686 pBigNum->pauElements[i] = uLast;
696 pBigNum->pauElements[i] = RT_MAKE_U64_FROM_U8(pb[7], pb[6], pb[5], pb[4], pb[3], pb[2], pb[1], pb[0]);
698 pBigNum->pauElements[i] = RT_MAKE_U32_FROM_U8(pb[3], pb[2], pb[1], pb[0]);
708 RTBIGNUMELEMENT uLast = pBigNum->fNegative ? ~(RTBIGNUMELEMENT)0 : 0;
723 pBigNum->pauElements[i] = uLast;
730 if (pBigNum->fNegative)
732 pBigNum->pauElements[0] = 0U - pBigNum->pauElements[0];
733 for (i = 1; i < pBigNum->cUsed; i++)
734 pBigNum->pauElements[i] = 0U - pBigNum->pauElements[i] - 1U;
740 if (pBigNum->cUsed != pBigNum->cAllocated)
742 RTBIGNUMELEMENT *puUnused = &pBigNum->pauElements[pBigNum->cUsed];
744 switch (pBigNum->cAllocated - pBigNum->cUsed)
752 RTBIGNUM_ASSERT_VALID(pBigNum);
755 rtBigNumScramble(pBigNum);
760 RTDECL(int) RTBigNumInitZero(PRTBIGNUM pBigNum, uint32_t fFlags)
763 AssertPtrReturn(pBigNum, VERR_INVALID_POINTER);
765 rtBigNumInitZeroInternal(pBigNum, fFlags);
766 rtBigNumScramble(pBigNum);
775 * @param pBigNum The target number.
778 static int rtBigNumCloneInternal(PRTBIGNUM pBigNum, PCRTBIGNUM pSrc)
786 RT_ZERO(*pBigNum);
787 pBigNum->fNegative = pSrc->fNegative;
788 pBigNum->fSensitive = pSrc->fSensitive;
789 pBigNum->cUsed = pSrc->cUsed;
793 pBigNum->cAllocated = RT_ALIGN_32(pBigNum->cUsed, RTBIGNUM_ALIGNMENT);
794 if (pBigNum->fSensitive)
795 pBigNum->pauElements = (RTBIGNUMELEMENT *)RTMemSaferAllocZ(pBigNum->cAllocated * RTBIGNUM_ELEMENT_SIZE);
797 pBigNum->pauElements = (RTBIGNUMELEMENT *)RTMemAlloc(pBigNum->cAllocated * RTBIGNUM_ELEMENT_SIZE);
798 if (RT_LIKELY(pBigNum->pauElements))
800 memcpy(pBigNum->pauElements, pSrc->pauElements, pBigNum->cUsed * RTBIGNUM_ELEMENT_SIZE);
801 if (pBigNum->cUsed != pBigNum->cAllocated)
802 RT_BZERO(&pBigNum->pauElements[pBigNum->cUsed], (pBigNum->cAllocated - pBigNum->cUsed) * RTBIGNUM_ELEMENT_SIZE);
806 RT_ZERO(*pBigNum);
814 RTDECL(int) RTBigNumClone(PRTBIGNUM pBigNum, PCRTBIGNUM pSrc)
820 rc = rtBigNumCloneInternal(pBigNum, pSrc);
822 rtBigNumScramble(pBigNum);
829 RTDECL(int) RTBigNumDestroy(PRTBIGNUM pBigNum)
831 if (pBigNum)
833 if (pBigNum->pauElements)
835 Assert(pBigNum->cAllocated > 0);
836 if (pBigNum->fSensitive)
838 RTMemSaferFree(pBigNum->pauElements, pBigNum->cAllocated * RTBIGNUM_ELEMENT_SIZE);
839 RT_ZERO(*pBigNum);
841 RTMemFree(pBigNum->pauElements);
842 pBigNum->pauElements = NULL;
898 * @param pBigNum The bit number.
900 static uint32_t rtBigNumMagnitudeBitWidth(PCRTBIGNUM pBigNum)
902 uint32_t idxLast = pBigNum->cUsed;
906 RTBIGNUMELEMENT uLast = pBigNum->pauElements[idxLast]; Assert(uLast);
913 RTDECL(uint32_t) RTBigNumBitWidth(PCRTBIGNUM pBigNum)
915 uint32_t idxLast = pBigNum->cUsed;
919 rtBigNumUnscramble((PRTBIGNUM)pBigNum);
920 RTBIGNUMELEMENT uLast = pBigNum->pauElements[idxLast]; Assert(uLast);
921 rtBigNumScramble((PRTBIGNUM)pBigNum);
922 return rtBigNumElementBitCount(uLast) + idxLast * RTBIGNUM_ELEMENT_BITS + pBigNum->fNegative;
928 RTDECL(uint32_t) RTBigNumByteWidth(PCRTBIGNUM pBigNum)
930 uint32_t cBits = RTBigNumBitWidth(pBigNum);
935 RTDECL(int) RTBigNumToBytesBigEndian(PCRTBIGNUM pBigNum, void *pvBuf, size_t cbWanted)
940 int rc = rtBigNumUnscramble((PRTBIGNUM)pBigNum);
943 RTBIGNUM_ASSERT_VALID(pBigNum);
945 if (pBigNum->cUsed != 0)
949 for (uint32_t i = 0; i < pBigNum->cUsed; i++)
951 RTBIGNUMELEMENT uElement = pBigNum->pauElements[i];
952 if (pBigNum->fNegative)
989 if ( i + 1 < pBigNum->cUsed
990 || ( !pBigNum->fNegative
1000 memset(pbDst - cbWanted, pBigNum->fNegative ? 0 : 0xff, cbWanted);
1004 rtBigNumScramble((PRTBIGNUM)pBigNum);
1177 * Copies the magnitude of on number (@a pSrc) to another (@a pBigNum).
1495 RTDECL(int) RTBigNumNegate(PRTBIGNUM pResult, PCRTBIGNUM pBigNum)
1497 int rc = RTBigNumAssign(pResult, pBigNum);
1620 * Clears a bit in the magnitude of @a pBigNum.
1624 * @param pBigNum The big number.
1627 DECLINLINE(void) rtBigNumMagnitudeClearBit(PRTBIGNUM pBigNum, uint32_t iBit)
1630 if (iElement < pBigNum->cUsed)
1633 pBigNum->pauElements[iElement] &= ~RTBIGNUM_ELEMENT_BIT(iBit);
1634 if (iElement + 1 == pBigNum->cUsed && !pBigNum->pauElements[iElement])
1635 rtBigNumStripTrailingZeros(pBigNum);
1641 * Sets a bit in the magnitude of @a pBigNum.
1646 * @param pBigNum The big number.
1649 DECLINLINE(int) rtBigNumMagnitudeSetBit(PRTBIGNUM pBigNum, uint32_t iBit)
1652 int rc = rtBigNumEnsureElementPresent(pBigNum, iElement);
1656 pBigNum->pauElements[iElement] |= RTBIGNUM_ELEMENT_BIT(iBit);
1664 * Writes a bit in the magnitude of @a pBigNum.
1669 * @param pBigNum The big number.
1673 DECLINLINE(int) rtBigNumMagnitudeWriteBit(PRTBIGNUM pBigNum, uint32_t iBit, bool fValue)
1676 return rtBigNumMagnitudeSetBit(pBigNum, iBit);
1677 rtBigNumMagnitudeClearBit(pBigNum, iBit);
1688 * @param pBigNum The big number.
1691 DECLINLINE(RTBIGNUMELEMENT) rtBigNumMagnitudeGetBit(PCRTBIGNUM pBigNum, uint32_t iBit)
1694 if (iElement < pBigNum->cUsed)
1697 return (pBigNum->pauElements[iElement] >> iBit) & 1;
1709 * @param pBigNum The big number.
1712 DECLINLINE(int) rtBigNumMagnitudeShiftLeftOne(PRTBIGNUM pBigNum, RTBIGNUMELEMENT uCarry)
1717 uint32_t cUsed = pBigNum->cUsed;
1719 uCarry = rtBigNumMagnitudeShiftLeftOneAssemblyWorker(pBigNum->pauElements, cUsed, uCarry);
1723 RTBIGNUMELEMENT uTmp = pBigNum->pauElements[i];
1724 pBigNum->pauElements[i] = (uTmp << 1) | uCarry;
1732 int rc = rtBigNumSetUsed(pBigNum, cUsed + 1);
1733 pBigNum->pauElements[cUsed] = uCarry;