gcc/cppexp.c

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