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, 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, 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 (pfile->cb.used_define)
 704                 pfile->cb.used_define (pfile, pfile->directive_line, node);
 705             }
 706           else
 707             {
 708               if (pfile->cb.used_undef)
 709                 pfile->cb.used_undef (pfile, pfile->directive_line, node);
 710             }
 711         }
 712
 713       /* A possible controlling macro of the form #if !defined ().
 714          _cpp_parse_expr checks there was no other junk on the line.  */
 715       pfile->mi_ind_cmacro = node;
 716     }
 717
 718   pfile->state.prevent_expansion--;
 719
 720   result.unsignedp = false;
 721   result.high = 0;
 722   result.overflow = false;
 723   result.low = node && node->type == NT_MACRO;
 724   return result;
 725 }
 726
 727 /* Convert a token into a CPP_NUMBER (an interpreted preprocessing
 728    number or character constant, or the result of the "defined" or "#"
 729    operators).  */
 730 static cpp_num
 731 eval_token (cpp_reader *pfile, const cpp_token *token)
 732 {
 733   cpp_num result;
 734   unsigned int temp;
 735   int unsignedp = 0;
 736
 737   result.unsignedp = false;
 738   result.overflow = false;
 739
 740   switch (token->type)
 741     {
 742     case CPP_NUMBER:
 743       temp = cpp_classify_number (pfile, token);
 744       switch (temp & CPP_N_CATEGORY)
 745         {
 746         case CPP_N_FLOATING:
 747           cpp_error (pfile, CPP_DL_ERROR,
 748                      "floating constant in preprocessor expression");
 749           break;
 750         case CPP_N_INTEGER:
 751           if (!(temp & CPP_N_IMAGINARY))
 752             return cpp_interpret_integer (pfile, token, temp);
 753           cpp_error (pfile, CPP_DL_ERROR,
 754                      "imaginary number in preprocessor expression");
 755           break;
 756
 757         case CPP_N_INVALID:
 758           /* Error already issued.  */
 759           break;
 760         }
 761       result.high = result.low = 0;
 762       break;
 763
 764     case CPP_WCHAR:
 765     case CPP_CHAR:
 766     case CPP_CHAR16:
 767     case CPP_CHAR32:
 768       {
 769         cppchar_t cc = cpp_interpret_charconst (pfile, token,
 770                                                 &temp, &unsignedp);
 771
 772         result.high = 0;
 773         result.low = cc;
 774         /* Sign-extend the result if necessary.  */
 775         if (!unsignedp && (cppchar_signed_t) cc < 0)
 776           {
 777             if (PART_PRECISION > BITS_PER_CPPCHAR_T)
 778               result.low |= ~(~(cpp_num_part) 0
 779                               >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
 780             result.high = ~(cpp_num_part) 0;
 781             result = num_trim (result, CPP_OPTION (pfile, precision));
 782           }
 783       }
 784       break;
 785
 786     case CPP_NAME:
 787       if (token->val.node.node == pfile->spec_nodes.n_defined)
 788         return parse_defined (pfile);
 789       else if (CPP_OPTION (pfile, cplusplus)
 790                && (token->val.node.node == pfile->spec_nodes.n_true
 791                    || token->val.node.node == pfile->spec_nodes.n_false))
 792         {
 793           result.high = 0;
 794           result.low = (token->val.node.node == pfile->spec_nodes.n_true);
 795         }
 796       else
 797         {
 798           result.high = 0;
 799           result.low = 0;
 800           if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
 801             cpp_warning (pfile, CPP_W_UNDEF, "\"%s\" is not defined",
 802                          NODE_NAME (token->val.node.node));
 803         }
 804       break;
 805
 806     case CPP_HASH:
 807       if (!pfile->state.skipping)
 808         {
 809           /* A pedantic warning takes precedence over a deprecated
 810              warning here.  */
 811           if (CPP_PEDANTIC (pfile))
 812             cpp_error (pfile, CPP_DL_PEDWARN,
 813                        "assertions are a GCC extension");
 814           else if (CPP_OPTION (pfile, warn_deprecated))
 815             cpp_warning (pfile, CPP_W_DEPRECATED,
 816                          "assertions are a deprecated extension");
 817         }
 818       _cpp_test_assertion (pfile, &temp);
 819       result.high = 0;
 820       result.low = temp;
 821       break;
 822
 823     default:
 824       abort ();
 825     }
 826
 827   result.unsignedp = !!unsignedp;
 828   return result;
 829 }
 830 \f
 831 /* Operator precedence and flags table.
 832
 833 After an operator is returned from the lexer, if it has priority less
 834 than the operator on the top of the stack, we reduce the stack by one
 835 operator and repeat the test.  Since equal priorities do not reduce,
 836 this is naturally right-associative.
 837
 838 We handle left-associative operators by decrementing the priority of
 839 just-lexed operators by one, but retaining the priority of operators
 840 already on the stack.
 841
 842 The remaining cases are '(' and ')'.  We handle '(' by skipping the
 843 reduction phase completely.  ')' is given lower priority than
 844 everything else, including '(', effectively forcing a reduction of the
 845 parenthesized expression.  If there is a matching '(', the routine
 846 reduce() exits immediately.  If the normal exit route sees a ')', then
 847 there cannot have been a matching '(' and an error message is output.
 848
 849 The parser assumes all shifted operators require a left operand unless
 850 the flag NO_L_OPERAND is set.  These semantics are automatic; any
 851 extra semantics need to be handled with operator-specific code.  */
 852
 853 /* Flags.  If CHECK_PROMOTION, we warn if the effective sign of an
 854    operand changes because of integer promotions.  */
 855 #define NO_L_OPERAND    (1 << 0)
 856 #define LEFT_ASSOC      (1 << 1)
 857 #define CHECK_PROMOTION (1 << 2)
 858
 859 /* Operator to priority map.  Must be in the same order as the first
 860    N entries of enum cpp_ttype.  */
 861 static const struct cpp_operator
 862 {
 863   uchar prio;
 864   uchar flags;
 865 } optab[] =
 866 {
 867   /* EQ */              {0, 0}, /* Shouldn't happen.  */
 868   /* NOT */             {16, NO_L_OPERAND},
 869   /* GREATER */         {12, LEFT_ASSOC | CHECK_PROMOTION},
 870   /* LESS */            {12, LEFT_ASSOC | CHECK_PROMOTION},
 871   /* PLUS */            {14, LEFT_ASSOC | CHECK_PROMOTION},
 872   /* MINUS */           {14, LEFT_ASSOC | CHECK_PROMOTION},
 873   /* MULT */            {15, LEFT_ASSOC | CHECK_PROMOTION},
 874   /* DIV */             {15, LEFT_ASSOC | CHECK_PROMOTION},
 875   /* MOD */             {15, LEFT_ASSOC | CHECK_PROMOTION},
 876   /* AND */             {9, LEFT_ASSOC | CHECK_PROMOTION},
 877   /* OR */              {7, LEFT_ASSOC | CHECK_PROMOTION},
 878   /* XOR */             {8, LEFT_ASSOC | CHECK_PROMOTION},
 879   /* RSHIFT */          {13, LEFT_ASSOC},
 880   /* LSHIFT */          {13, LEFT_ASSOC},
 881
 882   /* COMPL */           {16, NO_L_OPERAND},
 883   /* AND_AND */         {6, LEFT_ASSOC},
 884   /* OR_OR */           {5, LEFT_ASSOC},
 885   /* Note that QUERY, COLON, and COMMA must have the same precedence.
 886      However, there are some special cases for these in reduce().  */
 887   /* QUERY */           {4, 0},
 888   /* COLON */           {4, LEFT_ASSOC | CHECK_PROMOTION},
 889   /* COMMA */           {4, LEFT_ASSOC},
 890   /* OPEN_PAREN */      {1, NO_L_OPERAND},
 891   /* CLOSE_PAREN */     {0, 0},
 892   /* EOF */             {0, 0},
 893   /* EQ_EQ */           {11, LEFT_ASSOC},
 894   /* NOT_EQ */          {11, LEFT_ASSOC},
 895   /* GREATER_EQ */      {12, LEFT_ASSOC | CHECK_PROMOTION},
 896   /* LESS_EQ */         {12, LEFT_ASSOC | CHECK_PROMOTION},
 897   /* UPLUS */           {16, NO_L_OPERAND},
 898   /* UMINUS */          {16, NO_L_OPERAND}
 899 };
 900
 901 /* Parse and evaluate a C expression, reading from PFILE.
 902    Returns the truth value of the expression.
 903
 904    The implementation is an operator precedence parser, i.e. a
 905    bottom-up parser, using a stack for not-yet-reduced tokens.
 906
 907    The stack base is op_stack, and the current stack pointer is 'top'.
 908    There is a stack element for each operator (only), and the most
 909    recently pushed operator is 'top->op'.  An operand (value) is
 910    stored in the 'value' field of the stack element of the operator
 911    that precedes it.  */
 912 bool
 913 _cpp_parse_expr (cpp_reader *pfile, bool is_if)
 914 {
 915   struct op *top = pfile->op_stack;
 916   unsigned int lex_count;
 917   bool saw_leading_not, want_value = true;
 918
 919   pfile->state.skip_eval = 0;
 920
 921   /* Set up detection of #if ! defined().  */
 922   pfile->mi_ind_cmacro = 0;
 923   saw_leading_not = false;
 924   lex_count = 0;
 925
 926   /* Lowest priority operator prevents further reductions.  */
 927   top->op = CPP_EOF;
 928
 929   for (;;)
 930     {
 931       struct op op;
 932
 933       lex_count++;
 934       op.token = cpp_get_token (pfile);
 935       op.op = op.token->type;
 936       op.loc = op.token->src_loc;
 937
 938       switch (op.op)
 939         {
 940           /* These tokens convert into values.  */
 941         case CPP_NUMBER:
 942         case CPP_CHAR:
 943         case CPP_WCHAR:
 944         case CPP_CHAR16:
 945         case CPP_CHAR32:
 946         case CPP_NAME:
 947         case CPP_HASH:
 948           if (!want_value)
 949             SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
 950                            cpp_token_as_text (pfile, op.token));
 951           want_value = false;
 952           top->value = eval_token (pfile, op.token);
 953           continue;
 954
 955         case CPP_NOT:
 956           saw_leading_not = lex_count == 1;
 957           break;
 958         case CPP_PLUS:
 959           if (want_value)
 960             op.op = CPP_UPLUS;
 961           break;
 962         case CPP_MINUS:
 963           if (want_value)
 964             op.op = CPP_UMINUS;
 965           break;
 966
 967         default:
 968           if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
 969             SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
 970                            cpp_token_as_text (pfile, op.token));
 971           break;
 972         }
 973
 974       /* Check we have a value or operator as appropriate.  */
 975       if (optab[op.op].flags & NO_L_OPERAND)
 976         {
 977           if (!want_value)
 978             SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
 979                            cpp_token_as_text (pfile, op.token));
 980         }
 981       else if (want_value)
 982         {
 983           /* We want a number (or expression) and haven't got one.
 984              Try to emit a specific diagnostic.  */
 985           if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
 986             SYNTAX_ERROR ("missing expression between '(' and ')'");
 987
 988           if (op.op == CPP_EOF && top->op == CPP_EOF)
 989             SYNTAX_ERROR2 ("%s with no expression", is_if ? "#if" : "#elif");
 990
 991           if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
 992             SYNTAX_ERROR2 ("operator '%s' has no right operand",
 993                            cpp_token_as_text (pfile, top->token));
 994           else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
 995             /* Complain about missing paren during reduction.  */;
 996           else
 997             SYNTAX_ERROR2 ("operator '%s' has no left operand",
 998                            cpp_token_as_text (pfile, op.token));
 999         }
1000
1001       top = reduce (pfile, top, op.op);
1002       if (!top)
1003         goto syntax_error;
1004
1005       if (op.op == CPP_EOF)
1006         break;
1007
1008       switch (op.op)
1009         {
1010         case CPP_CLOSE_PAREN:
1011           continue;
1012         case CPP_OR_OR:
1013           if (!num_zerop (top->value))
1014             pfile->state.skip_eval++;
1015           break;
1016         case CPP_AND_AND:
1017         case CPP_QUERY:
1018           if (num_zerop (top->value))
1019             pfile->state.skip_eval++;
1020           break;
1021         case CPP_COLON:
1022           if (top->op != CPP_QUERY)
1023             SYNTAX_ERROR (" ':' without preceding '?'");
1024           if (!num_zerop (top[-1].value)) /* Was '?' condition true?  */
1025             pfile->state.skip_eval++;
1026           else
1027             pfile->state.skip_eval--;
1028         default:
1029           break;
1030         }
1031
1032       want_value = true;
1033
1034       /* Check for and handle stack overflow.  */
1035       if (++top == pfile->op_limit)
1036         top = _cpp_expand_op_stack (pfile);
1037
1038       top->op = op.op;
1039       top->token = op.token;
1040       top->loc = op.token->src_loc;
1041     }
1042
1043   /* The controlling macro expression is only valid if we called lex 3
1044      times: <!> <defined expression> and <EOF>.  push_conditional ()
1045      checks that we are at top-of-file.  */
1046   if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
1047     pfile->mi_ind_cmacro = 0;
1048
1049   if (top != pfile->op_stack)
1050     {
1051       cpp_error (pfile, CPP_DL_ICE, "unbalanced stack in %s",
1052                  is_if ? "#if" : "#elif");
1053     syntax_error:
1054       return false;  /* Return false on syntax error.  */
1055     }
1056
1057   return !num_zerop (top->value);
1058 }
1059
1060 /* Reduce the operator / value stack if possible, in preparation for
1061    pushing operator OP.  Returns NULL on error, otherwise the top of
1062    the stack.  */
1063 static struct op *
1064 reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
1065 {
1066   unsigned int prio;
1067
1068   if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
1069     {
1070     bad_op:
1071       cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
1072       return 0;
1073     }
1074
1075   if (op == CPP_OPEN_PAREN)
1076     return top;
1077
1078   /* Decrement the priority of left-associative operators to force a
1079      reduction with operators of otherwise equal priority.  */
1080   prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
1081   while (prio < optab[top->op].prio)
1082     {
1083       if (CPP_OPTION (pfile, warn_num_sign_change)
1084           && optab[top->op].flags & CHECK_PROMOTION)
1085         check_promotion (pfile, top);
1086
1087       switch (top->op)
1088         {
1089         case CPP_UPLUS:
1090         case CPP_UMINUS:
1091         case CPP_NOT:
1092         case CPP_COMPL:
1093           top[-1].value = num_unary_op (pfile, top->value, top->op);
1094           top[-1].loc = top->loc;
1095           break;
1096
1097         case CPP_PLUS:
1098         case CPP_MINUS:
1099         case CPP_RSHIFT:
1100         case CPP_LSHIFT:
1101         case CPP_COMMA:
1102           top[-1].value = num_binary_op (pfile, top[-1].value,
1103                                          top->value, top->op);
1104           top[-1].loc = top->loc;
1105           break;
1106
1107         case CPP_GREATER:
1108         case CPP_LESS:
1109         case CPP_GREATER_EQ:
1110         case CPP_LESS_EQ:
1111           top[-1].value
1112             = num_inequality_op (pfile, top[-1].value, top->value, top->op);
1113           top[-1].loc = top->loc;
1114           break;
1115
1116         case CPP_EQ_EQ:
1117         case CPP_NOT_EQ:
1118           top[-1].value
1119             = num_equality_op (pfile, top[-1].value, top->value, top->op);
1120           top[-1].loc = top->loc;
1121           break;
1122
1123         case CPP_AND:
1124         case CPP_OR:
1125         case CPP_XOR:
1126           top[-1].value
1127             = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
1128           top[-1].loc = top->loc;
1129           break;
1130
1131         case CPP_MULT:
1132           top[-1].value = num_mul (pfile, top[-1].value, top->value);
1133           top[-1].loc = top->loc;
1134           break;
1135
1136         case CPP_DIV:
1137         case CPP_MOD:
1138           top[-1].value = num_div_op (pfile, top[-1].value,
1139                                       top->value, top->op, top->loc);
1140           top[-1].loc = top->loc;
1141           break;
1142
1143         case CPP_OR_OR:
1144           top--;
1145           if (!num_zerop (top->value))
1146             pfile->state.skip_eval--;
1147           top->value.low = (!num_zerop (top->value)
1148                             || !num_zerop (top[1].value));
1149           top->value.high = 0;
1150           top->value.unsignedp = false;
1151           top->value.overflow = false;
1152           top->loc = top[1].loc;
1153           continue;
1154
1155         case CPP_AND_AND:
1156           top--;
1157           if (num_zerop (top->value))
1158             pfile->state.skip_eval--;
1159           top->value.low = (!num_zerop (top->value)
1160                             && !num_zerop (top[1].value));
1161           top->value.high = 0;
1162           top->value.unsignedp = false;
1163           top->value.overflow = false;
1164           top->loc = top[1].loc;
1165           continue;
1166
1167         case CPP_OPEN_PAREN:
1168           if (op != CPP_CLOSE_PAREN)
1169             {
1170               cpp_error_with_line (pfile, CPP_DL_ERROR,
1171                                    top->token->src_loc,
1172                                    0, "missing ')' in expression");
1173               return 0;
1174             }
1175           top--;
1176           top->value = top[1].value;
1177           top->loc = top[1].loc;
1178           return top;
1179
1180         case CPP_COLON:
1181           top -= 2;
1182           if (!num_zerop (top->value))
1183             {
1184               pfile->state.skip_eval--;
1185               top->value = top[1].value;
1186               top->loc = top[1].loc;
1187             }
1188           else
1189             {
1190               top->value = top[2].value;
1191               top->loc = top[2].loc;
1192             }
1193           top->value.unsignedp = (top[1].value.unsignedp
1194                                   || top[2].value.unsignedp);
1195           continue;
1196
1197         case CPP_QUERY:
1198           /* COMMA and COLON should not reduce a QUERY operator.  */
1199           if (op == CPP_COMMA || op == CPP_COLON)
1200             return top;
1201           cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
1202           return 0;
1203
1204         default:
1205           goto bad_op;
1206         }
1207
1208       top--;
1209       if (top->value.overflow && !pfile->state.skip_eval)
1210         cpp_error (pfile, CPP_DL_PEDWARN,
1211                    "integer overflow in preprocessor expression");
1212     }
1213
1214   if (op == CPP_CLOSE_PAREN)
1215     {
1216       cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
1217       return 0;
1218     }
1219
1220   return top;
1221 }
1222
1223 /* Returns the position of the old top of stack after expansion.  */
1224 struct op *
1225 _cpp_expand_op_stack (cpp_reader *pfile)
1226 {
1227   size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
1228   size_t new_size = old_size * 2 + 20;
1229
1230   pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
1231   pfile->op_limit = pfile->op_stack + new_size;
1232
1233   return pfile->op_stack + old_size;
1234 }
1235
1236 /* Emits a warning if the effective sign of either operand of OP
1237    changes because of integer promotions.  */
1238 static void
1239 check_promotion (cpp_reader *pfile, const struct op *op)
1240 {
1241   if (op->value.unsignedp == op[-1].value.unsignedp)
1242     return;
1243
1244   if (op->value.unsignedp)
1245     {
1246       if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1247         cpp_error_with_line (pfile, CPP_DL_WARNING, op[-1].loc, 0,
1248                              "the left operand of \"%s\" changes sign when promoted",
1249                              cpp_token_as_text (pfile, op->token));
1250     }
1251   else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1252     cpp_error_with_line (pfile, CPP_DL_WARNING, op->loc, 0,
1253                "the right operand of \"%s\" changes sign when promoted",
1254                cpp_token_as_text (pfile, op->token));
1255 }
1256
1257 /* Clears the unused high order bits of the number pointed to by PNUM.  */
1258 static cpp_num
1259 num_trim (cpp_num num, size_t precision)
1260 {
1261   if (precision > PART_PRECISION)
1262     {
1263       precision -= PART_PRECISION;
1264       if (precision < PART_PRECISION)
1265         num.high &= ((cpp_num_part) 1 << precision) - 1;
1266     }
1267   else
1268     {
1269       if (precision < PART_PRECISION)
1270         num.low &= ((cpp_num_part) 1 << precision) - 1;
1271       num.high = 0;
1272     }
1273
1274   return num;
1275 }
1276
1277 /* True iff A (presumed signed) >= 0.  */
1278 static bool
1279 num_positive (cpp_num num, size_t precision)
1280 {
1281   if (precision > PART_PRECISION)
1282     {
1283       precision -= PART_PRECISION;
1284       return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1285     }
1286
1287   return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1288 }
1289
1290 /* Sign extend a number, with PRECISION significant bits and all
1291    others assumed clear, to fill out a cpp_num structure.  */
1292 cpp_num
1293 cpp_num_sign_extend (cpp_num num, size_t precision)
1294 {
1295   if (!num.unsignedp)
1296     {
1297       if (precision > PART_PRECISION)
1298         {
1299           precision -= PART_PRECISION;
1300           if (precision < PART_PRECISION
1301               && (num.high & (cpp_num_part) 1 << (precision - 1)))
1302             num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1303         }
1304       else if (num.low & (cpp_num_part) 1 << (precision - 1))
1305         {
1306           if (precision < PART_PRECISION)
1307             num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1308           num.high = ~(cpp_num_part) 0;
1309         }
1310     }
1311
1312   return num;
1313 }
1314
1315 /* Returns the negative of NUM.  */
1316 static cpp_num
1317 num_negate (cpp_num num, size_t precision)
1318 {
1319   cpp_num copy;
1320
1321   copy = num;
1322   num.high = ~num.high;
1323   num.low = ~num.low;
1324   if (++num.low == 0)
1325     num.high++;
1326   num = num_trim (num, precision);
1327   num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1328
1329   return num;
1330 }
1331
1332 /* Returns true if A >= B.  */
1333 static bool
1334 num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1335 {
1336   bool unsignedp;
1337
1338   unsignedp = pa.unsignedp || pb.unsignedp;
1339
1340   if (!unsignedp)
1341     {
1342       /* Both numbers have signed type.  If they are of different
1343        sign, the answer is the sign of A.  */
1344       unsignedp = num_positive (pa, precision);
1345
1346       if (unsignedp != num_positive (pb, precision))
1347         return unsignedp;
1348
1349       /* Otherwise we can do an unsigned comparison.  */
1350     }
1351
1352   return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1353 }
1354
1355 /* Returns LHS OP RHS, where OP is a bit-wise operation.  */
1356 static cpp_num
1357 num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1358                 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1359 {
1360   lhs.overflow = false;
1361   lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1362
1363   /* As excess precision is zeroed, there is no need to num_trim () as
1364      these operations cannot introduce a set bit there.  */
1365   if (op == CPP_AND)
1366     {
1367       lhs.low &= rhs.low;
1368       lhs.high &= rhs.high;
1369     }
1370   else if (op == CPP_OR)
1371     {
1372       lhs.low |= rhs.low;
1373       lhs.high |= rhs.high;
1374     }
1375   else
1376     {
1377       lhs.low ^= rhs.low;
1378       lhs.high ^= rhs.high;
1379     }
1380
1381   return lhs;
1382 }
1383
1384 /* Returns LHS OP RHS, where OP is an inequality.  */
1385 static cpp_num
1386 num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1387                    enum cpp_ttype op)
1388 {
1389   bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1390
1391   if (op == CPP_GREATER_EQ)
1392     lhs.low = gte;
1393   else if (op == CPP_LESS)
1394     lhs.low = !gte;
1395   else if (op == CPP_GREATER)
1396     lhs.low = gte && !num_eq (lhs, rhs);
1397   else /* CPP_LESS_EQ.  */
1398     lhs.low = !gte || num_eq (lhs, rhs);
1399
1400   lhs.high = 0;
1401   lhs.overflow = false;
1402   lhs.unsignedp = false;
1403   return lhs;
1404 }
1405
1406 /* Returns LHS OP RHS, where OP is == or !=.  */
1407 static cpp_num
1408 num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1409                  cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1410 {
1411   /* Work around a 3.0.4 bug; see PR 6950.  */
1412   bool eq = num_eq (lhs, rhs);
1413   if (op == CPP_NOT_EQ)
1414     eq = !eq;
1415   lhs.low = eq;
1416   lhs.high = 0;
1417   lhs.overflow = false;
1418   lhs.unsignedp = false;
1419   return lhs;
1420 }
1421
1422 /* Shift NUM, of width PRECISION, right by N bits.  */
1423 static cpp_num
1424 num_rshift (cpp_num num, size_t precision, size_t n)
1425 {
1426   cpp_num_part sign_mask;
1427   bool x = num_positive (num, precision);
1428
1429   if (num.unsignedp || x)
1430     sign_mask = 0;
1431   else
1432     sign_mask = ~(cpp_num_part) 0;
1433
1434   if (n >= precision)
1435     num.high = num.low = sign_mask;
1436   else
1437     {
1438       /* Sign-extend.  */
1439       if (precision < PART_PRECISION)
1440         num.high = sign_mask, num.low |= sign_mask << precision;
1441       else if (precision < 2 * PART_PRECISION)
1442         num.high |= sign_mask << (precision - PART_PRECISION);
1443
1444       if (n >= PART_PRECISION)
1445         {
1446           n -= PART_PRECISION;
1447           num.low = num.high;
1448           num.high = sign_mask;
1449         }
1450
1451       if (n)
1452         {
1453           num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1454           num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1455         }
1456     }
1457
1458   num = num_trim (num, precision);
1459   num.overflow = false;
1460   return num;
1461 }
1462
1463 /* Shift NUM, of width PRECISION, left by N bits.  */
1464 static cpp_num
1465 num_lshift (cpp_num num, size_t precision, size_t n)
1466 {
1467   if (n >= precision)
1468     {
1469       num.overflow = !num.unsignedp && !num_zerop (num);
1470       num.high = num.low = 0;
1471     }
1472   else
1473     {
1474       cpp_num orig, maybe_orig;
1475       size_t m = n;
1476
1477       orig = num;
1478       if (m >= PART_PRECISION)
1479         {
1480           m -= PART_PRECISION;
1481           num.high = num.low;
1482           num.low = 0;
1483         }
1484       if (m)
1485         {
1486           num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1487           num.low <<= m;
1488         }
1489       num = num_trim (num, precision);
1490
1491       if (num.unsignedp)
1492         num.overflow = false;
1493       else
1494         {
1495           maybe_orig = num_rshift (num, precision, n);
1496           num.overflow = !num_eq (orig, maybe_orig);
1497         }
1498     }
1499
1500   return num;
1501 }
1502
1503 /* The four unary operators: +, -, ! and ~.  */
1504 static cpp_num
1505 num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1506 {
1507   switch (op)
1508     {
1509     case CPP_UPLUS:
1510       if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1511         cpp_warning (pfile, CPP_W_TRADITIONAL,
1512                      "traditional C rejects the unary plus operator");
1513       num.overflow = false;
1514       break;
1515
1516     case CPP_UMINUS:
1517       num = num_negate (num, CPP_OPTION (pfile, precision));
1518       break;
1519
1520     case CPP_COMPL:
1521       num.high = ~num.high;
1522       num.low = ~num.low;
1523       num = num_trim (num, CPP_OPTION (pfile, precision));
1524       num.overflow = false;
1525       break;
1526
1527     default: /* case CPP_NOT: */
1528       num.low = num_zerop (num);
1529       num.high = 0;
1530       num.overflow = false;
1531       num.unsignedp = false;
1532       break;
1533     }
1534
1535   return num;
1536 }
1537
1538 /* The various binary operators.  */
1539 static cpp_num
1540 num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1541 {
1542   cpp_num result;
1543   size_t precision = CPP_OPTION (pfile, precision);
1544   size_t n;
1545
1546   switch (op)
1547     {
1548       /* Shifts.  */
1549     case CPP_LSHIFT:
1550     case CPP_RSHIFT:
1551       if (!rhs.unsignedp && !num_positive (rhs, precision))
1552         {
1553           /* A negative shift is a positive shift the other way.  */
1554           if (op == CPP_LSHIFT)
1555             op = CPP_RSHIFT;
1556           else
1557             op = CPP_LSHIFT;
1558           rhs = num_negate (rhs, precision);
1559         }
1560       if (rhs.high)
1561         n = ~0;                 /* Maximal.  */
1562       else
1563         n = rhs.low;
1564       if (op == CPP_LSHIFT)
1565         lhs = num_lshift (lhs, precision, n);
1566       else
1567         lhs = num_rshift (lhs, precision, n);
1568       break;
1569
1570       /* Arithmetic.  */
1571     case CPP_MINUS:
1572       rhs = num_negate (rhs, precision);
1573     case CPP_PLUS:
1574       result.low = lhs.low + rhs.low;
1575       result.high = lhs.high + rhs.high;
1576       if (result.low < lhs.low)
1577         result.high++;
1578       result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1579       result.overflow = false;
1580
1581       result = num_trim (result, precision);
1582       if (!result.unsignedp)
1583         {
1584           bool lhsp = num_positive (lhs, precision);
1585           result.overflow = (lhsp == num_positive (rhs, precision)
1586                              && lhsp != num_positive (result, precision));
1587         }
1588       return result;
1589
1590       /* Comma.  */
1591     default: /* case CPP_COMMA: */
1592       if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
1593                                    || !pfile->state.skip_eval))
1594         cpp_error (pfile, CPP_DL_PEDWARN,
1595                    "comma operator in operand of #if");
1596       lhs = rhs;
1597       break;
1598     }
1599
1600   return lhs;
1601 }
1602
1603 /* Multiplies two unsigned cpp_num_parts to give a cpp_num.  This
1604    cannot overflow.  */
1605 static cpp_num
1606 num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1607 {
1608   cpp_num result;
1609   cpp_num_part middle[2], temp;
1610
1611   result.low = LOW_PART (lhs) * LOW_PART (rhs);
1612   result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1613
1614   middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1615   middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1616
1617   temp = result.low;
1618   result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1619   if (result.low < temp)
1620     result.high++;
1621
1622   temp = result.low;
1623   result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1624   if (result.low < temp)
1625     result.high++;
1626
1627   result.high += HIGH_PART (middle[0]);
1628   result.high += HIGH_PART (middle[1]);
1629   result.unsignedp = true;
1630   result.overflow = false;
1631
1632   return result;
1633 }
1634
1635 /* Multiply two preprocessing numbers.  */
1636 static cpp_num
1637 num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
1638 {
1639   cpp_num result, temp;
1640   bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1641   bool overflow, negate = false;
1642   size_t precision = CPP_OPTION (pfile, precision);
1643
1644   /* Prepare for unsigned multiplication.  */
1645   if (!unsignedp)
1646     {
1647       if (!num_positive (lhs, precision))
1648         negate = !negate, lhs = num_negate (lhs, precision);
1649       if (!num_positive (rhs, precision))
1650         negate = !negate, rhs = num_negate (rhs, precision);
1651     }
1652
1653   overflow = lhs.high && rhs.high;
1654   result = num_part_mul (lhs.low, rhs.low);
1655
1656   temp = num_part_mul (lhs.high, rhs.low);
1657   result.high += temp.low;
1658   if (temp.high)
1659     overflow = true;
1660
1661   temp = num_part_mul (lhs.low, rhs.high);
1662   result.high += temp.low;
1663   if (temp.high)
1664     overflow = true;
1665
1666   temp.low = result.low, temp.high = result.high;
1667   result = num_trim (result, precision);
1668   if (!num_eq (result, temp))
1669     overflow = true;
1670
1671   if (negate)
1672     result = num_negate (result, precision);
1673
1674   if (unsignedp)
1675     result.overflow = false;
1676   else
1677     result.overflow = overflow || (num_positive (result, precision) ^ !negate
1678                                    && !num_zerop (result));
1679   result.unsignedp = unsignedp;
1680
1681   return result;
1682 }
1683
1684 /* Divide two preprocessing numbers, LHS and RHS, returning the answer
1685    or the remainder depending upon OP. LOCATION is the source location
1686    of this operator (for diagnostics).  */
1687
1688 static cpp_num
1689 num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op,
1690             source_location location)
1691 {
1692   cpp_num result, sub;
1693   cpp_num_part mask;
1694   bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1695   bool negate = false, lhs_neg = false;
1696   size_t i, precision = CPP_OPTION (pfile, precision);
1697
1698   /* Prepare for unsigned division.  */
1699   if (!unsignedp)
1700     {
1701       if (!num_positive (lhs, precision))
1702         negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1703       if (!num_positive (rhs, precision))
1704         negate = !negate, rhs = num_negate (rhs, precision);
1705     }
1706
1707   /* Find the high bit.  */
1708   if (rhs.high)
1709     {
1710       i = precision - 1;
1711       mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1712       for (; ; i--, mask >>= 1)
1713         if (rhs.high & mask)
1714           break;
1715     }
1716   else if (rhs.low)
1717     {
1718       if (precision > PART_PRECISION)
1719         i = precision - PART_PRECISION - 1;
1720       else
1721         i = precision - 1;
1722       mask = (cpp_num_part) 1 << i;
1723       for (; ; i--, mask >>= 1)
1724         if (rhs.low & mask)
1725           break;
1726     }
1727   else
1728     {
1729       if (!pfile->state.skip_eval)
1730         cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
1731                              "division by zero in #if");
1732       return lhs;
1733     }
1734
1735   /* First nonzero bit of RHS is bit I.  Do naive division by
1736      shifting the RHS fully left, and subtracting from LHS if LHS is
1737      at least as big, and then repeating but with one less shift.
1738      This is not very efficient, but is easy to understand.  */
1739
1740   rhs.unsignedp = true;
1741   lhs.unsignedp = true;
1742   i = precision - i - 1;
1743   sub = num_lshift (rhs, precision, i);
1744
1745   result.high = result.low = 0;
1746   for (;;)
1747     {
1748       if (num_greater_eq (lhs, sub, precision))
1749         {
1750           lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
1751           if (i >= PART_PRECISION)
1752             result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
1753           else
1754             result.low |= (cpp_num_part) 1 << i;
1755         }
1756       if (i-- == 0)
1757         break;
1758       sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
1759       sub.high >>= 1;
1760     }
1761
1762   /* We divide so that the remainder has the sign of the LHS.  */
1763   if (op == CPP_DIV)
1764     {
1765       result.unsignedp = unsignedp;
1766       result.overflow = false;
1767       if (!unsignedp)
1768         {
1769           if (negate)
1770             result = num_negate (result, precision);
1771           result.overflow = (num_positive (result, precision) ^ !negate
1772                              && !num_zerop (result));
1773         }
1774
1775       return result;
1776     }
1777
1778   /* CPP_MOD.  */
1779   lhs.unsignedp = unsignedp;
1780   lhs.overflow = false;
1781   if (lhs_neg)
1782     lhs = num_negate (lhs, precision);
1783
1784   return lhs;
1785 }