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