libcpp/expr.c

   1 /* Parse C expressions for cpplib.
   2    Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
   3    2002, 2004, 2008, 2009, 2010 Free Software Foundation.
   4    Contributed by Per Bothner, 1994.
   5
   6 This program is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 3, or (at your option) any
   9 later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "cpplib.h"
  23 #include "internal.h"
  24
  25 #define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
  26 #define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
  27 #define LOW_PART(num_part) (num_part & HALF_MASK)
  28 #define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
  29
  30 struct op
  31 {
  32   const cpp_token *token;       /* The token forming op (for diagnostics).  */
  33   cpp_num value;                /* The value logically "right" of op.  */
  34   source_location loc;          /* The location of this value.         */
  35   enum cpp_ttype op;
  36 };
  37
  38 /* Some simple utility routines on double integers.  */
  39 #define num_zerop(num) ((num.low | num.high) == 0)
  40 #define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
  41 static bool num_positive (cpp_num, size_t);
  42 static bool num_greater_eq (cpp_num, cpp_num, size_t);
  43 static cpp_num num_trim (cpp_num, size_t);
  44 static cpp_num num_part_mul (cpp_num_part, cpp_num_part);
  45
  46 static cpp_num num_unary_op (cpp_reader *, cpp_num, enum cpp_ttype);
  47 static cpp_num num_binary_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
  48 static cpp_num num_negate (cpp_num, size_t);
  49 static cpp_num num_bitwise_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
  50 static cpp_num num_inequality_op (cpp_reader *, cpp_num, cpp_num,
  51                                   enum cpp_ttype);
  52 static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,
  53                                 enum cpp_ttype);
  54 static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num);
  55 static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype,
  56                            source_location);
  57 static cpp_num num_lshift (cpp_num, size_t, size_t);
  58 static cpp_num num_rshift (cpp_num, size_t, size_t);
  59
  60 static cpp_num append_digit (cpp_num, int, int, size_t);
  61 static cpp_num parse_defined (cpp_reader *);
  62 static cpp_num eval_token (cpp_reader *, const cpp_token *);
  63 static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);
  64 static unsigned int interpret_float_suffix (const uchar *, size_t);
  65 static unsigned int interpret_int_suffix (const uchar *, size_t);
  66 static void check_promotion (cpp_reader *, const struct op *);
  67
  68 /* Token type abuse to create unary plus and minus operators.  */
  69 #define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
  70 #define CPP_UMINUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))
  71
  72 /* With -O2, gcc appears to produce nice code, moving the error
  73    message load and subsequent jump completely out of the main path.  */
  74 #define SYNTAX_ERROR(msgid) \
  75   do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)
  76 #define SYNTAX_ERROR2(msgid, arg) \
  77   do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \
  78   while(0)
  79
  80 /* Subroutine of cpp_classify_number.  S points to a float suffix of
  81    length LEN, possibly zero.  Returns 0 for an invalid suffix, or a
  82    flag vector describing the suffix.  */
  83 static unsigned int
  84 interpret_float_suffix (const uchar *s, size_t len)
  85 {
  86   size_t flags;
  87   size_t f, d, l, w, q, i;
  88
  89   flags = 0;
  90   f = d = l = w = q = i = 0;
  91
  92   /* Process decimal float suffixes, which are two letters starting
  93      with d or D.  Order and case are significant.  */
  94   if (len == 2 && (*s == 'd' || *s == 'D'))
  95     {
  96       bool uppercase = (*s == 'D');
  97       switch (s[1])
  98       {
  99       case 'f': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL): 0); break;
 100       case 'F': return (uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL) : 0); break;
 101       case 'd': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM): 0); break;
 102       case 'D': return (uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM) : 0); break;
 103       case 'l': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
 104       case 'L': return (uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
 105       default:
 106         /* Additional two-character suffixes beginning with D are not
 107            for decimal float constants.  */
 108         break;
 109       }
 110     }
 111
 112   /* Recognize a fixed-point suffix.  */
 113   switch (s[len-1])
 114     {
 115     case 'k': case 'K': flags = CPP_N_ACCUM; break;
 116     case 'r': case 'R': flags = CPP_N_FRACT; break;
 117     default: break;
 118     }
 119
 120   /* Continue processing a fixed-point suffix.  The suffix is case
 121      insensitive except for ll or LL.  Order is significant.  */
 122   if (flags)
 123     {
 124       if (len == 1)
 125         return flags;
 126       len--;
 127
 128       if (*s == 'u' || *s == 'U')
 129         {
 130           flags |= CPP_N_UNSIGNED;
 131           if (len == 1)
 132             return flags;
 133           len--;
 134           s++;
 135         }
 136
 137       switch (*s)
 138       {
 139       case 'h': case 'H':
 140         if (len == 1)
 141           return flags |= CPP_N_SMALL;
 142         break;
 143       case 'l':
 144         if (len == 1)
 145           return flags |= CPP_N_MEDIUM;
 146         if (len == 2 && s[1] == 'l')
 147           return flags |= CPP_N_LARGE;
 148         break;
 149       case 'L':
 150         if (len == 1)
 151           return flags |= CPP_N_MEDIUM;
 152         if (len == 2 && s[1] == 'L')
 153           return flags |= CPP_N_LARGE;
 154         break;
 155       default:
 156         break;
 157       }
 158       /* Anything left at this point is invalid.  */
 159       return 0;
 160     }
 161
 162   /* In any remaining valid suffix, the case and order don't matter.  */
 163   while (len--)
 164     switch (s[len])
 165       {
 166       case 'f': case 'F': f++; break;
 167       case 'd': case 'D': d++; break;
 168       case 'l': case 'L': l++; break;
 169       case 'w': case 'W': w++; break;
 170       case 'q': case 'Q': q++; break;
 171       case 'i': case 'I':
 172       case 'j': case 'J': i++; break;
 173       default:
 174         return 0;
 175       }
 176
 177   if (f + d + l + w + q > 1 || i > 1)
 178     return 0;
 179
 180   return ((i ? CPP_N_IMAGINARY : 0)
 181           | (f ? CPP_N_SMALL :
 182              d ? CPP_N_MEDIUM :
 183              l ? CPP_N_LARGE :
 184              w ? CPP_N_MD_W :
 185              q ? CPP_N_MD_Q : CPP_N_DEFAULT));
 186 }
 187
 188 /* Subroutine of cpp_classify_number.  S points to an integer suffix
 189    of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
 190    flag vector describing the suffix.  */
 191 static unsigned int
 192 interpret_int_suffix (const uchar *s, size_t len)
 193 {
 194   size_t u, l, i;
 195
 196   u = l = i = 0;
 197
 198   while (len--)
 199     switch (s[len])
 200       {
 201       case 'u': case 'U':       u++; break;
 202       case 'i': case 'I':
 203       case 'j': case 'J':       i++; break;
 204       case 'l': case 'L':       l++;
 205         /* If there are two Ls, they must be adjacent and the same case.  */
 206         if (l == 2 && s[len] != s[len + 1])
 207           return 0;
 208         break;
 209       default:
 210         return 0;
 211       }
 212
 213   if (l > 2 || u > 1 || i > 1)
 214     return 0;
 215
 216   return ((i ? CPP_N_IMAGINARY : 0)
 217           | (u ? CPP_N_UNSIGNED : 0)
 218           | ((l == 0) ? CPP_N_SMALL
 219              : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
 220 }
 221
 222 /* Categorize numeric constants according to their field (integer,
 223    floating point, or invalid), radix (decimal, octal, hexadecimal),
 224    and type suffixes.  */
 225 unsigned int
 226 cpp_classify_number (cpp_reader *pfile, const cpp_token *token)
 227 {
 228   const uchar *str = token->val.str.text;
 229   const uchar *limit;
 230   unsigned int max_digit, result, radix;
 231   enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
 232   bool seen_digit;
 233
 234   /* If the lexer has done its job, length one can only be a single
 235      digit.  Fast-path this very common case.  */
 236   if (token->val.str.len == 1)
 237     return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
 238
 239   limit = str + token->val.str.len;
 240   float_flag = NOT_FLOAT;
 241   max_digit = 0;
 242   radix = 10;
 243   seen_digit = false;
 244
 245   /* First, interpret the radix.  */
 246   if (*str == '0')
 247     {
 248       radix = 8;
 249       str++;
 250
 251       /* Require at least one hex digit to classify it as hex.  */
 252       if ((*str == 'x' || *str == 'X')
 253           && (str[1] == '.' || ISXDIGIT (str[1])))
 254         {
 255           radix = 16;
 256           str++;
 257         }
 258       else if ((*str == 'b' || *str == 'B') && (str[1] == '0' || str[1] == '1'))
 259         {
 260           radix = 2;
 261           str++;
 262         }
 263     }
 264
 265   /* Now scan for a well-formed integer or float.  */
 266   for (;;)
 267     {
 268       unsigned int c = *str++;
 269
 270       if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
 271         {
 272           seen_digit = true;
 273           c = hex_value (c);
 274           if (c > max_digit)
 275             max_digit = c;
 276         }
 277       else if (c == '.')
 278         {
 279           if (float_flag == NOT_FLOAT)
 280             float_flag = AFTER_POINT;
 281           else
 282             SYNTAX_ERROR ("too many decimal points in number");
 283         }
 284       else if ((radix <= 10 && (c == 'e' || c == 'E'))
 285                || (radix == 16 && (c == 'p' || c == 'P')))
 286         {
 287           float_flag = AFTER_EXPON;
 288           break;
 289         }
 290       else
 291         {
 292           /* Start of suffix.  */
 293           str--;
 294           break;
 295         }
 296     }
 297
 298   /* The suffix may be for decimal fixed-point constants without exponent.  */
 299   if (radix != 16 && float_flag == NOT_FLOAT)
 300     {
 301       result = interpret_float_suffix (str, limit - str);
 302       if ((result & CPP_N_FRACT) || (result & CPP_N_ACCUM))
 303         {
 304           result |= CPP_N_FLOATING;
 305           /* We need to restore the radix to 10, if the radix is 8.  */
 306           if (radix == 8)
 307             radix = 10;
 308
 309           if (CPP_PEDANTIC (pfile))
 310             cpp_error (pfile, CPP_DL_PEDWARN,
 311                        "fixed-point constants are a GCC extension");
 312           goto syntax_ok;
 313         }
 314       else
 315         result = 0;
 316     }
 317
 318   if (float_flag != NOT_FLOAT && radix == 8)
 319     radix = 10;
 320
 321   if (max_digit >= radix)
 322     {
 323       if (radix == 2)
 324         SYNTAX_ERROR2 ("invalid digit \"%c\" in binary constant", '0' + max_digit);
 325       else
 326         SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);
 327     }
 328
 329   if (float_flag != NOT_FLOAT)
 330     {
 331       if (radix == 2)
 332         {
 333           cpp_error (pfile, CPP_DL_ERROR,
 334                      "invalid prefix \"0b\" for floating constant");
 335           return CPP_N_INVALID;
 336         }
 337
 338       if (radix == 16 && !seen_digit)
 339         SYNTAX_ERROR ("no digits in hexadecimal floating constant");
 340
 341       if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
 342         cpp_error (pfile, CPP_DL_PEDWARN,
 343                    "use of C99 hexadecimal floating constant");
 344
 345       if (float_flag == AFTER_EXPON)
 346         {
 347           if (*str == '+' || *str == '-')
 348             str++;
 349
 350           /* Exponent is decimal, even if string is a hex float.  */
 351           if (!ISDIGIT (*str))
 352             SYNTAX_ERROR ("exponent has no digits");
 353
 354           do
 355             str++;
 356           while (ISDIGIT (*str));
 357         }
 358       else if (radix == 16)
 359         SYNTAX_ERROR ("hexadecimal floating constants require an exponent");
 360
 361       result = interpret_float_suffix (str, limit - str);
 362       if (result == 0)
 363         {
 364           cpp_error (pfile, CPP_DL_ERROR,
 365                      "invalid suffix \"%.*s\" on floating constant",
 366                      (int) (limit - str), str);
 367           return CPP_N_INVALID;
 368         }
 369
 370       /* Traditional C didn't accept any floating suffixes.  */
 371       if (limit != str
 372           && CPP_WTRADITIONAL (pfile)
 373           && ! cpp_sys_macro_p (pfile))
 374         cpp_warning (pfile, CPP_W_TRADITIONAL,
 375                      "traditional C rejects the \"%.*s\" suffix",
 376                      (int) (limit - str), str);
 377
 378       /* A suffix for double is a GCC extension via decimal float support.
 379          If the suffix also specifies an imaginary value we'll catch that
 380          later.  */
 381       if ((result == CPP_N_MEDIUM) && CPP_PEDANTIC (pfile))
 382         cpp_error (pfile, CPP_DL_PEDWARN,
 383                    "suffix for double constant is a GCC extension");
 384
 385       /* Radix must be 10 for decimal floats.  */
 386       if ((result & CPP_N_DFLOAT) && radix != 10)
 387         {
 388           cpp_error (pfile, CPP_DL_ERROR,
 389                      "invalid suffix \"%.*s\" with hexadecimal floating constant",
 390                      (int) (limit - str), str);
 391           return CPP_N_INVALID;
 392         }
 393
 394       if ((result & (CPP_N_FRACT | CPP_N_ACCUM)) && CPP_PEDANTIC (pfile))
 395         cpp_error (pfile, CPP_DL_PEDWARN,
 396                    "fixed-point constants are a GCC extension");
 397
 398       if ((result & CPP_N_DFLOAT) && CPP_PEDANTIC (pfile))
 399         cpp_error (pfile, CPP_DL_PEDWARN,
 400                    "decimal float constants are a GCC extension");
 401
 402       result |= CPP_N_FLOATING;
 403     }
 404   else
 405     {
 406       result = interpret_int_suffix (str, limit - str);
 407       if (result == 0)
 408         {
 409           cpp_error (pfile, CPP_DL_ERROR,
 410                      "invalid suffix \"%.*s\" on integer constant",
 411                      (int) (limit - str), str);
 412           return CPP_N_INVALID;
 413         }
 414
 415       /* Traditional C only accepted the 'L' suffix.
 416          Suppress warning about 'LL' with -Wno-long-long.  */
 417       if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
 418         {
 419           int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
 420           int large = (result & CPP_N_WIDTH) == CPP_N_LARGE
 421                        && CPP_OPTION (pfile, cpp_warn_long_long);
 422
 423           if (u_or_i || large)
 424             cpp_warning (pfile, large ? CPP_W_LONG_LONG : CPP_W_TRADITIONAL,
 425                          "traditional C rejects the \"%.*s\" suffix",
 426                          (int) (limit - str), str);
 427         }
 428
 429       if ((result & CPP_N_WIDTH) == CPP_N_LARGE
 430           && CPP_OPTION (pfile, cpp_warn_long_long))
 431         {
 432           const char *message = CPP_OPTION (pfile, cplusplus)
 433                                 ? N_("use of C++0x long long integer constant")
 434                                 : N_("use of C99 long long integer constant");
 435
 436           if (CPP_OPTION (pfile, c99))
 437             cpp_warning (pfile, CPP_W_LONG_LONG, message);
 438           else
 439             cpp_pedwarning (pfile, CPP_W_LONG_LONG, message);
 440         }
 441
 442       result |= CPP_N_INTEGER;
 443     }
 444
 445  syntax_ok:
 446   if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
 447     cpp_error (pfile, CPP_DL_PEDWARN,
 448                "imaginary constants are a GCC extension");
 449   if (radix == 2 && CPP_PEDANTIC (pfile))
 450     cpp_error (pfile, CPP_DL_PEDWARN,
 451                "binary constants are a GCC extension");
 452
 453   if (radix == 10)
 454     result |= CPP_N_DECIMAL;
 455   else if (radix == 16)
 456     result |= CPP_N_HEX;
 457   else if (radix == 2)
 458     result |= CPP_N_BINARY;
 459   else
 460     result |= CPP_N_OCTAL;
 461
 462   return result;
 463
 464  syntax_error:
 465   return CPP_N_INVALID;
 466 }
 467
 468 /* cpp_interpret_integer converts an integer constant into a cpp_num,
 469    of precision options->precision.
 470
 471    We do not provide any interface for decimal->float conversion,
 472    because the preprocessor doesn't need it and we don't want to
 473    drag in GCC's floating point emulator.  */
 474 cpp_num
 475 cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
 476                        unsigned int type)
 477 {
 478   const uchar *p, *end;
 479   cpp_num result;
 480
 481   result.low = 0;
 482   result.high = 0;
 483   result.unsignedp = !!(type & CPP_N_UNSIGNED);
 484   result.overflow = false;
 485
 486   p = token->val.str.text;
 487   end = p + token->val.str.len;
 488
 489   /* Common case of a single digit.  */
 490   if (token->val.str.len == 1)
 491     result.low = p[0] - '0';
 492   else
 493     {
 494       cpp_num_part max;
 495       size_t precision = CPP_OPTION (pfile, precision);
 496       unsigned int base = 10, c = 0;
 497       bool overflow = false;
 498
 499       if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
 500         {
 501           base = 8;
 502           p++;
 503         }
 504       else if ((type & CPP_N_RADIX) == CPP_N_HEX)
 505         {
 506           base = 16;
 507           p += 2;
 508         }
 509       else if ((type & CPP_N_RADIX) == CPP_N_BINARY)
 510         {
 511           base = 2;
 512           p += 2;
 513         }
 514
 515       /* We can add a digit to numbers strictly less than this without
 516          needing the precision and slowness of double integers.  */
 517       max = ~(cpp_num_part) 0;
 518       if (precision < PART_PRECISION)
 519         max >>= PART_PRECISION - precision;
 520       max = (max - base + 1) / base + 1;
 521
 522       for (; p < end; p++)
 523         {
 524           c = *p;
 525
 526           if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
 527             c = hex_value (c);
 528           else
 529             break;
 530
 531           /* Strict inequality for when max is set to zero.  */
 532           if (result.low < max)
 533             result.low = result.low * base + c;
 534           else
 535             {
 536               result = append_digit (result, c, base, precision);
 537               overflow |= result.overflow;
 538               max = 0;
 539             }
 540         }
 541
 542       if (overflow)
 543         cpp_error (pfile, CPP_DL_PEDWARN,
 544                    "integer constant is too large for its type");
 545       /* If too big to be signed, consider it unsigned.  Only warn for
 546          decimal numbers.  Traditional numbers were always signed (but
 547          we still honor an explicit U suffix); but we only have
 548          traditional semantics in directives.  */
 549       else if (!result.unsignedp
 550                && !(CPP_OPTION (pfile, traditional)
 551                     && pfile->state.in_directive)
 552                && !num_positive (result, precision))
 553         {
 554           /* This is for constants within the range of uintmax_t but
 555              not that of intmax_t.  For such decimal constants, a
 556              diagnostic is required for C99 as the selected type must
 557              be signed and not having a type is a constraint violation
 558              (DR#298, TC3), so this must be a pedwarn.  For C90,
 559              unsigned long is specified to be used for a constant that
 560              does not fit in signed long; if uintmax_t has the same
 561              range as unsigned long this means only a warning is
 562              appropriate here.  C90 permits the preprocessor to use a
 563              wider range than unsigned long in the compiler, so if
 564              uintmax_t is wider than unsigned long no diagnostic is
 565              required for such constants in preprocessor #if
 566              expressions and the compiler will pedwarn for such
 567              constants outside the range of unsigned long that reach
 568              the compiler so a diagnostic is not required there
 569              either; thus, pedwarn for C99 but use a plain warning for
 570              C90.  */
 571           if (base == 10)
 572             cpp_error (pfile, (CPP_OPTION (pfile, c99)
 573                                ? CPP_DL_PEDWARN
 574                                : CPP_DL_WARNING),
 575                        "integer constant is so large that it is unsigned");
 576           result.unsignedp = true;
 577         }
 578     }
 579
 580   return result;
 581 }
 582
 583 /* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE.  */
 584 static cpp_num
 585 append_digit (cpp_num num, int digit, int base, size_t precision)
 586 {
 587   cpp_num result;
 588   unsigned int shift;
 589   bool overflow;
 590   cpp_num_part add_high, add_low;
 591
 592   /* Multiply by 2, 8 or 16.  Catching this overflow here means we don't
 593      need to worry about add_high overflowing.  */
 594   switch (base)
 595     {
 596     case 2:
 597       shift = 1;
 598       break;
 599
 600     case 16:
 601       shift = 4;
 602       break;
 603
 604     default:
 605       shift = 3;
 606     }
 607   overflow = !!(num.high >> (PART_PRECISION - shift));
 608   result.high = num.high << shift;
 609   result.low = num.low << shift;
 610   result.high |= num.low >> (PART_PRECISION - shift);
 611   result.unsignedp = num.unsignedp;
 612
 613   if (base == 10)
 614     {
 615       add_low = num.low << 1;
 616       add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
 617     }
 618   else
 619     add_high = add_low = 0;
 620
 621   if (add_low + digit < add_low)
 622     add_high++;
 623   add_low += digit;
 624
 625   if (result.low + add_low < result.low)
 626     add_high++;
 627   if (result.high + add_high < result.high)
 628     overflow = true;
 629
 630   result.low += add_low;
 631   result.high += add_high;
 632   result.overflow = overflow;
 633
 634   /* The above code catches overflow of a cpp_num type.  This catches
 635      overflow of the (possibly shorter) target precision.  */
 636   num.low = result.low;
 637   num.high = result.high;
 638   result = num_trim (result, precision);
 639   if (!num_eq (result, num))
 640     result.overflow = true;
 641
 642   return result;
 643 }
 644
 645 /* Handle meeting "defined" in a preprocessor expression.  */
 646 static cpp_num
 647 parse_defined (cpp_reader *pfile)
 648 {
 649   cpp_num result;
 650   int paren = 0;
 651   cpp_hashnode *node = 0;
 652   const cpp_token *token;
 653   cpp_context *initial_context = pfile->context;
 654
 655   /* Don't expand macros.  */
 656   pfile->state.prevent_expansion++;
 657
 658   token = cpp_get_token (pfile);
 659   if (token->type == CPP_OPEN_PAREN)
 660     {
 661       paren = 1;
 662       token = cpp_get_token (pfile);
 663     }
 664
 665   if (token->type == CPP_NAME)
 666     {
 667       node = token->val.node.node;
 668       if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
 669         {
 670           cpp_error (pfile, CPP_DL_ERROR, "missing ')' after \"defined\"");
 671           node = 0;
 672         }
 673     }
 674   else
 675     {
 676       cpp_error (pfile, CPP_DL_ERROR,
 677                  "operator \"defined\" requires an identifier");
 678       if (token->flags & NAMED_OP)
 679         {
 680           cpp_token op;
 681
 682           op.flags = 0;
 683           op.type = token->type;
 684           cpp_error (pfile, CPP_DL_ERROR,
 685                      "(\"%s\" is an alternative token for \"%s\" in C++)",
 686                      cpp_token_as_text (pfile, token),
 687                      cpp_token_as_text (pfile, &op));
 688         }
 689     }
 690
 691   if (node)
 692     {
 693       if (pfile->context != initial_context && CPP_PEDANTIC (pfile))
 694         cpp_error (pfile, CPP_DL_WARNING,
 695                    "this use of \"defined\" may not be portable");
 696
 697       _cpp_mark_macro_used (node);
 698       if (!(node->flags & NODE_USED))
 699         {
 700           node->flags |= NODE_USED;
 701           if (node->type == NT_MACRO)
 702             {
 703               if ((node->flags & NODE_BUILTIN)
 704                   && pfile->cb.user_builtin_macro)
 705                 pfile->cb.user_builtin_macro (pfile, node);
 706               if (pfile->cb.used_define)
 707                 pfile->cb.used_define (pfile, pfile->directive_line, node);
 708             }
 709           else
 710             {
 711               if (pfile->cb.used_undef)
 712                 pfile->cb.used_undef (pfile, pfile->directive_line, node);
 713             }
 714         }
 715
 716       /* A possible controlling macro of the form #if !defined ().
 717          _cpp_parse_expr checks there was no other junk on the line.  */
 718       pfile->mi_ind_cmacro = node;
 719     }
 720
 721   pfile->state.prevent_expansion--;
 722
 723   result.unsignedp = false;
 724   result.high = 0;
 725   result.overflow = false;
 726   result.low = node && node->type == NT_MACRO;
 727   return result;
 728 }
 729
 730 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
 731    number or character constant, or the result of the "defined" or "#"
 732    operators).  */
 733 static cpp_num
 734 eval_token (cpp_reader *pfile, const cpp_token *token)
 735 {
 736   cpp_num result;
 737   unsigned int temp;
 738   int unsignedp = 0;
 739
 740   result.unsignedp = false;
 741   result.overflow = false;
 742
 743   switch (token->type)
 744     {
 745     case CPP_NUMBER:
 746       temp = cpp_classify_number (pfile, token);
 747       switch (temp & CPP_N_CATEGORY)
 748         {
 749         case CPP_N_FLOATING:
 750           cpp_error (pfile, CPP_DL_ERROR,
 751                      "floating constant in preprocessor expression");
 752           break;
 753         case CPP_N_INTEGER:
 754           if (!(temp & CPP_N_IMAGINARY))
 755             return cpp_interpret_integer (pfile, token, temp);
 756           cpp_error (pfile, CPP_DL_ERROR,
 757                      "imaginary number in preprocessor expression");
 758           break;
 759
 760         case CPP_N_INVALID:
 761           /* Error already issued.  */
 762           break;
 763         }
 764       result.high = result.low = 0;
 765       break;
 766
 767     case CPP_WCHAR:
 768     case CPP_CHAR:
 769     case CPP_CHAR16:
 770     case CPP_CHAR32:
 771       {
 772         cppchar_t cc = cpp_interpret_charconst (pfile, token,
 773                                                 &temp, &unsignedp);
 774
 775         result.high = 0;
 776         result.low = cc;
 777         /* Sign-extend the result if necessary.  */
 778         if (!unsignedp && (cppchar_signed_t) cc < 0)
 779           {
 780             if (PART_PRECISION > BITS_PER_CPPCHAR_T)
 781               result.low |= ~(~(cpp_num_part) 0
 782                               >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
 783             result.high = ~(cpp_num_part) 0;
 784             result = num_trim (result, CPP_OPTION (pfile, precision));
 785           }
 786       }
 787       break;
 788
 789     case CPP_NAME:
 790       if (token->val.node.node == pfile->spec_nodes.n_defined)
 791         return parse_defined (pfile);
 792       else if (CPP_OPTION (pfile, cplusplus)
 793                && (token->val.node.node == pfile->spec_nodes.n_true
 794                    || token->val.node.node == pfile->spec_nodes.n_false))
 795         {
 796           result.high = 0;
 797           result.low = (token->val.node.node == pfile->spec_nodes.n_true);
 798         }
 799       else
 800         {
 801           result.high = 0;
 802           result.low = 0;
 803           if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
 804             cpp_warning (pfile, CPP_W_UNDEF, "\"%s\" is not defined",
 805                          NODE_NAME (token->val.node.node));
 806         }
 807       break;
 808
 809     case CPP_HASH:
 810       if (!pfile->state.skipping)
 811         {
 812           /* A pedantic warning takes precedence over a deprecated
 813              warning here.  */
 814           if (CPP_PEDANTIC (pfile))
 815             cpp_error (pfile, CPP_DL_PEDWARN,
 816                        "assertions are a GCC extension");
 817           else if (CPP_OPTION (pfile, cpp_warn_deprecated))
 818             cpp_warning (pfile, CPP_W_DEPRECATED,
 819                          "assertions are a deprecated extension");
 820         }
 821       _cpp_test_assertion (pfile, &temp);
 822       result.high = 0;
 823       result.low = temp;
 824       break;
 825
 826     default:
 827       abort ();
 828     }
 829
 830   result.unsignedp = !!unsignedp;
 831   return result;
 832 }
 833 \f
 834 /* Operator precedence and flags table.
 835
 836 After an operator is returned from the lexer, if it has priority less
 837 than the operator on the top of the stack, we reduce the stack by one
 838 operator and repeat the test.  Since equal priorities do not reduce,
 839 this is naturally right-associative.
 840
 841 We handle left-associative operators by decrementing the priority of
 842 just-lexed operators by one, but retaining the priority of operators
 843 already on the stack.
 844
 845 The remaining cases are '(' and ')'.  We handle '(' by skipping the
 846 reduction phase completely.  ')' is given lower priority than
 847 everything else, including '(', effectively forcing a reduction of the
 848 parenthesized expression.  If there is a matching '(', the routine
 849 reduce() exits immediately.  If the normal exit route sees a ')', then
 850 there cannot have been a matching '(' and an error message is output.
 851
 852 The parser assumes all shifted operators require a left operand unless
 853 the flag NO_L_OPERAND is set.  These semantics are automatic; any
 854 extra semantics need to be handled with operator-specific code.  */
 855
 856 /* Flags.  If CHECK_PROMOTION, we warn if the effective sign of an
 857    operand changes because of integer promotions.  */
 858 #define NO_L_OPERAND    (1 << 0)
 859 #define LEFT_ASSOC      (1 << 1)
 860 #define CHECK_PROMOTION (1 << 2)
 861
 862 /* Operator to priority map.  Must be in the same order as the first
 863    N entries of enum cpp_ttype.  */
 864 static const struct cpp_operator
 865 {
 866   uchar prio;
 867   uchar flags;
 868 } optab[] =
 869 {
 870   /* EQ */              {0, 0}, /* Shouldn't happen.  */
 871   /* NOT */             {16, NO_L_OPERAND},
 872   /* GREATER */         {12, LEFT_ASSOC | CHECK_PROMOTION},
 873   /* LESS */            {12, LEFT_ASSOC | CHECK_PROMOTION},
 874   /* PLUS */            {14, LEFT_ASSOC | CHECK_PROMOTION},
 875   /* MINUS */           {14, LEFT_ASSOC | CHECK_PROMOTION},
 876   /* MULT */            {15, LEFT_ASSOC | CHECK_PROMOTION},
 877   /* DIV */             {15, LEFT_ASSOC | CHECK_PROMOTION},
 878   /* MOD */             {15, LEFT_ASSOC | CHECK_PROMOTION},
 879   /* AND */             {9, LEFT_ASSOC | CHECK_PROMOTION},
 880   /* OR */              {7, LEFT_ASSOC | CHECK_PROMOTION},
 881   /* XOR */             {8, LEFT_ASSOC | CHECK_PROMOTION},
 882   /* RSHIFT */          {13, LEFT_ASSOC},
 883   /* LSHIFT */          {13, LEFT_ASSOC},
 884
 885   /* COMPL */           {16, NO_L_OPERAND},
 886   /* AND_AND */         {6, LEFT_ASSOC},
 887   /* OR_OR */           {5, LEFT_ASSOC},
 888   /* Note that QUERY, COLON, and COMMA must have the same precedence.
 889      However, there are some special cases for these in reduce().  */
 890   /* QUERY */           {4, 0},
 891   /* COLON */           {4, LEFT_ASSOC | CHECK_PROMOTION},
 892   /* COMMA */           {4, LEFT_ASSOC},
 893   /* OPEN_PAREN */      {1, NO_L_OPERAND},
 894   /* CLOSE_PAREN */     {0, 0},
 895   /* EOF */             {0, 0},
 896   /* EQ_EQ */           {11, LEFT_ASSOC},
 897   /* NOT_EQ */          {11, LEFT_ASSOC},
 898   /* GREATER_EQ */      {12, LEFT_ASSOC | CHECK_PROMOTION},
 899   /* LESS_EQ */         {12, LEFT_ASSOC | CHECK_PROMOTION},
 900   /* UPLUS */           {16, NO_L_OPERAND},
 901   /* UMINUS */          {16, NO_L_OPERAND}
 902 };
 903
 904 /* Parse and evaluate a C expression, reading from PFILE.
 905    Returns the truth value of the expression.
 906
 907    The implementation is an operator precedence parser, i.e. a
 908    bottom-up parser, using a stack for not-yet-reduced tokens.
 909
 910    The stack base is op_stack, and the current stack pointer is 'top'.
 911    There is a stack element for each operator (only), and the most
 912    recently pushed operator is 'top->op'.  An operand (value) is
 913    stored in the 'value' field of the stack element of the operator
 914    that precedes it.  */
 915 bool
 916 _cpp_parse_expr (cpp_reader *pfile, bool is_if)
 917 {
 918   struct op *top = pfile->op_stack;
 919   unsigned int lex_count;
 920   bool saw_leading_not, want_value = true;
 921
 922   pfile->state.skip_eval = 0;
 923
 924   /* Set up detection of #if ! defined().  */
 925   pfile->mi_ind_cmacro = 0;
 926   saw_leading_not = false;
 927   lex_count = 0;
 928
 929   /* Lowest priority operator prevents further reductions.  */
 930   top->op = CPP_EOF;
 931
 932   for (;;)
 933     {
 934       struct op op;
 935
 936       lex_count++;
 937       op.token = cpp_get_token (pfile);
 938       op.op = op.token->type;
 939       op.loc = op.token->src_loc;
 940
 941       switch (op.op)
 942         {
 943           /* These tokens convert into values.  */
 944         case CPP_NUMBER:
 945         case CPP_CHAR:
 946         case CPP_WCHAR:
 947         case CPP_CHAR16:
 948         case CPP_CHAR32:
 949         case CPP_NAME:
 950         case CPP_HASH:
 951           if (!want_value)
 952             SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
 953                            cpp_token_as_text (pfile, op.token));
 954           want_value = false;
 955           top->value = eval_token (pfile, op.token);
 956           continue;
 957
 958         case CPP_NOT:
 959           saw_leading_not = lex_count == 1;
 960           break;
 961         case CPP_PLUS:
 962           if (want_value)
 963             op.op = CPP_UPLUS;
 964           break;
 965         case CPP_MINUS:
 966           if (want_value)
 967             op.op = CPP_UMINUS;
 968           break;
 969
 970         default:
 971           if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
 972             SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
 973                            cpp_token_as_text (pfile, op.token));
 974           break;
 975         }
 976
 977       /* Check we have a value or operator as appropriate.  */
 978       if (optab[op.op].flags & NO_L_OPERAND)
 979         {
 980           if (!want_value)
 981             SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
 982                            cpp_token_as_text (pfile, op.token));
 983         }
 984       else if (want_value)
 985         {
 986           /* We want a number (or expression) and haven't got one.
 987              Try to emit a specific diagnostic.  */
 988           if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
 989             SYNTAX_ERROR ("missing expression between '(' and ')'");
 990
 991           if (op.op == CPP_EOF && top->op == CPP_EOF)
 992             SYNTAX_ERROR2 ("%s with no expression", is_if ? "#if" : "#elif");
 993
 994           if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
 995             SYNTAX_ERROR2 ("operator '%s' has no right operand",
 996                            cpp_token_as_text (pfile, top->token));
 997           else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
 998             /* Complain about missing paren during reduction.  */;
 999           else
1000             SYNTAX_ERROR2 ("operator '%s' has no left operand",
1001                            cpp_token_as_text (pfile, op.token));
1002         }
1003
1004       top = reduce (pfile, top, op.op);
1005       if (!top)
1006         goto syntax_error;
1007
1008       if (op.op == CPP_EOF)
1009         break;
1010
1011       switch (op.op)
1012         {
1013         case CPP_CLOSE_PAREN:
1014           continue;
1015         case CPP_OR_OR:
1016           if (!num_zerop (top->value))
1017             pfile->state.skip_eval++;
1018           break;
1019         case CPP_AND_AND:
1020         case CPP_QUERY:
1021           if (num_zerop (top->value))
1022             pfile->state.skip_eval++;
1023           break;
1024         case CPP_COLON:
1025           if (top->op != CPP_QUERY)
1026             SYNTAX_ERROR (" ':' without preceding '?'");
1027           if (!num_zerop (top[-1].value)) /* Was '?' condition true?  */
1028             pfile->state.skip_eval++;
1029           else
1030             pfile->state.skip_eval--;
1031         default:
1032           break;
1033         }
1034
1035       want_value = true;
1036
1037       /* Check for and handle stack overflow.  */
1038       if (++top == pfile->op_limit)
1039         top = _cpp_expand_op_stack (pfile);
1040
1041       top->op = op.op;
1042       top->token = op.token;
1043       top->loc = op.token->src_loc;
1044     }
1045
1046   /* The controlling macro expression is only valid if we called lex 3
1047      times: <!> <defined expression> and <EOF>.  push_conditional ()
1048      checks that we are at top-of-file.  */
1049   if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
1050     pfile->mi_ind_cmacro = 0;
1051
1052   if (top != pfile->op_stack)
1053     {
1054       cpp_error (pfile, CPP_DL_ICE, "unbalanced stack in %s",
1055                  is_if ? "#if" : "#elif");
1056     syntax_error:
1057       return false;  /* Return false on syntax error.  */
1058     }
1059
1060   return !num_zerop (top->value);
1061 }
1062
1063 /* Reduce the operator / value stack if possible, in preparation for
1064    pushing operator OP.  Returns NULL on error, otherwise the top of
1065    the stack.  */
1066 static struct op *
1067 reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
1068 {
1069   unsigned int prio;
1070
1071   if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
1072     {
1073     bad_op:
1074       cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
1075       return 0;
1076     }
1077
1078   if (op == CPP_OPEN_PAREN)
1079     return top;
1080
1081   /* Decrement the priority of left-associative operators to force a
1082      reduction with operators of otherwise equal priority.  */
1083   prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
1084   while (prio < optab[top->op].prio)
1085     {
1086       if (CPP_OPTION (pfile, warn_num_sign_change)
1087           && optab[top->op].flags & CHECK_PROMOTION)
1088         check_promotion (pfile, top);
1089
1090       switch (top->op)
1091         {
1092         case CPP_UPLUS:
1093         case CPP_UMINUS:
1094         case CPP_NOT:
1095         case CPP_COMPL:
1096           top[-1].value = num_unary_op (pfile, top->value, top->op);
1097           top[-1].loc = top->loc;
1098           break;
1099
1100         case CPP_PLUS:
1101         case CPP_MINUS:
1102         case CPP_RSHIFT:
1103         case CPP_LSHIFT:
1104         case CPP_COMMA:
1105           top[-1].value = num_binary_op (pfile, top[-1].value,
1106                                          top->value, top->op);
1107           top[-1].loc = top->loc;
1108           break;
1109
1110         case CPP_GREATER:
1111         case CPP_LESS:
1112         case CPP_GREATER_EQ:
1113         case CPP_LESS_EQ:
1114           top[-1].value
1115             = num_inequality_op (pfile, top[-1].value, top->value, top->op);
1116           top[-1].loc = top->loc;
1117           break;
1118
1119         case CPP_EQ_EQ:
1120         case CPP_NOT_EQ:
1121           top[-1].value
1122             = num_equality_op (pfile, top[-1].value, top->value, top->op);
1123           top[-1].loc = top->loc;
1124           break;
1125
1126         case CPP_AND:
1127         case CPP_OR:
1128         case CPP_XOR:
1129           top[-1].value
1130             = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
1131           top[-1].loc = top->loc;
1132           break;
1133
1134         case CPP_MULT:
1135           top[-1].value = num_mul (pfile, top[-1].value, top->value);
1136           top[-1].loc = top->loc;
1137           break;
1138
1139         case CPP_DIV:
1140         case CPP_MOD:
1141           top[-1].value = num_div_op (pfile, top[-1].value,
1142                                       top->value, top->op, top->loc);
1143           top[-1].loc = top->loc;
1144           break;
1145
1146         case CPP_OR_OR:
1147           top--;
1148           if (!num_zerop (top->value))
1149             pfile->state.skip_eval--;
1150           top->value.low = (!num_zerop (top->value)
1151                             || !num_zerop (top[1].value));
1152           top->value.high = 0;
1153           top->value.unsignedp = false;
1154           top->value.overflow = false;
1155           top->loc = top[1].loc;
1156           continue;
1157
1158         case CPP_AND_AND:
1159           top--;
1160           if (num_zerop (top->value))
1161             pfile->state.skip_eval--;
1162           top->value.low = (!num_zerop (top->value)
1163                             && !num_zerop (top[1].value));
1164           top->value.high = 0;
1165           top->value.unsignedp = false;
1166           top->value.overflow = false;
1167           top->loc = top[1].loc;
1168           continue;
1169
1170         case CPP_OPEN_PAREN:
1171           if (op != CPP_CLOSE_PAREN)
1172             {
1173               cpp_error_with_line (pfile, CPP_DL_ERROR,
1174                                    top->token->src_loc,
1175                                    0, "missing ')' in expression");
1176               return 0;
1177             }
1178           top--;
1179           top->value = top[1].value;
1180           top->loc = top[1].loc;
1181           return top;
1182
1183         case CPP_COLON:
1184           top -= 2;
1185           if (!num_zerop (top->value))
1186             {
1187               pfile->state.skip_eval--;
1188               top->value = top[1].value;
1189               top->loc = top[1].loc;
1190             }
1191           else
1192             {
1193               top->value = top[2].value;
1194               top->loc = top[2].loc;
1195             }
1196           top->value.unsignedp = (top[1].value.unsignedp
1197                                   || top[2].value.unsignedp);
1198           continue;
1199
1200         case CPP_QUERY:
1201           /* COMMA and COLON should not reduce a QUERY operator.  */
1202           if (op == CPP_COMMA || op == CPP_COLON)
1203             return top;
1204           cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
1205           return 0;
1206
1207         default:
1208           goto bad_op;
1209         }
1210
1211       top--;
1212       if (top->value.overflow && !pfile->state.skip_eval)
1213         cpp_error (pfile, CPP_DL_PEDWARN,
1214                    "integer overflow in preprocessor expression");
1215     }
1216
1217   if (op == CPP_CLOSE_PAREN)
1218     {
1219       cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
1220       return 0;
1221     }
1222
1223   return top;
1224 }
1225
1226 /* Returns the position of the old top of stack after expansion.  */
1227 struct op *
1228 _cpp_expand_op_stack (cpp_reader *pfile)
1229 {
1230   size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
1231   size_t new_size = old_size * 2 + 20;
1232
1233   pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
1234   pfile->op_limit = pfile->op_stack + new_size;
1235
1236   return pfile->op_stack + old_size;
1237 }
1238
1239 /* Emits a warning if the effective sign of either operand of OP
1240    changes because of integer promotions.  */
1241 static void
1242 check_promotion (cpp_reader *pfile, const struct op *op)
1243 {
1244   if (op->value.unsignedp == op[-1].value.unsignedp)
1245     return;
1246
1247   if (op->value.unsignedp)
1248     {
1249       if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1250         cpp_error_with_line (pfile, CPP_DL_WARNING, op[-1].loc, 0,
1251                              "the left operand of \"%s\" changes sign when promoted",
1252                              cpp_token_as_text (pfile, op->token));
1253     }
1254   else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1255     cpp_error_with_line (pfile, CPP_DL_WARNING, op->loc, 0,
1256                "the right operand of \"%s\" changes sign when promoted",
1257                cpp_token_as_text (pfile, op->token));
1258 }
1259
1260 /* Clears the unused high order bits of the number pointed to by PNUM.  */
1261 static cpp_num
1262 num_trim (cpp_num num, size_t precision)
1263 {
1264   if (precision > PART_PRECISION)
1265     {
1266       precision -= PART_PRECISION;
1267       if (precision < PART_PRECISION)
1268         num.high &= ((cpp_num_part) 1 << precision) - 1;
1269     }
1270   else
1271     {
1272       if (precision < PART_PRECISION)
1273         num.low &= ((cpp_num_part) 1 << precision) - 1;
1274       num.high = 0;
1275     }
1276
1277   return num;
1278 }
1279
1280 /* True iff A (presumed signed) >= 0.  */
1281 static bool
1282 num_positive (cpp_num num, size_t precision)
1283 {
1284   if (precision > PART_PRECISION)
1285     {
1286       precision -= PART_PRECISION;
1287       return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1288     }
1289
1290   return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1291 }
1292
1293 /* Sign extend a number, with PRECISION significant bits and all
1294    others assumed clear, to fill out a cpp_num structure.  */
1295 cpp_num
1296 cpp_num_sign_extend (cpp_num num, size_t precision)
1297 {
1298   if (!num.unsignedp)
1299     {
1300       if (precision > PART_PRECISION)
1301         {
1302           precision -= PART_PRECISION;
1303           if (precision < PART_PRECISION
1304               && (num.high & (cpp_num_part) 1 << (precision - 1)))
1305             num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1306         }
1307       else if (num.low & (cpp_num_part) 1 << (precision - 1))
1308         {
1309           if (precision < PART_PRECISION)
1310             num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1311           num.high = ~(cpp_num_part) 0;
1312         }
1313     }
1314
1315   return num;
1316 }
1317
1318 /* Returns the negative of NUM.  */
1319 static cpp_num
1320 num_negate (cpp_num num, size_t precision)
1321 {
1322   cpp_num copy;
1323
1324   copy = num;
1325   num.high = ~num.high;
1326   num.low = ~num.low;
1327   if (++num.low == 0)
1328     num.high++;
1329   num = num_trim (num, precision);
1330   num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1331
1332   return num;
1333 }
1334
1335 /* Returns true if A >= B.  */
1336 static bool
1337 num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1338 {
1339   bool unsignedp;
1340
1341   unsignedp = pa.unsignedp || pb.unsignedp;
1342
1343   if (!unsignedp)
1344     {
1345       /* Both numbers have signed type.  If they are of different
1346        sign, the answer is the sign of A.  */
1347       unsignedp = num_positive (pa, precision);
1348
1349       if (unsignedp != num_positive (pb, precision))
1350         return unsignedp;
1351
1352       /* Otherwise we can do an unsigned comparison.  */
1353     }
1354
1355   return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1356 }
1357
1358 /* Returns LHS OP RHS, where OP is a bit-wise operation.  */
1359 static cpp_num
1360 num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1361                 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1362 {
1363   lhs.overflow = false;
1364   lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1365
1366   /* As excess precision is zeroed, there is no need to num_trim () as
1367      these operations cannot introduce a set bit there.  */
1368   if (op == CPP_AND)
1369     {
1370       lhs.low &= rhs.low;
1371       lhs.high &= rhs.high;
1372     }
1373   else if (op == CPP_OR)
1374     {
1375       lhs.low |= rhs.low;
1376       lhs.high |= rhs.high;
1377     }
1378   else
1379     {
1380       lhs.low ^= rhs.low;
1381       lhs.high ^= rhs.high;
1382     }
1383
1384   return lhs;
1385 }
1386
1387 /* Returns LHS OP RHS, where OP is an inequality.  */
1388 static cpp_num
1389 num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1390                    enum cpp_ttype op)
1391 {
1392   bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1393
1394   if (op == CPP_GREATER_EQ)
1395     lhs.low = gte;
1396   else if (op == CPP_LESS)
1397     lhs.low = !gte;
1398   else if (op == CPP_GREATER)
1399     lhs.low = gte && !num_eq (lhs, rhs);
1400   else /* CPP_LESS_EQ.  */
1401     lhs.low = !gte || num_eq (lhs, rhs);
1402
1403   lhs.high = 0;
1404   lhs.overflow = false;
1405   lhs.unsignedp = false;
1406   return lhs;
1407 }
1408
1409 /* Returns LHS OP RHS, where OP is == or !=.  */
1410 static cpp_num
1411 num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1412                  cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1413 {
1414   /* Work around a 3.0.4 bug; see PR 6950.  */
1415   bool eq = num_eq (lhs, rhs);
1416   if (op == CPP_NOT_EQ)
1417     eq = !eq;
1418   lhs.low = eq;
1419   lhs.high = 0;
1420   lhs.overflow = false;
1421   lhs.unsignedp = false;
1422   return lhs;
1423 }
1424
1425 /* Shift NUM, of width PRECISION, right by N bits.  */
1426 static cpp_num
1427 num_rshift (cpp_num num, size_t precision, size_t n)
1428 {
1429   cpp_num_part sign_mask;
1430   bool x = num_positive (num, precision);
1431
1432   if (num.unsignedp || x)
1433     sign_mask = 0;
1434   else
1435     sign_mask = ~(cpp_num_part) 0;
1436
1437   if (n >= precision)
1438     num.high = num.low = sign_mask;
1439   else
1440     {
1441       /* Sign-extend.  */
1442       if (precision < PART_PRECISION)
1443         num.high = sign_mask, num.low |= sign_mask << precision;
1444       else if (precision < 2 * PART_PRECISION)
1445         num.high |= sign_mask << (precision - PART_PRECISION);
1446
1447       if (n >= PART_PRECISION)
1448         {
1449           n -= PART_PRECISION;
1450           num.low = num.high;
1451           num.high = sign_mask;
1452         }
1453
1454       if (n)
1455         {
1456           num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1457           num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1458         }
1459     }
1460
1461   num = num_trim (num, precision);
1462   num.overflow = false;
1463   return num;
1464 }
1465
1466 /* Shift NUM, of width PRECISION, left by N bits.  */
1467 static cpp_num
1468 num_lshift (cpp_num num, size_t precision, size_t n)
1469 {
1470   if (n >= precision)
1471     {
1472       num.overflow = !num.unsignedp && !num_zerop (num);
1473       num.high = num.low = 0;
1474     }
1475   else
1476     {
1477       cpp_num orig, maybe_orig;
1478       size_t m = n;
1479
1480       orig = num;
1481       if (m >= PART_PRECISION)
1482         {
1483           m -= PART_PRECISION;
1484           num.high = num.low;
1485           num.low = 0;
1486         }
1487       if (m)
1488         {
1489           num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1490           num.low <<= m;
1491         }
1492       num = num_trim (num, precision);
1493
1494       if (num.unsignedp)
1495         num.overflow = false;
1496       else
1497         {
1498           maybe_orig = num_rshift (num, precision, n);
1499           num.overflow = !num_eq (orig, maybe_orig);
1500         }
1501     }
1502
1503   return num;
1504 }
1505
1506 /* The four unary operators: +, -, ! and ~.  */
1507 static cpp_num
1508 num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1509 {
1510   switch (op)
1511     {
1512     case CPP_UPLUS:
1513       if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1514         cpp_warning (pfile, CPP_W_TRADITIONAL,
1515                      "traditional C rejects the unary plus operator");
1516       num.overflow = false;
1517       break;
1518
1519     case CPP_UMINUS:
1520       num = num_negate (num, CPP_OPTION (pfile, precision));
1521       break;
1522
1523     case CPP_COMPL:
1524       num.high = ~num.high;
1525       num.low = ~num.low;
1526       num = num_trim (num, CPP_OPTION (pfile, precision));
1527       num.overflow = false;
1528       break;
1529
1530     default: /* case CPP_NOT: */
1531       num.low = num_zerop (num);
1532       num.high = 0;
1533       num.overflow = false;
1534       num.unsignedp = false;
1535       break;
1536     }
1537
1538   return num;
1539 }
1540
1541 /* The various binary operators.  */
1542 static cpp_num
1543 num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1544 {
1545   cpp_num result;
1546   size_t precision = CPP_OPTION (pfile, precision);
1547   size_t n;
1548
1549   switch (op)
1550     {
1551       /* Shifts.  */
1552     case CPP_LSHIFT:
1553     case CPP_RSHIFT:
1554       if (!rhs.unsignedp && !num_positive (rhs, precision))
1555         {
1556           /* A negative shift is a positive shift the other way.  */
1557           if (op == CPP_LSHIFT)
1558             op = CPP_RSHIFT;
1559           else
1560             op = CPP_LSHIFT;
1561           rhs = num_negate (rhs, precision);
1562         }
1563       if (rhs.high)
1564         n = ~0;                 /* Maximal.  */
1565       else
1566         n = rhs.low;
1567       if (op == CPP_LSHIFT)
1568         lhs = num_lshift (lhs, precision, n);
1569       else
1570         lhs = num_rshift (lhs, precision, n);
1571       break;
1572
1573       /* Arithmetic.  */
1574     case CPP_MINUS:
1575       rhs = num_negate (rhs, precision);
1576     case CPP_PLUS:
1577       result.low = lhs.low + rhs.low;
1578       result.high = lhs.high + rhs.high;
1579       if (result.low < lhs.low)
1580         result.high++;
1581       result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1582       result.overflow = false;
1583
1584       result = num_trim (result, precision);
1585       if (!result.unsignedp)
1586         {
1587           bool lhsp = num_positive (lhs, precision);
1588           result.overflow = (lhsp == num_positive (rhs, precision)
1589                              && lhsp != num_positive (result, precision));
1590         }
1591       return result;
1592
1593       /* Comma.  */
1594     default: /* case CPP_COMMA: */
1595       if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
1596                                    || !pfile->state.skip_eval))
1597         cpp_error (pfile, CPP_DL_PEDWARN,
1598                    "comma operator in operand of #if");
1599       lhs = rhs;
1600       break;
1601     }
1602
1603   return lhs;
1604 }
1605
1606 /* Multiplies two unsigned cpp_num_parts to give a cpp_num.  This
1607    cannot overflow.  */
1608 static cpp_num
1609 num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1610 {
1611   cpp_num result;
1612   cpp_num_part middle[2], temp;
1613
1614   result.low = LOW_PART (lhs) * LOW_PART (rhs);
1615   result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1616
1617   middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1618   middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1619
1620   temp = result.low;
1621   result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1622   if (result.low < temp)
1623     result.high++;
1624
1625   temp = result.low;
1626   result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1627   if (result.low < temp)
1628     result.high++;
1629
1630   result.high += HIGH_PART (middle[0]);
1631   result.high += HIGH_PART (middle[1]);
1632   result.unsignedp = true;
1633   result.overflow = false;
1634
1635   return result;
1636 }
1637
1638 /* Multiply two preprocessing numbers.  */
1639 static cpp_num
1640 num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
1641 {
1642   cpp_num result, temp;
1643   bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1644   bool overflow, negate = false;
1645   size_t precision = CPP_OPTION (pfile, precision);
1646
1647   /* Prepare for unsigned multiplication.  */
1648   if (!unsignedp)
1649     {
1650       if (!num_positive (lhs, precision))
1651         negate = !negate, lhs = num_negate (lhs, precision);
1652       if (!num_positive (rhs, precision))
1653         negate = !negate, rhs = num_negate (rhs, precision);
1654     }
1655
1656   overflow = lhs.high && rhs.high;
1657   result = num_part_mul (lhs.low, rhs.low);
1658
1659   temp = num_part_mul (lhs.high, rhs.low);
1660   result.high += temp.low;
1661   if (temp.high)
1662     overflow = true;
1663
1664   temp = num_part_mul (lhs.low, rhs.high);
1665   result.high += temp.low;
1666   if (temp.high)
1667     overflow = true;
1668
1669   temp.low = result.low, temp.high = result.high;
1670   result = num_trim (result, precision);
1671   if (!num_eq (result, temp))
1672     overflow = true;
1673
1674   if (negate)
1675     result = num_negate (result, precision);
1676
1677   if (unsignedp)
1678     result.overflow = false;
1679   else
1680     result.overflow = overflow || (num_positive (result, precision) ^ !negate
1681                                    && !num_zerop (result));
1682   result.unsignedp = unsignedp;
1683
1684   return result;
1685 }
1686
1687 /* Divide two preprocessing numbers, LHS and RHS, returning the answer
1688    or the remainder depending upon OP. LOCATION is the source location
1689    of this operator (for diagnostics).  */
1690
1691 static cpp_num
1692 num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op,
1693             source_location location)
1694 {
1695   cpp_num result, sub;
1696   cpp_num_part mask;
1697   bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1698   bool negate = false, lhs_neg = false;
1699   size_t i, precision = CPP_OPTION (pfile, precision);
1700
1701   /* Prepare for unsigned division.  */
1702   if (!unsignedp)
1703     {
1704       if (!num_positive (lhs, precision))
1705         negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1706       if (!num_positive (rhs, precision))
1707         negate = !negate, rhs = num_negate (rhs, precision);
1708     }
1709
1710   /* Find the high bit.  */
1711   if (rhs.high)
1712     {
1713       i = precision - 1;
1714       mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1715       for (; ; i--, mask >>= 1)
1716         if (rhs.high & mask)
1717           break;
1718     }
1719   else if (rhs.low)
1720     {
1721       if (precision > PART_PRECISION)
1722         i = precision - PART_PRECISION - 1;
1723       else
1724         i = precision - 1;
1725       mask = (cpp_num_part) 1 << i;
1726       for (; ; i--, mask >>= 1)
1727         if (rhs.low & mask)
1728           break;
1729     }
1730   else
1731     {
1732       if (!pfile->state.skip_eval)
1733         cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
1734                              "division by zero in #if");
1735       return lhs;
1736     }
1737
1738   /* First nonzero bit of RHS is bit I.  Do naive division by
1739      shifting the RHS fully left, and subtracting from LHS if LHS is
1740      at least as big, and then repeating but with one less shift.
1741      This is not very efficient, but is easy to understand.  */
1742
1743   rhs.unsignedp = true;
1744   lhs.unsignedp = true;
1745   i = precision - i - 1;
1746   sub = num_lshift (rhs, precision, i);
1747
1748   result.high = result.low = 0;
1749   for (;;)
1750     {
1751       if (num_greater_eq (lhs, sub, precision))
1752         {
1753           lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
1754           if (i >= PART_PRECISION)
1755             result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
1756           else
1757             result.low |= (cpp_num_part) 1 << i;
1758         }
1759       if (i-- == 0)
1760         break;
1761       sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
1762       sub.high >>= 1;
1763     }
1764
1765   /* We divide so that the remainder has the sign of the LHS.  */
1766   if (op == CPP_DIV)
1767     {
1768       result.unsignedp = unsignedp;
1769       result.overflow = false;
1770       if (!unsignedp)
1771         {
1772           if (negate)
1773             result = num_negate (result, precision);
1774           result.overflow = (num_positive (result, precision) ^ !negate
1775                              && !num_zerop (result));
1776         }
1777
1778       return result;
1779     }
1780
1781   /* CPP_MOD.  */
1782   lhs.unsignedp = unsignedp;
1783   lhs.overflow = false;
1784   if (lhs_neg)
1785     lhs = num_negate (lhs, precision);
1786
1787   return lhs;
1788 }