gcclibs/libcpp/expr.c

364    of precision options->precision.
390       size_t precision = CPP_OPTION (pfile, precision);
411 	 needing the precision and slowness of double integers.  */
413       if (precision < PART_PRECISION)
414 	max >>= PART_PRECISION - precision;
431 	      result = append_digit (result, c, base, precision);
447 	       && !num_positive (result, precision))
461 append_digit (cpp_num num, int digit, int base, size_t precision)
511      overflow of the (possibly shorter) target precision.  */
514   result = num_trim (result, precision);
641 	    result = num_trim (result, CPP_OPTION (pfile, precision));
1066       if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1071   else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1079 num_trim (cpp_num num, size_t precision)
1081   if (precision > PART_PRECISION)
1083       precision -= PART_PRECISION;
1084       if (precision < PART_PRECISION)
1085 	num.high &= ((cpp_num_part) 1 << precision) - 1;
1089       if (precision < PART_PRECISION)
1090 	num.low &= ((cpp_num_part) 1 << precision) - 1;
1099 num_positive (cpp_num num, size_t precision)
1101   if (precision > PART_PRECISION)
1103       precision -= PART_PRECISION;
1104       return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1107   return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1113 cpp_num_sign_extend (cpp_num num, size_t precision)
1117       if (precision > PART_PRECISION)
1119 	  precision -= PART_PRECISION;
1120 	  if (precision < PART_PRECISION
1121 	      && (num.high & (cpp_num_part) 1 << (precision - 1)))
1122 	    num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1124       else if (num.low & (cpp_num_part) 1 << (precision - 1))
1126 	  if (precision < PART_PRECISION)
1127 	    num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1137 num_negate (cpp_num num, size_t precision)
1146   num = num_trim (num, precision);
1154 num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1164       unsignedp = num_positive (pa, precision);
1166       if (unsignedp != num_positive (pb, precision))
1183   /* As excess precision is zeroed, there is no need to num_trim () as
1209   bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1244 num_rshift (cpp_num num, size_t precision, size_t n)
1247   bool x = num_positive (num, precision);
1254   if (n >= precision)
1259       if (precision < PART_PRECISION)
1260 	num.high = sign_mask, num.low |= sign_mask << precision;
1261       else if (precision < 2 * PART_PRECISION)
1262 	num.high |= sign_mask << (precision - PART_PRECISION);
1278   num = num_trim (num, precision);
1285 num_lshift (cpp_num num, size_t precision, size_t n)
1287   if (n >= precision)
1309       num = num_trim (num, precision);
1315 	  maybe_orig = num_rshift (num, precision, n);
1337       num = num_negate (num, CPP_OPTION (pfile, precision));
1343       num = num_trim (num, CPP_OPTION (pfile, precision));
1363   size_t precision = CPP_OPTION (pfile, precision);
1371       if (!rhs.unsignedp && !num_positive (rhs, precision))
1378 	  rhs = num_negate (rhs, precision);
1385 	lhs = num_lshift (lhs, precision, n);
1387 	lhs = num_rshift (lhs, precision, n);
1392       rhs = num_negate (rhs, precision);
1401       result = num_trim (result, precision);
1404 	  bool lhsp = num_positive (lhs, precision);
1405 	  result.overflow = (lhsp == num_positive (rhs, precision)
1406 			     && lhsp != num_positive (result, precision));
1462   size_t precision = CPP_OPTION (pfile, precision);
1467       if (!num_positive (lhs, precision))
1468 	negate = !negate, lhs = num_negate (lhs, precision);
1469       if (!num_positive (rhs, precision))
1470 	negate = !negate, rhs = num_negate (rhs, precision);
1487   result = num_trim (result, precision);
1492     result = num_negate (result, precision);
1497     result.overflow = overflow || (num_positive (result, precision) ^ !negate
1513   size_t i, precision = CPP_OPTION (pfile, precision);
1518       if (!num_positive (lhs, precision))
1519 	negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1520       if (!num_positive (rhs, precision))
1521 	negate = !negate, rhs = num_negate (rhs, precision);
1527       i = precision - 1;
1535       if (precision > PART_PRECISION)
1536 	i = precision - PART_PRECISION - 1;
1538 	i = precision - 1;
1558   i = precision - i - 1;
1559   sub = num_lshift (rhs, precision, i);
1564       if (num_greater_eq (lhs, sub, precision))
1586 	    result = num_negate (result, precision);
1587 	  result.overflow = (num_positive (result, precision) ^ !negate
1598     lhs = num_negate (lhs, precision);