OSDN Git Service

* config/mips/mips.c (TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P): Undef.
[pf3gnuchains/gcc-fork.git] / 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 }