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