lib/Support/APInt.cpp

48 /// A utility function that converts a character to a digit.
85 void APInt::initSlowCase(const APInt& that) {
87   memcpy(U.pVal, that.U.pVal, getNumWords() * APINT_WORD_SIZE);
468   // Extracting bits that start on a source word boundary can be done
534   // Compute a sufficient number of bits that is always large enough but might
537   // bits in that case.
546   // Compute a sufficient number of bits that is always large enough but might
557   // the first few digits. But, I'm not sure how accurate that could be.
602   // We can check that all parts of an integer are equal by making use of a
871   // we are using. Note that the sign bit is gone since we constructed the
1099     // Extend the rotate APInt, so that the urem doesn't divide by 0.
1249 ///          signifying that no multiplicative inverse exists!
1255   // (especially the properties numbered 3, 4 and 9) it can be proved that
1322   // u and v by d. Note that we have taken Knuth's advice here to use a power
1323   // of 2 value for d such that d * v[n-1] >= b/2 (b is the base). A power of
1326   // and v so that its high bits are shifted to the top of v's range without
1327   // overflow. Note that this can require an extra word in u so that u must
1404       // D6. [Add back]. The probability that this step is necessary is very
1405       // small, on the order of only 2/b. Make sure that test data accounts for
1410       // since it cancels with the borrow that occurred in D4.
1526   // and faster because we are certain that we can divide a 64-bit quantity
1810   // NOTE: This assumes that reallocate won't affect any bits if it doesn't
1877   // NOTE: This assumes that reallocate won't affect any bits if it doesn't
2389 /// DST, of dstCOUNT parts, such that the bit srcLSB becomes the least
2405   // in DST.  If this is less that srcBits, append the rest, else
2652   // Loop, subtracting SRHS if REMAINDER is greater and adding that to the
2809   // The operation done below (on quadratic coefficients) that can produce
2837   // that "wrap around", such a set will always have a solution, i.e. an x
2838   // that satisfies at least one of the equations, or such that |q(x)|
2841   // We need to find a value k, such that Ax^2 + Bx + C = kR will have a
2842   // positive solution n (in the above sense), and also such that the n
2845   //   { n(k) | k is such that a solution n(k) exists }).
2847   // Consider the parabola (over real numbers) that corresponds to the
2872     // order to have a non-negative solution we need to pick k that makes
2874     // that we are looking for, it needs to be closest to 0 of all k.
2882     // to exist, the discriminant must be non-negative. This means that
2889     // If there exists k meeting the condition above, and such that
2891     // q(x) = kR. Out of all such values of k, pick the one that makes
2892     // C-kR closest to 0, (i.e. pick maximum k such that C-kR > 0).
2893     // In other words, find maximum k such that LowkR <= kR < C.
2901       // If C-kR < 0 for all potential k's, it means that one solution
2905       // to 0, or in other words, out of all parabolas that have solutions,
2906       // pick the one that is the farthest "up").
2924   // value. If that's the case, decrement SQ to get a value that is lower.
2934   // To make sure that the calculated root is not greater than the exact
2942   // The updated coefficients should be such that the (exact) solution is
2954   // This implies that the solution should be between that corresponding to
2955   // SQ (i.e. X) and that corresponding to SQ+1.