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