Lines Matching refs:Result
33 uint64_t * result = new uint64_t[numWords];
34 assert(result && "APInt memory allocation fails!");
35 memset(result, 0, numWords * sizeof(uint64_t));
36 return result;
42 uint64_t * result = new uint64_t[numWords];
43 assert(result && "APInt memory allocation fails!");
44 return result;
203 /// no further borrowing is neeeded or it runs out of "digits" in x. The result
231 /// places the result in dest.
284 /// Multiplies an integer array, x, by a uint64_t integer and places the result
301 // hasCarry == 2, no carry and the calculation result == 0.
319 /// Multiplies integer array x by integer array y and stores the result into
334 // hasCarry == 2, no carry and the calculation result == 0.
376 // Allocate space for the result
383 // Copy result back into *this
470 APInt Result(*this);
471 Result *= RHS;
472 return Result.clearUnusedBits();
479 APInt Result(BitWidth, 0);
480 add(Result.pVal, this->pVal, RHS.pVal, getNumWords());
481 return Result.clearUnusedBits();
488 APInt Result(BitWidth, 0);
489 sub(Result.pVal, this->pVal, RHS.pVal, getNumWords());
490 return Result.clearUnusedBits();
729 /*------------------------------------------------------ report the result */
880 APInt Result(BitWidth, 0);
881 char *pByte = (char*)Result.pVal;
887 return Result;
928 // then the result is undefined, just return 0
1013 APInt Result(getMemory(getNumWords(width)), width);
1018 Result.pVal[i] = pVal[i];
1023 Result.pVal[i] = pVal[i] << bits >> bits;
1025 return Result;
1038 APInt Result(getMemory(getNumWords(width)), width);
1045 Result.pVal[i] = word;
1057 Result.pVal[i] = word;
1064 Result.pVal[i] = word << bits >> bits;
1066 return Result;
1076 APInt Result(getMemory(getNumWords(width)), width);
1081 Result.pVal[i] = getRawData()[i];
1084 memset(&Result.pVal[i], 0, (Result.getNumWords() - i) * APINT_WORD_SIZE);
1086 return Result;
1130 // If all the bits were shifted out, the result is, technically, undefined.
1140 // Create some space for the result.
1210 // If all the bits were shifted out, the result is 0. This avoids issues
1216 // If none of the bits are shifted out, the result is *this. This avoids
1222 // Create some space for the result.
1270 // If all the bits were shifted out, the result is 0. This avoids issues
1276 // If none of the bits are shifted out, the result is *this. This avoids a
1282 // Create some space for the result.
1308 // Copy whole words from this to Result.
1353 // the libc sqrt function is called. The result is rounded and then converted
1354 // back to a uint64_t which is then used to construct the result. Finally,
1667 uint64_t result = u_tmp - subtrahend;
1669 u[k++] = (unsigned)(result & (b-1)); // subtract low word
1670 u[k++] = (unsigned)(result >> 32); // subtract high word
1683 // The digits (u[j+n]...u[j]) should be kept positive; if the result of
1699 // D5. [Test remainder.] Set q[j] = qp. If the result of step D4 was
1720 DEBUG(dbgs() << "\nKnuthDiv: digit result = " << q[j] << '\n');
1761 assert(lhsWords >= rhsWords && "Fractional result");
1766 // operations for +, -, and * on an m bit value with an m*2 bit result. We
1965 APInt Quotient(1,0); // to hold result.
2243 // value and put a '-' in the result.
2599 DSTPARTS parts of the result, and if all of the omitted higher
2692 is filled with the least significant parts of the result. Returns
2717 result. */
2748 SCRATCH is a bignum of the same size as the operands and result for
2844 of the result at zero. */
