1/* Parse C expressions for cpplib.
2 Copyright (C) 1987-2023 Free Software Foundation, Inc.
3 Contributed by Per Bothner, 1994.
4
5This program is free software; you can redistribute it and/or modify it
6under the terms of the GNU General Public License as published by the
7Free Software Foundation; either version 3, or (at your option) any
8later version.
9
10This program is distributed in the hope that it will be useful,
11but WITHOUT ANY WARRANTY; without even the implied warranty of
12MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13GNU General Public License for more details.
14
15You should have received a copy of the GNU General Public License
16along with this program; see the file COPYING3. If not see
17<http://www.gnu.org/licenses/>. */
18
19#include "config.h"
20#include "system.h"
21#include "cpplib.h"
22#include "internal.h"
23
24#define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
25#define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
26#define LOW_PART(num_part) (num_part & HALF_MASK)
27#define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
28
29struct op
30{
31 const cpp_token *token; /* The token forming op (for diagnostics). */
32 cpp_num value; /* The value logically "right" of op. */
33 location_t loc; /* The location of this value. */
34 enum cpp_ttype op;
35};
36
37/* Some simple utility routines on double integers. */
38#define num_zerop(num) ((num.low | num.high) == 0)
39#define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
40static bool num_positive (cpp_num, size_t);
41static bool num_greater_eq (cpp_num, cpp_num, size_t);
42static cpp_num num_trim (cpp_num, size_t);
43static cpp_num num_part_mul (cpp_num_part, cpp_num_part);
44
45static cpp_num num_unary_op (cpp_reader *, cpp_num, enum cpp_ttype);
46static cpp_num num_binary_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
47static cpp_num num_negate (cpp_num, size_t);
48static cpp_num num_bitwise_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
49static cpp_num num_inequality_op (cpp_reader *, cpp_num, cpp_num,
50 enum cpp_ttype);
51static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,
52 enum cpp_ttype);
53static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num);
54static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype,
55 location_t);
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 *, location_t);
62static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);
63static unsigned int interpret_float_suffix (cpp_reader *, const uchar *, size_t);
64static unsigned int interpret_int_suffix (cpp_reader *, 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#define SYNTAX_ERROR_AT(loc, msgid) \
79 do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid); goto syntax_error; } \
80 while(0)
81#define SYNTAX_ERROR2_AT(loc, msgid, arg) \
82 do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid, arg); goto syntax_error; } \
83 while(0)
84
85/* Subroutine of cpp_classify_number. S points to a float suffix of
86 length LEN, possibly zero. Returns 0 for an invalid suffix, or a
87 flag vector (of CPP_N_* bits) describing the suffix. */
88static unsigned int
89interpret_float_suffix (cpp_reader *pfile, const uchar *s, size_t len)
90{
91 size_t orig_len = len;
92 const uchar *orig_s = s;
93 size_t flags;
94 size_t f, d, l, w, q, i, fn, fnx, fn_bits, bf16;
95
96 flags = 0;
97 f = d = l = w = q = i = fn = fnx = fn_bits = bf16 = 0;
98
99 /* The following decimal float suffixes, from TR 24732:2009, TS
100 18661-2:2015 and C23, are supported:
101
102 df, DF - _Decimal32.
103 dd, DD - _Decimal64.
104 dl, DL - _Decimal128.
105
106 The dN and DN suffixes for _DecimalN, and dNx and DNx for
107 _DecimalNx, defined in TS 18661-3:2015, are not supported.
108
109 Fixed-point suffixes, from TR 18037:2008, are supported. They
110 consist of three parts, in order:
111
112 (i) An optional u or U, for unsigned types.
113
114 (ii) An optional h or H, for short types, or l or L, for long
115 types, or ll or LL, for long long types. Use of ll or LL is a
116 GNU extension.
117
118 (iii) r or R, for _Fract types, or k or K, for _Accum types.
119
120 Otherwise the suffix is for a binary or standard floating-point
121 type. Such a suffix, or the absence of a suffix, may be preceded
122 or followed by i, I, j or J, to indicate an imaginary number with
123 the corresponding complex type. The following suffixes for
124 binary or standard floating-point types are supported:
125
126 f, F - float (ISO C and C++).
127 l, L - long double (ISO C and C++).
128 d, D - double, even with the FLOAT_CONST_DECIMAL64 pragma in
129 operation (from TR 24732:2009; the pragma and the suffix
130 are not included in TS 18661-2:2015).
131 w, W - machine-specific type such as __float80 (GNU extension).
132 q, Q - machine-specific type such as __float128 (GNU extension).
133 fN, FN - _FloatN (TS 18661-3:2015).
134 fNx, FNx - _FloatNx (TS 18661-3:2015).
135 bf16, BF16 - std::bfloat16_t (ISO C++23). */
136
137 /* Process decimal float suffixes, which are two letters starting
138 with d or D. Order and case are significant. */
139 if (len == 2 && (*s == 'd' || *s == 'D'))
140 {
141 bool uppercase = (*s == 'D');
142 switch (s[1])
143 {
144 case 'f': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL): 0); break;
145 case 'F': return (uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL) : 0); break;
146 case 'd': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM): 0); break;
147 case 'D': return (uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM) : 0); break;
148 case 'l': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
149 case 'L': return (uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
150 default:
151 /* Additional two-character suffixes beginning with D are not
152 for decimal float constants. */
153 break;
154 }
155 }
156
157 if (CPP_OPTION (pfile, ext_numeric_literals))
158 {
159 /* Recognize a fixed-point suffix. */
160 if (len != 0)
161 switch (s[len-1])
162 {
163 case 'k': case 'K': flags = CPP_N_ACCUM; break;
164 case 'r': case 'R': flags = CPP_N_FRACT; break;
165 default: break;
166 }
167
168 /* Continue processing a fixed-point suffix. The suffix is case
169 insensitive except for ll or LL. Order is significant. */
170 if (flags)
171 {
172 if (len == 1)
173 return flags;
174 len--;
175
176 if (*s == 'u' || *s == 'U')
177 {
178 flags |= CPP_N_UNSIGNED;
179 if (len == 1)
180 return flags;
181 len--;
182 s++;
183 }
184
185 switch (*s)
186 {
187 case 'h': case 'H':
188 if (len == 1)
189 return flags |= CPP_N_SMALL;
190 break;
191 case 'l':
192 if (len == 1)
193 return flags |= CPP_N_MEDIUM;
194 if (len == 2 && s[1] == 'l')
195 return flags |= CPP_N_LARGE;
196 break;
197 case 'L':
198 if (len == 1)
199 return flags |= CPP_N_MEDIUM;
200 if (len == 2 && s[1] == 'L')
201 return flags |= CPP_N_LARGE;
202 break;
203 default:
204 break;
205 }
206 /* Anything left at this point is invalid. */
207 return 0;
208 }
209 }
210
211 /* In any remaining valid suffix, the case and order don't matter. */
212 while (len--)
213 {
214 switch (s[0])
215 {
216 case 'f': case 'F':
217 f++;
218 if (len > 0
219 && s[1] >= '1'
220 && s[1] <= '9'
221 && fn_bits == 0)
222 {
223 f--;
224 while (len > 0
225 && s[1] >= '0'
226 && s[1] <= '9'
227 && fn_bits < CPP_FLOATN_MAX)
228 {
229 fn_bits = fn_bits * 10 + (s[1] - '0');
230 len--;
231 s++;
232 }
233 if (len > 0 && s[1] == 'x')
234 {
235 fnx++;
236 len--;
237 s++;
238 }
239 else
240 fn++;
241 }
242 break;
243 case 'b': case 'B':
244 if (len > 2
245 /* Except for bf16 / BF16 where case is significant. */
246 && s[1] == (s[0] == 'b' ? 'f' : 'F')
247 && s[2] == '1'
248 && s[3] == '6')
249 {
250 bf16++;
251 len -= 3;
252 s += 3;
253 break;
254 }
255 return 0;
256 case 'd': case 'D': d++; break;
257 case 'l': case 'L': l++; break;
258 case 'w': case 'W': w++; break;
259 case 'q': case 'Q': q++; break;
260 case 'i': case 'I':
261 case 'j': case 'J': i++; break;
262 default:
263 return 0;
264 }
265 s++;
266 }
267
268 /* Reject any case of multiple suffixes specifying types, multiple
269 suffixes specifying an imaginary constant, _FloatN or _FloatNx
270 suffixes for invalid values of N, and _FloatN suffixes for values
271 of N larger than can be represented in the return value. The
272 caller is responsible for rejecting _FloatN suffixes where
273 _FloatN is not supported on the chosen target. */
274 if (f + d + l + w + q + fn + fnx + bf16 > 1 || i > 1)
275 return 0;
276 if (fn_bits > CPP_FLOATN_MAX)
277 return 0;
278 if (fnx && fn_bits != 32 && fn_bits != 64 && fn_bits != 128)
279 return 0;
280 if (fn && fn_bits != 16 && fn_bits % 32 != 0)
281 return 0;
282 if (fn && fn_bits == 96)
283 return 0;
284
285 if (i)
286 {
287 if (!CPP_OPTION (pfile, ext_numeric_literals))
288 return 0;
289
290 /* In C++14 and up these suffixes are in the standard library, so treat
291 them as user-defined literals. */
292 if (CPP_OPTION (pfile, cplusplus)
293 && CPP_OPTION (pfile, lang) > CLK_CXX11
294 && orig_s[0] == 'i'
295 && (orig_len == 1
296 || (orig_len == 2
297 && (orig_s[1] == 'f' || orig_s[1] == 'l'))))
298 return 0;
299 }
300
301 if ((w || q) && !CPP_OPTION (pfile, ext_numeric_literals))
302 return 0;
303
304 return ((i ? CPP_N_IMAGINARY : 0)
305 | (f ? CPP_N_SMALL :
306 d ? CPP_N_MEDIUM :
307 l ? CPP_N_LARGE :
308 w ? CPP_N_MD_W :
309 q ? CPP_N_MD_Q :
310 fn ? CPP_N_FLOATN | (fn_bits << CPP_FLOATN_SHIFT) :
311 fnx ? CPP_N_FLOATNX | (fn_bits << CPP_FLOATN_SHIFT) :
312 bf16 ? CPP_N_BFLOAT16 :
313 CPP_N_DEFAULT));
314}
315
316/* Return the classification flags for a float suffix. */
317unsigned int
318cpp_interpret_float_suffix (cpp_reader *pfile, const char *s, size_t len)
319{
320 return interpret_float_suffix (pfile, s: (const unsigned char *)s, len);
321}
322
323/* Subroutine of cpp_classify_number. S points to an integer suffix
324 of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
325 flag vector describing the suffix. */
326static unsigned int
327interpret_int_suffix (cpp_reader *pfile, const uchar *s, size_t len)
328{
329 size_t orig_len = len;
330 size_t u, l, i, z, wb;
331
332 u = l = i = z = wb = 0;
333
334 while (len--)
335 switch (s[len])
336 {
337 case 'z': case 'Z': z++; break;
338 case 'u': case 'U': u++; break;
339 case 'i': case 'I':
340 case 'j': case 'J': i++; break;
341 case 'l': case 'L': l++;
342 /* If there are two Ls, they must be adjacent and the same case. */
343 if (l == 2 && s[len] != s[len + 1])
344 return 0;
345 break;
346 case 'b':
347 if (len == 0 || s[len - 1] != 'w')
348 return 0;
349 wb++;
350 len--;
351 break;
352 case 'B':
353 if (len == 0 || s[len - 1] != 'W')
354 return 0;
355 wb++;
356 len--;
357 break;
358 default:
359 return 0;
360 }
361
362 if (l > 2 || u > 1 || i > 1 || z > 1 || wb > 1)
363 return 0;
364
365 if (z)
366 {
367 if (l > 0 || i > 0)
368 return 0;
369 if (!CPP_OPTION (pfile, cplusplus))
370 return 0;
371 }
372
373 if (wb)
374 {
375 if (CPP_OPTION (pfile, cplusplus))
376 return 0;
377 if (l > 0 || i > 0 || z > 0)
378 return 0;
379 }
380
381 if (i)
382 {
383 if (!CPP_OPTION (pfile, ext_numeric_literals))
384 return 0;
385
386 /* In C++14 and up these suffixes are in the standard library, so treat
387 them as user-defined literals. */
388 if (CPP_OPTION (pfile, cplusplus)
389 && CPP_OPTION (pfile, lang) > CLK_CXX11
390 && s[0] == 'i'
391 && (orig_len == 1 || (orig_len == 2 && s[1] == 'l')))
392 return 0;
393 }
394
395 return ((i ? CPP_N_IMAGINARY : 0)
396 | (u ? CPP_N_UNSIGNED : 0)
397 | ((l == 0) ? CPP_N_SMALL
398 : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE)
399 | (z ? CPP_N_SIZE_T : 0)
400 | (wb ? CPP_N_BITINT : 0));
401}
402
403/* Return the classification flags for an int suffix. */
404unsigned int
405cpp_interpret_int_suffix (cpp_reader *pfile, const char *s, size_t len)
406{
407 return interpret_int_suffix (pfile, s: (const unsigned char *)s, len);
408}
409
410/* Return the string type corresponding to the the input user-defined string
411 literal type. If the input type is not a user-defined string literal
412 type return the input type. */
413enum cpp_ttype
414cpp_userdef_string_remove_type (enum cpp_ttype type)
415{
416 if (type == CPP_STRING_USERDEF)
417 return CPP_STRING;
418 else if (type == CPP_WSTRING_USERDEF)
419 return CPP_WSTRING;
420 else if (type == CPP_STRING16_USERDEF)
421 return CPP_STRING16;
422 else if (type == CPP_STRING32_USERDEF)
423 return CPP_STRING32;
424 else if (type == CPP_UTF8STRING_USERDEF)
425 return CPP_UTF8STRING;
426 else
427 return type;
428}
429
430/* Return the user-defined string literal type corresponding to the input
431 string type. If the input type is not a string type return the input
432 type. */
433enum cpp_ttype
434cpp_userdef_string_add_type (enum cpp_ttype type)
435{
436 if (type == CPP_STRING)
437 return CPP_STRING_USERDEF;
438 else if (type == CPP_WSTRING)
439 return CPP_WSTRING_USERDEF;
440 else if (type == CPP_STRING16)
441 return CPP_STRING16_USERDEF;
442 else if (type == CPP_STRING32)
443 return CPP_STRING32_USERDEF;
444 else if (type == CPP_UTF8STRING)
445 return CPP_UTF8STRING_USERDEF;
446 else
447 return type;
448}
449
450/* Return the char type corresponding to the the input user-defined char
451 literal type. If the input type is not a user-defined char literal
452 type return the input type. */
453enum cpp_ttype
454cpp_userdef_char_remove_type (enum cpp_ttype type)
455{
456 if (type == CPP_CHAR_USERDEF)
457 return CPP_CHAR;
458 else if (type == CPP_WCHAR_USERDEF)
459 return CPP_WCHAR;
460 else if (type == CPP_CHAR16_USERDEF)
461 return CPP_CHAR16;
462 else if (type == CPP_CHAR32_USERDEF)
463 return CPP_CHAR32;
464 else if (type == CPP_UTF8CHAR_USERDEF)
465 return CPP_UTF8CHAR;
466 else
467 return type;
468}
469
470/* Return the user-defined char literal type corresponding to the input
471 char type. If the input type is not a char type return the input
472 type. */
473enum cpp_ttype
474cpp_userdef_char_add_type (enum cpp_ttype type)
475{
476 if (type == CPP_CHAR)
477 return CPP_CHAR_USERDEF;
478 else if (type == CPP_WCHAR)
479 return CPP_WCHAR_USERDEF;
480 else if (type == CPP_CHAR16)
481 return CPP_CHAR16_USERDEF;
482 else if (type == CPP_CHAR32)
483 return CPP_CHAR32_USERDEF;
484 else if (type == CPP_UTF8CHAR)
485 return CPP_UTF8CHAR_USERDEF;
486 else
487 return type;
488}
489
490/* Return true if the token type is a user-defined string literal. */
491bool
492cpp_userdef_string_p (enum cpp_ttype type)
493{
494 if (type == CPP_STRING_USERDEF
495 || type == CPP_WSTRING_USERDEF
496 || type == CPP_STRING16_USERDEF
497 || type == CPP_STRING32_USERDEF
498 || type == CPP_UTF8STRING_USERDEF)
499 return true;
500 else
501 return false;
502}
503
504/* Return true if the token type is a user-defined char literal. */
505bool
506cpp_userdef_char_p (enum cpp_ttype type)
507{
508 if (type == CPP_CHAR_USERDEF
509 || type == CPP_WCHAR_USERDEF
510 || type == CPP_CHAR16_USERDEF
511 || type == CPP_CHAR32_USERDEF
512 || type == CPP_UTF8CHAR_USERDEF)
513 return true;
514 else
515 return false;
516}
517
518/* Extract the suffix from a user-defined literal string or char. */
519const char *
520cpp_get_userdef_suffix (const cpp_token *tok)
521{
522 unsigned int len = tok->val.str.len;
523 const char *text = (const char *)tok->val.str.text;
524 char delim;
525 unsigned int i;
526 for (i = 0; i < len; ++i)
527 if (text[i] == '\'' || text[i] == '"')
528 break;
529 if (i == len)
530 return text + len;
531 delim = text[i];
532 for (i = len; i > 0; --i)
533 if (text[i - 1] == delim)
534 break;
535 return text + i;
536}
537
538/* Categorize numeric constants according to their field (integer,
539 floating point, or invalid), radix (decimal, octal, hexadecimal),
540 and type suffixes.
541
542 TOKEN is the token that represents the numeric constant to
543 classify.
544
545 In C++0X if UD_SUFFIX is non null it will be assigned
546 any unrecognized suffix for a user-defined literal.
547
548 VIRTUAL_LOCATION is the virtual location for TOKEN. */
549unsigned int
550cpp_classify_number (cpp_reader *pfile, const cpp_token *token,
551 const char **ud_suffix, location_t virtual_location)
552{
553 const uchar *str = token->val.str.text;
554 const uchar *limit;
555 unsigned int max_digit, result, radix;
556 enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
557 bool seen_digit;
558 bool seen_digit_sep;
559
560 if (ud_suffix)
561 *ud_suffix = NULL;
562
563 /* If the lexer has done its job, length one can only be a single
564 digit. Fast-path this very common case. */
565 if (token->val.str.len == 1)
566 return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
567
568 limit = str + token->val.str.len;
569 float_flag = NOT_FLOAT;
570 max_digit = 0;
571 radix = 10;
572 seen_digit = false;
573 seen_digit_sep = false;
574
575 /* First, interpret the radix. */
576 if (*str == '0')
577 {
578 radix = 8;
579 str++;
580
581 /* Require at least one hex digit to classify it as hex. */
582 if (*str == 'x' || *str == 'X')
583 {
584 if (str[1] == '.' || ISXDIGIT (str[1]))
585 {
586 radix = 16;
587 str++;
588 }
589 else if (DIGIT_SEP (str[1]))
590 SYNTAX_ERROR_AT (virtual_location,
591 "digit separator after base indicator");
592 }
593 else if (*str == 'b' || *str == 'B')
594 {
595 if (str[1] == '0' || str[1] == '1')
596 {
597 radix = 2;
598 str++;
599 }
600 else if (DIGIT_SEP (str[1]))
601 SYNTAX_ERROR_AT (virtual_location,
602 "digit separator after base indicator");
603 }
604 }
605
606 /* Now scan for a well-formed integer or float. */
607 for (;;)
608 {
609 unsigned int c = *str++;
610
611 if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
612 {
613 seen_digit_sep = false;
614 seen_digit = true;
615 c = hex_value (c);
616 if (c > max_digit)
617 max_digit = c;
618 }
619 else if (DIGIT_SEP (c))
620 seen_digit_sep = true;
621 else if (c == '.')
622 {
623 if (seen_digit_sep || DIGIT_SEP (*str))
624 SYNTAX_ERROR_AT (virtual_location,
625 "digit separator adjacent to decimal point");
626 seen_digit_sep = false;
627 if (float_flag == NOT_FLOAT)
628 float_flag = AFTER_POINT;
629 else
630 SYNTAX_ERROR_AT (virtual_location,
631 "too many decimal points in number");
632 }
633 else if ((radix <= 10 && (c == 'e' || c == 'E'))
634 || (radix == 16 && (c == 'p' || c == 'P')))
635 {
636 if (seen_digit_sep || DIGIT_SEP (*str))
637 SYNTAX_ERROR_AT (virtual_location,
638 "digit separator adjacent to exponent");
639 float_flag = AFTER_EXPON;
640 break;
641 }
642 else
643 {
644 /* Start of suffix. */
645 str--;
646 break;
647 }
648 }
649
650 if (seen_digit_sep && float_flag != AFTER_EXPON)
651 SYNTAX_ERROR_AT (virtual_location,
652 "digit separator outside digit sequence");
653
654 /* The suffix may be for decimal fixed-point constants without exponent. */
655 if (radix != 16 && float_flag == NOT_FLOAT)
656 {
657 result = interpret_float_suffix (pfile, s: str, len: limit - str);
658 if ((result & CPP_N_FRACT) || (result & CPP_N_ACCUM))
659 {
660 result |= CPP_N_FLOATING;
661 /* We need to restore the radix to 10, if the radix is 8. */
662 if (radix == 8)
663 radix = 10;
664
665 if (CPP_PEDANTIC (pfile))
666 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
667 msgid: "fixed-point constants are a GCC extension");
668 goto syntax_ok;
669 }
670 else
671 result = 0;
672 }
673
674 if (float_flag != NOT_FLOAT && radix == 8)
675 radix = 10;
676
677 if (max_digit >= radix)
678 {
679 if (radix == 2)
680 SYNTAX_ERROR2_AT (virtual_location,
681 "invalid digit \"%c\" in binary constant", '0' + max_digit);
682 else
683 SYNTAX_ERROR2_AT (virtual_location,
684 "invalid digit \"%c\" in octal constant", '0' + max_digit);
685 }
686
687 if (float_flag != NOT_FLOAT)
688 {
689 if (radix == 2)
690 {
691 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
692 msgid: "invalid prefix \"0b\" for floating constant");
693 return CPP_N_INVALID;
694 }
695
696 if (radix == 16 && !seen_digit)
697 SYNTAX_ERROR_AT (virtual_location,
698 "no digits in hexadecimal floating constant");
699
700 if (radix == 16 && CPP_PEDANTIC (pfile)
701 && !CPP_OPTION (pfile, extended_numbers))
702 {
703 if (CPP_OPTION (pfile, cplusplus))
704 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
705 msgid: "use of C++17 hexadecimal floating constant");
706 else
707 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
708 msgid: "use of C99 hexadecimal floating constant");
709 }
710
711 if (float_flag == AFTER_EXPON)
712 {
713 if (*str == '+' || *str == '-')
714 str++;
715
716 /* Exponent is decimal, even if string is a hex float. */
717 if (!ISDIGIT (*str))
718 {
719 if (DIGIT_SEP (*str))
720 SYNTAX_ERROR_AT (virtual_location,
721 "digit separator adjacent to exponent");
722 else
723 SYNTAX_ERROR_AT (virtual_location, "exponent has no digits");
724 }
725 do
726 {
727 seen_digit_sep = DIGIT_SEP (*str);
728 str++;
729 }
730 while (ISDIGIT (*str) || DIGIT_SEP (*str));
731 }
732 else if (radix == 16)
733 SYNTAX_ERROR_AT (virtual_location,
734 "hexadecimal floating constants require an exponent");
735
736 if (seen_digit_sep)
737 SYNTAX_ERROR_AT (virtual_location,
738 "digit separator outside digit sequence");
739
740 result = interpret_float_suffix (pfile, s: str, len: limit - str);
741 if (result == 0)
742 {
743 if (CPP_OPTION (pfile, user_literals))
744 {
745 if (ud_suffix)
746 *ud_suffix = (const char *) str;
747 result = CPP_N_LARGE | CPP_N_USERDEF;
748 }
749 else
750 {
751 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
752 msgid: "invalid suffix \"%.*s\" on floating constant",
753 (int) (limit - str), str);
754 return CPP_N_INVALID;
755 }
756 }
757
758 /* Traditional C didn't accept any floating suffixes. */
759 if (limit != str
760 && CPP_WTRADITIONAL (pfile)
761 && ! cpp_sys_macro_p (pfile))
762 cpp_warning_with_line (pfile, CPP_W_TRADITIONAL, virtual_location, 0,
763 msgid: "traditional C rejects the \"%.*s\" suffix",
764 (int) (limit - str), str);
765
766 /* A suffix for double is a GCC extension via decimal float support.
767 If the suffix also specifies an imaginary value we'll catch that
768 later. */
769 if ((result == CPP_N_MEDIUM) && CPP_PEDANTIC (pfile))
770 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
771 msgid: "suffix for double constant is a GCC extension");
772
773 /* Radix must be 10 for decimal floats. */
774 if ((result & CPP_N_DFLOAT) && radix != 10)
775 {
776 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
777 msgid: "invalid suffix \"%.*s\" with hexadecimal floating constant",
778 (int) (limit - str), str);
779 return CPP_N_INVALID;
780 }
781
782 if ((result & (CPP_N_FRACT | CPP_N_ACCUM)) && CPP_PEDANTIC (pfile))
783 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
784 msgid: "fixed-point constants are a GCC extension");
785
786 if (result & CPP_N_DFLOAT)
787 {
788 if (CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, dfp_constants))
789 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
790 msgid: "decimal float constants are a C23 feature");
791 else if (CPP_OPTION (pfile, cpp_warn_c11_c23_compat) > 0)
792 cpp_warning_with_line (pfile, CPP_W_C11_C23_COMPAT,
793 virtual_location, 0,
794 msgid: "decimal float constants are a C23 feature");
795 }
796
797 result |= CPP_N_FLOATING;
798 }
799 else
800 {
801 result = interpret_int_suffix (pfile, s: str, len: limit - str);
802 if (result == 0)
803 {
804 if (CPP_OPTION (pfile, user_literals))
805 {
806 if (ud_suffix)
807 *ud_suffix = (const char *) str;
808 result = CPP_N_UNSIGNED | CPP_N_LARGE | CPP_N_USERDEF;
809 }
810 else
811 {
812 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
813 msgid: "invalid suffix \"%.*s\" on integer constant",
814 (int) (limit - str), str);
815 return CPP_N_INVALID;
816 }
817 }
818
819 /* Traditional C only accepted the 'L' suffix.
820 Suppress warning about 'LL' with -Wno-long-long. */
821 if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
822 {
823 int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
824 int large = (result & CPP_N_WIDTH) == CPP_N_LARGE
825 && CPP_OPTION (pfile, cpp_warn_long_long);
826
827 if (u_or_i || large)
828 cpp_warning_with_line (pfile, large ? CPP_W_LONG_LONG : CPP_W_TRADITIONAL,
829 virtual_location, 0,
830 msgid: "traditional C rejects the \"%.*s\" suffix",
831 (int) (limit - str), str);
832 }
833
834 if ((result & CPP_N_WIDTH) == CPP_N_LARGE
835 && CPP_OPTION (pfile, cpp_warn_long_long))
836 {
837 const char *message = CPP_OPTION (pfile, cplusplus)
838 ? N_("use of C++11 long long integer constant")
839 : N_("use of C99 long long integer constant");
840
841 if (CPP_OPTION (pfile, c99))
842 cpp_warning_with_line (pfile, CPP_W_LONG_LONG, virtual_location,
843 0, msgid: message);
844 else
845 cpp_pedwarning_with_line (pfile, CPP_W_LONG_LONG,
846 virtual_location, 0, msgid: message);
847 }
848
849 if ((result & CPP_N_SIZE_T) == CPP_N_SIZE_T
850 && !CPP_OPTION (pfile, size_t_literals))
851 {
852 const char *message = (result & CPP_N_UNSIGNED) == CPP_N_UNSIGNED
853 ? N_("use of C++23 %<size_t%> integer constant")
854 : N_("use of C++23 %<make_signed_t<size_t>%> integer constant");
855 cpp_warning_with_line (pfile, CPP_W_SIZE_T_LITERALS,
856 virtual_location, 0, msgid: message);
857 }
858
859 if ((result & CPP_N_BITINT) != 0
860 && CPP_OPTION (pfile, cpp_warn_c11_c23_compat) != 0)
861 {
862 if (CPP_OPTION (pfile, cpp_warn_c11_c23_compat) > 0)
863 {
864 const char *message = N_("ISO C does not support literal "
865 "%<wb%> suffixes before C23");
866 if (CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, true_false))
867 cpp_pedwarning_with_line (pfile, CPP_W_C11_C23_COMPAT,
868 virtual_location, 0, msgid: message);
869 else
870 cpp_warning_with_line (pfile, CPP_W_C11_C23_COMPAT,
871 virtual_location, 0, msgid: message);
872 }
873 else if (CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, true_false))
874 {
875 const char *message = N_("ISO C does not support literal "
876 "%<wb%> suffixes before C23");
877 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
878 msgid: message);
879 }
880 }
881
882 result |= CPP_N_INTEGER;
883 }
884
885 syntax_ok:
886 if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
887 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
888 msgid: "imaginary constants are a GCC extension");
889 if (radix == 2)
890 {
891 if (!CPP_OPTION (pfile, binary_constants)
892 && CPP_PEDANTIC (pfile))
893 cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
894 CPP_OPTION (pfile, cplusplus)
895 ? N_("binary constants are a C++14 feature "
896 "or GCC extension")
897 : N_("binary constants are a C23 feature "
898 "or GCC extension"));
899 else if (CPP_OPTION (pfile, cpp_warn_c11_c23_compat) > 0)
900 cpp_warning_with_line (pfile, CPP_W_C11_C23_COMPAT,
901 virtual_location, 0,
902 msgid: "binary constants are a C23 feature");
903 }
904
905 if (radix == 10)
906 result |= CPP_N_DECIMAL;
907 else if (radix == 16)
908 result |= CPP_N_HEX;
909 else if (radix == 2)
910 result |= CPP_N_BINARY;
911 else
912 result |= CPP_N_OCTAL;
913
914 return result;
915
916 syntax_error:
917 return CPP_N_INVALID;
918}
919
920/* cpp_interpret_integer converts an integer constant into a cpp_num,
921 of precision options->precision.
922
923 We do not provide any interface for decimal->float conversion,
924 because the preprocessor doesn't need it and we don't want to
925 drag in GCC's floating point emulator. */
926cpp_num
927cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
928 unsigned int type)
929{
930 const uchar *p, *end;
931 cpp_num result;
932
933 result.low = 0;
934 result.high = 0;
935 result.unsignedp = !!(type & CPP_N_UNSIGNED);
936 result.overflow = false;
937
938 p = token->val.str.text;
939 end = p + token->val.str.len;
940
941 /* Common case of a single digit. */
942 if (token->val.str.len == 1)
943 result.low = p[0] - '0';
944 else
945 {
946 cpp_num_part max;
947 size_t precision = CPP_OPTION (pfile, precision);
948 unsigned int base = 10, c = 0;
949 bool overflow = false;
950
951 if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
952 {
953 base = 8;
954 p++;
955 }
956 else if ((type & CPP_N_RADIX) == CPP_N_HEX)
957 {
958 base = 16;
959 p += 2;
960 }
961 else if ((type & CPP_N_RADIX) == CPP_N_BINARY)
962 {
963 base = 2;
964 p += 2;
965 }
966
967 /* We can add a digit to numbers strictly less than this without
968 needing the precision and slowness of double integers. */
969 max = ~(cpp_num_part) 0;
970 if (precision < PART_PRECISION)
971 max >>= PART_PRECISION - precision;
972 max = (max - base + 1) / base + 1;
973
974 for (; p < end; p++)
975 {
976 c = *p;
977
978 if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
979 c = hex_value (c);
980 else if (DIGIT_SEP (c))
981 continue;
982 else
983 break;
984
985 /* Strict inequality for when max is set to zero. */
986 if (result.low < max)
987 result.low = result.low * base + c;
988 else
989 {
990 result = append_digit (result, c, base, precision);
991 overflow |= result.overflow;
992 max = 0;
993 }
994 }
995
996 if (overflow && !(type & CPP_N_USERDEF))
997 cpp_error (pfile, CPP_DL_PEDWARN,
998 msgid: "integer constant is too large for its type");
999 /* If too big to be signed, consider it unsigned. Only warn for
1000 decimal numbers. Traditional numbers were always signed (but
1001 we still honor an explicit U suffix); but we only have
1002 traditional semantics in directives. */
1003 else if (!result.unsignedp
1004 && !(CPP_OPTION (pfile, traditional)
1005 && pfile->state.in_directive)
1006 && !num_positive (result, precision))
1007 {
1008 /* This is for constants within the range of uintmax_t but
1009 not that of intmax_t. For such decimal constants, a
1010 diagnostic is required for C99 as the selected type must
1011 be signed and not having a type is a constraint violation
1012 (DR#298, TC3), so this must be a pedwarn. For C90,
1013 unsigned long is specified to be used for a constant that
1014 does not fit in signed long; if uintmax_t has the same
1015 range as unsigned long this means only a warning is
1016 appropriate here. C90 permits the preprocessor to use a
1017 wider range than unsigned long in the compiler, so if
1018 uintmax_t is wider than unsigned long no diagnostic is
1019 required for such constants in preprocessor #if
1020 expressions and the compiler will pedwarn for such
1021 constants outside the range of unsigned long that reach
1022 the compiler so a diagnostic is not required there
1023 either; thus, pedwarn for C99 but use a plain warning for
1024 C90. */
1025 if (base == 10)
1026 cpp_error (pfile, (CPP_OPTION (pfile, c99)
1027 ? CPP_DL_PEDWARN
1028 : CPP_DL_WARNING),
1029 msgid: "integer constant is so large that it is unsigned");
1030 result.unsignedp = true;
1031 }
1032 }
1033
1034 return result;
1035}
1036
1037/* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE. */
1038static cpp_num
1039append_digit (cpp_num num, int digit, int base, size_t precision)
1040{
1041 cpp_num result;
1042 unsigned int shift;
1043 bool overflow;
1044 cpp_num_part add_high, add_low;
1045
1046 /* Multiply by 2, 8 or 16. Catching this overflow here means we don't
1047 need to worry about add_high overflowing. */
1048 switch (base)
1049 {
1050 case 2:
1051 shift = 1;
1052 break;
1053
1054 case 16:
1055 shift = 4;
1056 break;
1057
1058 default:
1059 shift = 3;
1060 }
1061 overflow = !!(num.high >> (PART_PRECISION - shift));
1062 result.high = num.high << shift;
1063 result.low = num.low << shift;
1064 result.high |= num.low >> (PART_PRECISION - shift);
1065 result.unsignedp = num.unsignedp;
1066
1067 if (base == 10)
1068 {
1069 add_low = num.low << 1;
1070 add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
1071 }
1072 else
1073 add_high = add_low = 0;
1074
1075 if (add_low + digit < add_low)
1076 add_high++;
1077 add_low += digit;
1078
1079 if (result.low + add_low < result.low)
1080 add_high++;
1081 if (result.high + add_high < result.high)
1082 overflow = true;
1083
1084 result.low += add_low;
1085 result.high += add_high;
1086 result.overflow = overflow;
1087
1088 /* The above code catches overflow of a cpp_num type. This catches
1089 overflow of the (possibly shorter) target precision. */
1090 num.low = result.low;
1091 num.high = result.high;
1092 result = num_trim (result, precision);
1093 if (!num_eq (result, num))
1094 result.overflow = true;
1095
1096 return result;
1097}
1098
1099/* Handle meeting "defined" in a preprocessor expression. */
1100static cpp_num
1101parse_defined (cpp_reader *pfile)
1102{
1103 cpp_num result;
1104 int paren = 0;
1105 cpp_hashnode *node = 0;
1106 const cpp_token *token;
1107 cpp_context *initial_context = pfile->context;
1108
1109 /* Don't expand macros. */
1110 pfile->state.prevent_expansion++;
1111
1112 token = cpp_get_token (pfile);
1113 if (token->type == CPP_OPEN_PAREN)
1114 {
1115 paren = 1;
1116 token = cpp_get_token (pfile);
1117 }
1118
1119 if (token->type == CPP_NAME)
1120 {
1121 node = token->val.node.node;
1122 if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
1123 {
1124 cpp_error (pfile, CPP_DL_ERROR, msgid: "missing ')' after \"defined\"");
1125 node = 0;
1126 }
1127 }
1128 else
1129 {
1130 cpp_error (pfile, CPP_DL_ERROR,
1131 msgid: "operator \"defined\" requires an identifier");
1132 if (token->flags & NAMED_OP)
1133 {
1134 cpp_token op;
1135
1136 op.flags = 0;
1137 op.type = token->type;
1138 cpp_error (pfile, CPP_DL_ERROR,
1139 msgid: "(\"%s\" is an alternative token for \"%s\" in C++)",
1140 cpp_token_as_text (pfile, token),
1141 cpp_token_as_text (pfile, &op));
1142 }
1143 }
1144
1145 bool is_defined = false;
1146 if (node)
1147 {
1148 if ((pfile->context != initial_context
1149 || initial_context != &pfile->base_context)
1150 && CPP_OPTION (pfile, warn_expansion_to_defined))
1151 cpp_pedwarning (pfile, CPP_W_EXPANSION_TO_DEFINED,
1152 msgid: "this use of \"defined\" may not be portable");
1153 is_defined = _cpp_defined_macro_p (node);
1154 if (!_cpp_maybe_notify_macro_use (pfile, node, loc: token->src_loc))
1155 /* It wasn't a macro after all. */
1156 is_defined = false;
1157 _cpp_mark_macro_used (node);
1158
1159 /* A possible controlling macro of the form #if !defined ().
1160 _cpp_parse_expr checks there was no other junk on the line. */
1161 pfile->mi_ind_cmacro = node;
1162 }
1163
1164 pfile->state.prevent_expansion--;
1165
1166 /* Do not treat conditional macros as being defined. This is due to the
1167 powerpc port using conditional macros for 'vector', 'bool', and 'pixel'
1168 to act as conditional keywords. This messes up tests like #ifndef
1169 bool. */
1170 result.unsignedp = false;
1171 result.high = 0;
1172 result.overflow = false;
1173 result.low = is_defined;
1174 return result;
1175}
1176
1177/* Convert a token into a CPP_NUMBER (an interpreted preprocessing
1178 number or character constant, or the result of the "defined" or "#"
1179 operators). */
1180static cpp_num
1181eval_token (cpp_reader *pfile, const cpp_token *token,
1182 location_t virtual_location)
1183{
1184 cpp_num result;
1185 unsigned int temp;
1186 int unsignedp = 0;
1187
1188 result.unsignedp = false;
1189 result.overflow = false;
1190
1191 switch (token->type)
1192 {
1193 case CPP_NUMBER:
1194 temp = cpp_classify_number (pfile, token, NULL, virtual_location);
1195 if (temp & CPP_N_USERDEF)
1196 cpp_error (pfile, CPP_DL_ERROR,
1197 msgid: "user-defined literal in preprocessor expression");
1198 switch (temp & CPP_N_CATEGORY)
1199 {
1200 case CPP_N_FLOATING:
1201 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
1202 msgid: "floating constant in preprocessor expression");
1203 break;
1204 case CPP_N_INTEGER:
1205 if (!(temp & CPP_N_IMAGINARY))
1206 return cpp_interpret_integer (pfile, token, type: temp);
1207 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
1208 msgid: "imaginary number in preprocessor expression");
1209 break;
1210
1211 case CPP_N_INVALID:
1212 /* Error already issued. */
1213 break;
1214 }
1215 result.high = result.low = 0;
1216 break;
1217
1218 case CPP_WCHAR:
1219 case CPP_CHAR:
1220 case CPP_CHAR16:
1221 case CPP_CHAR32:
1222 case CPP_UTF8CHAR:
1223 {
1224 cppchar_t cc = cpp_interpret_charconst (pfile, token,
1225 &temp, &unsignedp);
1226
1227 result.high = 0;
1228 result.low = cc;
1229 /* Sign-extend the result if necessary. */
1230 if (!unsignedp && (cppchar_signed_t) cc < 0)
1231 {
1232 if (PART_PRECISION > BITS_PER_CPPCHAR_T)
1233 result.low |= ~(~(cpp_num_part) 0
1234 >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
1235 result.high = ~(cpp_num_part) 0;
1236 result = num_trim (result, CPP_OPTION (pfile, precision));
1237 }
1238 }
1239 break;
1240
1241 case CPP_NAME:
1242 if (token->val.node.node == pfile->spec_nodes.n_defined)
1243 return parse_defined (pfile);
1244 else if (CPP_OPTION (pfile, true_false)
1245 && (token->val.node.node == pfile->spec_nodes.n_true
1246 || token->val.node.node == pfile->spec_nodes.n_false))
1247 {
1248 result.high = 0;
1249 result.low = (token->val.node.node == pfile->spec_nodes.n_true);
1250 }
1251 else
1252 {
1253 result.high = 0;
1254 result.low = 0;
1255 if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
1256 cpp_warning_with_line (pfile, CPP_W_UNDEF, virtual_location, 0,
1257 msgid: "\"%s\" is not defined, evaluates to 0",
1258 NODE_NAME (token->val.node.node));
1259 }
1260 break;
1261
1262 case CPP_HASH:
1263 if (!pfile->state.skipping)
1264 {
1265 /* A pedantic warning takes precedence over a deprecated
1266 warning here. */
1267 if (CPP_PEDANTIC (pfile))
1268 cpp_error_with_line (pfile, CPP_DL_PEDWARN,
1269 virtual_location, 0,
1270 msgid: "assertions are a GCC extension");
1271 else if (CPP_OPTION (pfile, cpp_warn_deprecated))
1272 cpp_warning_with_line (pfile, CPP_W_DEPRECATED, virtual_location, 0,
1273 msgid: "assertions are a deprecated extension");
1274 }
1275 _cpp_test_assertion (pfile, &temp);
1276 result.high = 0;
1277 result.low = temp;
1278 break;
1279
1280 default:
1281 abort ();
1282 }
1283
1284 result.unsignedp = !!unsignedp;
1285 return result;
1286}
1287
1288/* Operator precedence and flags table.
1289
1290After an operator is returned from the lexer, if it has priority less
1291than the operator on the top of the stack, we reduce the stack by one
1292operator and repeat the test. Since equal priorities do not reduce,
1293this is naturally right-associative.
1294
1295We handle left-associative operators by decrementing the priority of
1296just-lexed operators by one, but retaining the priority of operators
1297already on the stack.
1298
1299The remaining cases are '(' and ')'. We handle '(' by skipping the
1300reduction phase completely. ')' is given lower priority than
1301everything else, including '(', effectively forcing a reduction of the
1302parenthesized expression. If there is a matching '(', the routine
1303reduce() exits immediately. If the normal exit route sees a ')', then
1304there cannot have been a matching '(' and an error message is output.
1305
1306The parser assumes all shifted operators require a left operand unless
1307the flag NO_L_OPERAND is set. These semantics are automatic; any
1308extra semantics need to be handled with operator-specific code. */
1309
1310/* Flags. If CHECK_PROMOTION, we warn if the effective sign of an
1311 operand changes because of integer promotions. */
1312#define NO_L_OPERAND (1 << 0)
1313#define LEFT_ASSOC (1 << 1)
1314#define CHECK_PROMOTION (1 << 2)
1315
1316/* Operator to priority map. Must be in the same order as the first
1317 N entries of enum cpp_ttype. */
1318static const struct cpp_operator
1319{
1320 uchar prio;
1321 uchar flags;
1322} optab[] =
1323{
1324 /* EQ */ {.prio: 0, .flags: 0}, /* Shouldn't happen. */
1325 /* NOT */ {.prio: 16, NO_L_OPERAND},
1326 /* GREATER */ {.prio: 12, LEFT_ASSOC | CHECK_PROMOTION},
1327 /* LESS */ {.prio: 12, LEFT_ASSOC | CHECK_PROMOTION},
1328 /* PLUS */ {.prio: 14, LEFT_ASSOC | CHECK_PROMOTION},
1329 /* MINUS */ {.prio: 14, LEFT_ASSOC | CHECK_PROMOTION},
1330 /* MULT */ {.prio: 15, LEFT_ASSOC | CHECK_PROMOTION},
1331 /* DIV */ {.prio: 15, LEFT_ASSOC | CHECK_PROMOTION},
1332 /* MOD */ {.prio: 15, LEFT_ASSOC | CHECK_PROMOTION},
1333 /* AND */ {.prio: 9, LEFT_ASSOC | CHECK_PROMOTION},
1334 /* OR */ {.prio: 7, LEFT_ASSOC | CHECK_PROMOTION},
1335 /* XOR */ {.prio: 8, LEFT_ASSOC | CHECK_PROMOTION},
1336 /* RSHIFT */ {.prio: 13, LEFT_ASSOC},
1337 /* LSHIFT */ {.prio: 13, LEFT_ASSOC},
1338
1339 /* COMPL */ {.prio: 16, NO_L_OPERAND},
1340 /* AND_AND */ {.prio: 6, LEFT_ASSOC},
1341 /* OR_OR */ {.prio: 5, LEFT_ASSOC},
1342 /* Note that QUERY, COLON, and COMMA must have the same precedence.
1343 However, there are some special cases for these in reduce(). */
1344 /* QUERY */ {.prio: 4, .flags: 0},
1345 /* COLON */ {.prio: 4, LEFT_ASSOC | CHECK_PROMOTION},
1346 /* COMMA */ {.prio: 4, LEFT_ASSOC},
1347 /* OPEN_PAREN */ {.prio: 1, NO_L_OPERAND},
1348 /* CLOSE_PAREN */ {.prio: 0, .flags: 0},
1349 /* EOF */ {.prio: 0, .flags: 0},
1350 /* EQ_EQ */ {.prio: 11, LEFT_ASSOC},
1351 /* NOT_EQ */ {.prio: 11, LEFT_ASSOC},
1352 /* GREATER_EQ */ {.prio: 12, LEFT_ASSOC | CHECK_PROMOTION},
1353 /* LESS_EQ */ {.prio: 12, LEFT_ASSOC | CHECK_PROMOTION},
1354 /* UPLUS */ {.prio: 16, NO_L_OPERAND},
1355 /* UMINUS */ {.prio: 16, NO_L_OPERAND}
1356};
1357
1358/* Parse and evaluate a C expression, reading from PFILE.
1359 Returns the truth value of the expression.
1360
1361 The implementation is an operator precedence parser, i.e. a
1362 bottom-up parser, using a stack for not-yet-reduced tokens.
1363
1364 The stack base is op_stack, and the current stack pointer is 'top'.
1365 There is a stack element for each operator (only), and the most
1366 recently pushed operator is 'top->op'. An operand (value) is
1367 stored in the 'value' field of the stack element of the operator
1368 that precedes it. */
1369bool
1370_cpp_parse_expr (cpp_reader *pfile, bool is_if)
1371{
1372 struct op *top = pfile->op_stack;
1373 unsigned int lex_count;
1374 bool saw_leading_not, want_value = true;
1375 location_t virtual_location = 0;
1376
1377 pfile->state.skip_eval = 0;
1378
1379 /* Set up detection of #if ! defined(). */
1380 pfile->mi_ind_cmacro = 0;
1381 saw_leading_not = false;
1382 lex_count = 0;
1383
1384 /* Lowest priority operator prevents further reductions. */
1385 top->op = CPP_EOF;
1386
1387 for (;;)
1388 {
1389 struct op op;
1390
1391 lex_count++;
1392 op.token = cpp_get_token_with_location (pfile, &virtual_location);
1393 op.op = op.token->type;
1394 op.loc = virtual_location;
1395
1396 switch (op.op)
1397 {
1398 /* These tokens convert into values. */
1399 case CPP_NUMBER:
1400 case CPP_CHAR:
1401 case CPP_WCHAR:
1402 case CPP_CHAR16:
1403 case CPP_CHAR32:
1404 case CPP_UTF8CHAR:
1405 case CPP_NAME:
1406 case CPP_HASH:
1407 if (!want_value)
1408 SYNTAX_ERROR2_AT (op.loc,
1409 "missing binary operator before token \"%s\"",
1410 cpp_token_as_text (pfile, op.token));
1411 want_value = false;
1412 top->value = eval_token (pfile, token: op.token, virtual_location: op.loc);
1413 continue;
1414
1415 case CPP_NOT:
1416 saw_leading_not = lex_count == 1;
1417 break;
1418 case CPP_PLUS:
1419 if (want_value)
1420 op.op = CPP_UPLUS;
1421 break;
1422 case CPP_MINUS:
1423 if (want_value)
1424 op.op = CPP_UMINUS;
1425 break;
1426
1427 case CPP_PADDING:
1428 lex_count--;
1429 continue;
1430
1431 default:
1432 if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
1433 SYNTAX_ERROR2_AT (op.loc,
1434 "token \"%s\" is not valid in preprocessor expressions",
1435 cpp_token_as_text (pfile, op.token));
1436 break;
1437 }
1438
1439 /* Check we have a value or operator as appropriate. */
1440 if (optab[op.op].flags & NO_L_OPERAND)
1441 {
1442 if (!want_value)
1443 SYNTAX_ERROR2_AT (op.loc,
1444 "missing binary operator before token \"%s\"",
1445 cpp_token_as_text (pfile, op.token));
1446 }
1447 else if (want_value)
1448 {
1449 /* We want a number (or expression) and haven't got one.
1450 Try to emit a specific diagnostic. */
1451 if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
1452 SYNTAX_ERROR_AT (op.loc,
1453 "missing expression between '(' and ')'");
1454
1455 if (op.op == CPP_EOF && top->op == CPP_EOF)
1456 SYNTAX_ERROR2_AT (op.loc,
1457 "%s with no expression", is_if ? "#if" : "#elif");
1458
1459 if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
1460 SYNTAX_ERROR2_AT (op.loc,
1461 "operator '%s' has no right operand",
1462 cpp_token_as_text (pfile, top->token));
1463 else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
1464 /* Complain about missing paren during reduction. */;
1465 else
1466 SYNTAX_ERROR2_AT (op.loc,
1467 "operator '%s' has no left operand",
1468 cpp_token_as_text (pfile, op.token));
1469 }
1470
1471 top = reduce (pfile, top, op.op);
1472 if (!top)
1473 goto syntax_error;
1474
1475 if (op.op == CPP_EOF)
1476 break;
1477
1478 switch (op.op)
1479 {
1480 case CPP_CLOSE_PAREN:
1481 continue;
1482 case CPP_OR_OR:
1483 if (!num_zerop (top->value))
1484 pfile->state.skip_eval++;
1485 break;
1486 case CPP_AND_AND:
1487 case CPP_QUERY:
1488 if (num_zerop (top->value))
1489 pfile->state.skip_eval++;
1490 break;
1491 case CPP_COLON:
1492 if (top->op != CPP_QUERY)
1493 SYNTAX_ERROR_AT (op.loc,
1494 " ':' without preceding '?'");
1495 if (!num_zerop (top[-1].value)) /* Was '?' condition true? */
1496 pfile->state.skip_eval++;
1497 else
1498 pfile->state.skip_eval--;
1499 default:
1500 break;
1501 }
1502
1503 want_value = true;
1504
1505 /* Check for and handle stack overflow. */
1506 if (++top == pfile->op_limit)
1507 top = _cpp_expand_op_stack (pfile);
1508
1509 top->op = op.op;
1510 top->token = op.token;
1511 top->loc = op.loc;
1512 }
1513
1514 /* The controlling macro expression is only valid if we called lex 3
1515 times: <!> <defined expression> and <EOF>. push_conditional ()
1516 checks that we are at top-of-file. */
1517 if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
1518 pfile->mi_ind_cmacro = 0;
1519
1520 if (top != pfile->op_stack)
1521 {
1522 cpp_error_with_line (pfile, CPP_DL_ICE, top->loc, 0,
1523 msgid: "unbalanced stack in %s",
1524 is_if ? "#if" : "#elif");
1525 syntax_error:
1526 return false; /* Return false on syntax error. */
1527 }
1528
1529 return !num_zerop (top->value);
1530}
1531
1532/* Reduce the operator / value stack if possible, in preparation for
1533 pushing operator OP. Returns NULL on error, otherwise the top of
1534 the stack. */
1535static struct op *
1536reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
1537{
1538 unsigned int prio;
1539
1540 if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
1541 {
1542 bad_op:
1543 cpp_error (pfile, CPP_DL_ICE, msgid: "impossible operator '%u'", top->op);
1544 return 0;
1545 }
1546
1547 if (op == CPP_OPEN_PAREN)
1548 return top;
1549
1550 /* Decrement the priority of left-associative operators to force a
1551 reduction with operators of otherwise equal priority. */
1552 prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
1553 while (prio < optab[top->op].prio)
1554 {
1555 if (CPP_OPTION (pfile, warn_num_sign_change)
1556 && optab[top->op].flags & CHECK_PROMOTION)
1557 check_promotion (pfile, top);
1558
1559 switch (top->op)
1560 {
1561 case CPP_UPLUS:
1562 case CPP_UMINUS:
1563 case CPP_NOT:
1564 case CPP_COMPL:
1565 top[-1].value = num_unary_op (pfile, top->value, top->op);
1566 top[-1].loc = top->loc;
1567 break;
1568
1569 case CPP_PLUS:
1570 case CPP_MINUS:
1571 case CPP_RSHIFT:
1572 case CPP_LSHIFT:
1573 case CPP_COMMA:
1574 top[-1].value = num_binary_op (pfile, top[-1].value,
1575 top->value, top->op);
1576 top[-1].loc = top->loc;
1577 break;
1578
1579 case CPP_GREATER:
1580 case CPP_LESS:
1581 case CPP_GREATER_EQ:
1582 case CPP_LESS_EQ:
1583 top[-1].value
1584 = num_inequality_op (pfile, top[-1].value, top->value, top->op);
1585 top[-1].loc = top->loc;
1586 break;
1587
1588 case CPP_EQ_EQ:
1589 case CPP_NOT_EQ:
1590 top[-1].value
1591 = num_equality_op (pfile, top[-1].value, top->value, top->op);
1592 top[-1].loc = top->loc;
1593 break;
1594
1595 case CPP_AND:
1596 case CPP_OR:
1597 case CPP_XOR:
1598 top[-1].value
1599 = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
1600 top[-1].loc = top->loc;
1601 break;
1602
1603 case CPP_MULT:
1604 top[-1].value = num_mul (pfile, top[-1].value, top->value);
1605 top[-1].loc = top->loc;
1606 break;
1607
1608 case CPP_DIV:
1609 case CPP_MOD:
1610 top[-1].value = num_div_op (pfile, top[-1].value,
1611 top->value, top->op, top->loc);
1612 top[-1].loc = top->loc;
1613 break;
1614
1615 case CPP_OR_OR:
1616 top--;
1617 if (!num_zerop (top->value))
1618 pfile->state.skip_eval--;
1619 top->value.low = (!num_zerop (top->value)
1620 || !num_zerop (top[1].value));
1621 top->value.high = 0;
1622 top->value.unsignedp = false;
1623 top->value.overflow = false;
1624 top->loc = top[1].loc;
1625 continue;
1626
1627 case CPP_AND_AND:
1628 top--;
1629 if (num_zerop (top->value))
1630 pfile->state.skip_eval--;
1631 top->value.low = (!num_zerop (top->value)
1632 && !num_zerop (top[1].value));
1633 top->value.high = 0;
1634 top->value.unsignedp = false;
1635 top->value.overflow = false;
1636 top->loc = top[1].loc;
1637 continue;
1638
1639 case CPP_OPEN_PAREN:
1640 if (op != CPP_CLOSE_PAREN)
1641 {
1642 cpp_error_with_line (pfile, CPP_DL_ERROR,
1643 top->token->src_loc,
1644 0, msgid: "missing ')' in expression");
1645 return 0;
1646 }
1647 top--;
1648 top->value = top[1].value;
1649 top->loc = top[1].loc;
1650 return top;
1651
1652 case CPP_COLON:
1653 top -= 2;
1654 if (!num_zerop (top->value))
1655 {
1656 pfile->state.skip_eval--;
1657 top->value = top[1].value;
1658 top->loc = top[1].loc;
1659 }
1660 else
1661 {
1662 top->value = top[2].value;
1663 top->loc = top[2].loc;
1664 }
1665 top->value.unsignedp = (top[1].value.unsignedp
1666 || top[2].value.unsignedp);
1667 continue;
1668
1669 case CPP_QUERY:
1670 /* COMMA and COLON should not reduce a QUERY operator. */
1671 if (op == CPP_COMMA || op == CPP_COLON)
1672 return top;
1673 cpp_error (pfile, CPP_DL_ERROR, msgid: "'?' without following ':'");
1674 return 0;
1675
1676 default:
1677 goto bad_op;
1678 }
1679
1680 top--;
1681 if (top->value.overflow && !pfile->state.skip_eval)
1682 cpp_error (pfile, CPP_DL_PEDWARN,
1683 msgid: "integer overflow in preprocessor expression");
1684 }
1685
1686 if (op == CPP_CLOSE_PAREN)
1687 {
1688 cpp_error (pfile, CPP_DL_ERROR, msgid: "missing '(' in expression");
1689 return 0;
1690 }
1691
1692 return top;
1693}
1694
1695/* Returns the position of the old top of stack after expansion. */
1696struct op *
1697_cpp_expand_op_stack (cpp_reader *pfile)
1698{
1699 size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
1700 size_t new_size = old_size * 2 + 20;
1701
1702 pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
1703 pfile->op_limit = pfile->op_stack + new_size;
1704
1705 return pfile->op_stack + old_size;
1706}
1707
1708/* Emits a warning if the effective sign of either operand of OP
1709 changes because of integer promotions. */
1710static void
1711check_promotion (cpp_reader *pfile, const struct op *op)
1712{
1713 if (op->value.unsignedp == op[-1].value.unsignedp)
1714 return;
1715
1716 if (op->value.unsignedp)
1717 {
1718 if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1719 cpp_error_with_line (pfile, CPP_DL_WARNING, op[-1].loc, 0,
1720 msgid: "the left operand of \"%s\" changes sign when promoted",
1721 cpp_token_as_text (pfile, op->token));
1722 }
1723 else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1724 cpp_error_with_line (pfile, CPP_DL_WARNING, op->loc, 0,
1725 msgid: "the right operand of \"%s\" changes sign when promoted",
1726 cpp_token_as_text (pfile, op->token));
1727}
1728
1729/* Clears the unused high order bits of the number pointed to by PNUM. */
1730static cpp_num
1731num_trim (cpp_num num, size_t precision)
1732{
1733 if (precision > PART_PRECISION)
1734 {
1735 precision -= PART_PRECISION;
1736 if (precision < PART_PRECISION)
1737 num.high &= ((cpp_num_part) 1 << precision) - 1;
1738 }
1739 else
1740 {
1741 if (precision < PART_PRECISION)
1742 num.low &= ((cpp_num_part) 1 << precision) - 1;
1743 num.high = 0;
1744 }
1745
1746 return num;
1747}
1748
1749/* True iff A (presumed signed) >= 0. */
1750static bool
1751num_positive (cpp_num num, size_t precision)
1752{
1753 if (precision > PART_PRECISION)
1754 {
1755 precision -= PART_PRECISION;
1756 return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1757 }
1758
1759 return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1760}
1761
1762/* Sign extend a number, with PRECISION significant bits and all
1763 others assumed clear, to fill out a cpp_num structure. */
1764cpp_num
1765cpp_num_sign_extend (cpp_num num, size_t precision)
1766{
1767 if (!num.unsignedp)
1768 {
1769 if (precision > PART_PRECISION)
1770 {
1771 precision -= PART_PRECISION;
1772 if (precision < PART_PRECISION
1773 && (num.high & (cpp_num_part) 1 << (precision - 1)))
1774 num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1775 }
1776 else if (num.low & (cpp_num_part) 1 << (precision - 1))
1777 {
1778 if (precision < PART_PRECISION)
1779 num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1780 num.high = ~(cpp_num_part) 0;
1781 }
1782 }
1783
1784 return num;
1785}
1786
1787/* Returns the negative of NUM. */
1788static cpp_num
1789num_negate (cpp_num num, size_t precision)
1790{
1791 cpp_num copy;
1792
1793 copy = num;
1794 num.high = ~num.high;
1795 num.low = ~num.low;
1796 if (++num.low == 0)
1797 num.high++;
1798 num = num_trim (num, precision);
1799 num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1800
1801 return num;
1802}
1803
1804/* Returns true if A >= B. */
1805static bool
1806num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1807{
1808 bool unsignedp;
1809
1810 unsignedp = pa.unsignedp || pb.unsignedp;
1811
1812 if (!unsignedp)
1813 {
1814 /* Both numbers have signed type. If they are of different
1815 sign, the answer is the sign of A. */
1816 unsignedp = num_positive (num: pa, precision);
1817
1818 if (unsignedp != num_positive (num: pb, precision))
1819 return unsignedp;
1820
1821 /* Otherwise we can do an unsigned comparison. */
1822 }
1823
1824 return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1825}
1826
1827/* Returns LHS OP RHS, where OP is a bit-wise operation. */
1828static cpp_num
1829num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1830 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1831{
1832 lhs.overflow = false;
1833 lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1834
1835 /* As excess precision is zeroed, there is no need to num_trim () as
1836 these operations cannot introduce a set bit there. */
1837 if (op == CPP_AND)
1838 {
1839 lhs.low &= rhs.low;
1840 lhs.high &= rhs.high;
1841 }
1842 else if (op == CPP_OR)
1843 {
1844 lhs.low |= rhs.low;
1845 lhs.high |= rhs.high;
1846 }
1847 else
1848 {
1849 lhs.low ^= rhs.low;
1850 lhs.high ^= rhs.high;
1851 }
1852
1853 return lhs;
1854}
1855
1856/* Returns LHS OP RHS, where OP is an inequality. */
1857static cpp_num
1858num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1859 enum cpp_ttype op)
1860{
1861 bool gte = num_greater_eq (pa: lhs, pb: rhs, CPP_OPTION (pfile, precision));
1862
1863 if (op == CPP_GREATER_EQ)
1864 lhs.low = gte;
1865 else if (op == CPP_LESS)
1866 lhs.low = !gte;
1867 else if (op == CPP_GREATER)
1868 lhs.low = gte && !num_eq (lhs, rhs);
1869 else /* CPP_LESS_EQ. */
1870 lhs.low = !gte || num_eq (lhs, rhs);
1871
1872 lhs.high = 0;
1873 lhs.overflow = false;
1874 lhs.unsignedp = false;
1875 return lhs;
1876}
1877
1878/* Returns LHS OP RHS, where OP is == or !=. */
1879static cpp_num
1880num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1881 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1882{
1883 /* Work around a 3.0.4 bug; see PR 6950. */
1884 bool eq = num_eq (lhs, rhs);
1885 if (op == CPP_NOT_EQ)
1886 eq = !eq;
1887 lhs.low = eq;
1888 lhs.high = 0;
1889 lhs.overflow = false;
1890 lhs.unsignedp = false;
1891 return lhs;
1892}
1893
1894/* Shift NUM, of width PRECISION, right by N bits. */
1895static cpp_num
1896num_rshift (cpp_num num, size_t precision, size_t n)
1897{
1898 cpp_num_part sign_mask;
1899 bool x = num_positive (num, precision);
1900
1901 if (num.unsignedp || x)
1902 sign_mask = 0;
1903 else
1904 sign_mask = ~(cpp_num_part) 0;
1905
1906 if (n >= precision)
1907 num.high = num.low = sign_mask;
1908 else
1909 {
1910 /* Sign-extend. */
1911 if (precision < PART_PRECISION)
1912 num.high = sign_mask, num.low |= sign_mask << precision;
1913 else if (precision < 2 * PART_PRECISION)
1914 num.high |= sign_mask << (precision - PART_PRECISION);
1915
1916 if (n >= PART_PRECISION)
1917 {
1918 n -= PART_PRECISION;
1919 num.low = num.high;
1920 num.high = sign_mask;
1921 }
1922
1923 if (n)
1924 {
1925 num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1926 num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1927 }
1928 }
1929
1930 num = num_trim (num, precision);
1931 num.overflow = false;
1932 return num;
1933}
1934
1935/* Shift NUM, of width PRECISION, left by N bits. */
1936static cpp_num
1937num_lshift (cpp_num num, size_t precision, size_t n)
1938{
1939 if (n >= precision)
1940 {
1941 num.overflow = !num.unsignedp && !num_zerop (num);
1942 num.high = num.low = 0;
1943 }
1944 else
1945 {
1946 cpp_num orig, maybe_orig;
1947 size_t m = n;
1948
1949 orig = num;
1950 if (m >= PART_PRECISION)
1951 {
1952 m -= PART_PRECISION;
1953 num.high = num.low;
1954 num.low = 0;
1955 }
1956 if (m)
1957 {
1958 num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1959 num.low <<= m;
1960 }
1961 num = num_trim (num, precision);
1962
1963 if (num.unsignedp)
1964 num.overflow = false;
1965 else
1966 {
1967 maybe_orig = num_rshift (num, precision, n);
1968 num.overflow = !num_eq (orig, maybe_orig);
1969 }
1970 }
1971
1972 return num;
1973}
1974
1975/* The four unary operators: +, -, ! and ~. */
1976static cpp_num
1977num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1978{
1979 switch (op)
1980 {
1981 case CPP_UPLUS:
1982 if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1983 cpp_warning (pfile, CPP_W_TRADITIONAL,
1984 msgid: "traditional C rejects the unary plus operator");
1985 num.overflow = false;
1986 break;
1987
1988 case CPP_UMINUS:
1989 num = num_negate (num, CPP_OPTION (pfile, precision));
1990 break;
1991
1992 case CPP_COMPL:
1993 num.high = ~num.high;
1994 num.low = ~num.low;
1995 num = num_trim (num, CPP_OPTION (pfile, precision));
1996 num.overflow = false;
1997 break;
1998
1999 default: /* case CPP_NOT: */
2000 num.low = num_zerop (num);
2001 num.high = 0;
2002 num.overflow = false;
2003 num.unsignedp = false;
2004 break;
2005 }
2006
2007 return num;
2008}
2009
2010/* The various binary operators. */
2011static cpp_num
2012num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
2013{
2014 cpp_num result;
2015 size_t precision = CPP_OPTION (pfile, precision);
2016 size_t n;
2017
2018 switch (op)
2019 {
2020 /* Shifts. */
2021 case CPP_LSHIFT:
2022 case CPP_RSHIFT:
2023 if (!rhs.unsignedp && !num_positive (num: rhs, precision))
2024 {
2025 /* A negative shift is a positive shift the other way. */
2026 if (op == CPP_LSHIFT)
2027 op = CPP_RSHIFT;
2028 else
2029 op = CPP_LSHIFT;
2030 rhs = num_negate (num: rhs, precision);
2031 }
2032 if (rhs.high)
2033 n = ~0; /* Maximal. */
2034 else
2035 n = rhs.low;
2036 if (op == CPP_LSHIFT)
2037 lhs = num_lshift (num: lhs, precision, n);
2038 else
2039 lhs = num_rshift (num: lhs, precision, n);
2040 break;
2041
2042 /* Arithmetic. */
2043 case CPP_MINUS:
2044 result.low = lhs.low - rhs.low;
2045 result.high = lhs.high - rhs.high;
2046 if (result.low > lhs.low)
2047 result.high--;
2048 result.unsignedp = lhs.unsignedp || rhs.unsignedp;
2049 result.overflow = false;
2050
2051 result = num_trim (num: result, precision);
2052 if (!result.unsignedp)
2053 {
2054 bool lhsp = num_positive (num: lhs, precision);
2055 result.overflow = (lhsp != num_positive (num: rhs, precision)
2056 && lhsp != num_positive (num: result, precision));
2057 }
2058 return result;
2059
2060 case CPP_PLUS:
2061 result.low = lhs.low + rhs.low;
2062 result.high = lhs.high + rhs.high;
2063 if (result.low < lhs.low)
2064 result.high++;
2065 result.unsignedp = lhs.unsignedp || rhs.unsignedp;
2066 result.overflow = false;
2067
2068 result = num_trim (num: result, precision);
2069 if (!result.unsignedp)
2070 {
2071 bool lhsp = num_positive (num: lhs, precision);
2072 result.overflow = (lhsp == num_positive (num: rhs, precision)
2073 && lhsp != num_positive (num: result, precision));
2074 }
2075 return result;
2076
2077 /* Comma. */
2078 default: /* case CPP_COMMA: */
2079 if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
2080 || !pfile->state.skip_eval))
2081 cpp_pedwarning (pfile, CPP_W_PEDANTIC,
2082 msgid: "comma operator in operand of #if");
2083 lhs = rhs;
2084 break;
2085 }
2086
2087 return lhs;
2088}
2089
2090/* Multiplies two unsigned cpp_num_parts to give a cpp_num. This
2091 cannot overflow. */
2092static cpp_num
2093num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
2094{
2095 cpp_num result;
2096 cpp_num_part middle[2], temp;
2097
2098 result.low = LOW_PART (lhs) * LOW_PART (rhs);
2099 result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
2100
2101 middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
2102 middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
2103
2104 temp = result.low;
2105 result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
2106 if (result.low < temp)
2107 result.high++;
2108
2109 temp = result.low;
2110 result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
2111 if (result.low < temp)
2112 result.high++;
2113
2114 result.high += HIGH_PART (middle[0]);
2115 result.high += HIGH_PART (middle[1]);
2116 result.unsignedp = true;
2117 result.overflow = false;
2118
2119 return result;
2120}
2121
2122/* Multiply two preprocessing numbers. */
2123static cpp_num
2124num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
2125{
2126 cpp_num result, temp;
2127 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
2128 bool overflow, negate = false;
2129 size_t precision = CPP_OPTION (pfile, precision);
2130
2131 /* Prepare for unsigned multiplication. */
2132 if (!unsignedp)
2133 {
2134 if (!num_positive (num: lhs, precision))
2135 negate = !negate, lhs = num_negate (num: lhs, precision);
2136 if (!num_positive (num: rhs, precision))
2137 negate = !negate, rhs = num_negate (num: rhs, precision);
2138 }
2139
2140 overflow = lhs.high && rhs.high;
2141 result = num_part_mul (lhs: lhs.low, rhs: rhs.low);
2142
2143 temp = num_part_mul (lhs: lhs.high, rhs: rhs.low);
2144 result.high += temp.low;
2145 if (temp.high)
2146 overflow = true;
2147
2148 temp = num_part_mul (lhs: lhs.low, rhs: rhs.high);
2149 result.high += temp.low;
2150 if (temp.high)
2151 overflow = true;
2152
2153 temp.low = result.low, temp.high = result.high;
2154 result = num_trim (num: result, precision);
2155 if (!num_eq (result, temp))
2156 overflow = true;
2157
2158 if (negate)
2159 result = num_negate (num: result, precision);
2160
2161 if (unsignedp)
2162 result.overflow = false;
2163 else
2164 result.overflow = overflow || (num_positive (num: result, precision) ^ !negate
2165 && !num_zerop (result));
2166 result.unsignedp = unsignedp;
2167
2168 return result;
2169}
2170
2171/* Divide two preprocessing numbers, LHS and RHS, returning the answer
2172 or the remainder depending upon OP. LOCATION is the source location
2173 of this operator (for diagnostics). */
2174
2175static cpp_num
2176num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op,
2177 location_t location)
2178{
2179 cpp_num result, sub;
2180 cpp_num_part mask;
2181 bool unsignedp = lhs.unsignedp || rhs.unsignedp;
2182 bool negate = false, lhs_neg = false;
2183 size_t i, precision = CPP_OPTION (pfile, precision);
2184
2185 /* Prepare for unsigned division. */
2186 if (!unsignedp)
2187 {
2188 if (!num_positive (num: lhs, precision))
2189 negate = !negate, lhs_neg = true, lhs = num_negate (num: lhs, precision);
2190 if (!num_positive (num: rhs, precision))
2191 negate = !negate, rhs = num_negate (num: rhs, precision);
2192 }
2193
2194 /* Find the high bit. */
2195 if (rhs.high)
2196 {
2197 i = precision - 1;
2198 mask = (cpp_num_part) 1 << (i - PART_PRECISION);
2199 for (; ; i--, mask >>= 1)
2200 if (rhs.high & mask)
2201 break;
2202 }
2203 else if (rhs.low)
2204 {
2205 if (precision > PART_PRECISION)
2206 i = precision - PART_PRECISION - 1;
2207 else
2208 i = precision - 1;
2209 mask = (cpp_num_part) 1 << i;
2210 for (; ; i--, mask >>= 1)
2211 if (rhs.low & mask)
2212 break;
2213 }
2214 else
2215 {
2216 if (!pfile->state.skip_eval)
2217 cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
2218 msgid: "division by zero in #if");
2219 return lhs;
2220 }
2221
2222 /* First nonzero bit of RHS is bit I. Do naive division by
2223 shifting the RHS fully left, and subtracting from LHS if LHS is
2224 at least as big, and then repeating but with one less shift.
2225 This is not very efficient, but is easy to understand. */
2226
2227 rhs.unsignedp = true;
2228 lhs.unsignedp = true;
2229 i = precision - i - 1;
2230 sub = num_lshift (num: rhs, precision, n: i);
2231
2232 result.high = result.low = 0;
2233 for (;;)
2234 {
2235 if (num_greater_eq (pa: lhs, pb: sub, precision))
2236 {
2237 lhs = num_binary_op (pfile, lhs, rhs: sub, op: CPP_MINUS);
2238 if (i >= PART_PRECISION)
2239 result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
2240 else
2241 result.low |= (cpp_num_part) 1 << i;
2242 }
2243 if (i-- == 0)
2244 break;
2245 sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
2246 sub.high >>= 1;
2247 }
2248
2249 /* We divide so that the remainder has the sign of the LHS. */
2250 if (op == CPP_DIV)
2251 {
2252 result.unsignedp = unsignedp;
2253 result.overflow = false;
2254 if (!unsignedp)
2255 {
2256 if (negate)
2257 result = num_negate (num: result, precision);
2258 result.overflow = (num_positive (num: result, precision) ^ !negate
2259 && !num_zerop (result));
2260 }
2261
2262 return result;
2263 }
2264
2265 /* CPP_MOD. */
2266 lhs.unsignedp = unsignedp;
2267 lhs.overflow = false;
2268 if (lhs_neg)
2269 lhs = num_negate (num: lhs, precision);
2270
2271 return lhs;
2272}
2273
2274

source code of libcpp/expr.cc