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