1 //===--- PPExpressions.cpp - Preprocessor Expression Evaluation -----------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the Preprocessor::EvaluateDirectiveExpression method, 10 // which parses and evaluates integer constant expressions for #if directives. 11 // 12 //===----------------------------------------------------------------------===// 13 // 14 // FIXME: implement testing for #assert's. 15 // 16 //===----------------------------------------------------------------------===// 17 18 #include "clang/Basic/IdentifierTable.h" 19 #include "clang/Basic/SourceLocation.h" 20 #include "clang/Basic/SourceManager.h" 21 #include "clang/Basic/TargetInfo.h" 22 #include "clang/Basic/TokenKinds.h" 23 #include "clang/Lex/CodeCompletionHandler.h" 24 #include "clang/Lex/LexDiagnostic.h" 25 #include "clang/Lex/LiteralSupport.h" 26 #include "clang/Lex/MacroInfo.h" 27 #include "clang/Lex/PPCallbacks.h" 28 #include "clang/Lex/Preprocessor.h" 29 #include "clang/Lex/Token.h" 30 #include "llvm/ADT/APSInt.h" 31 #include "llvm/ADT/STLExtras.h" 32 #include "llvm/ADT/SmallString.h" 33 #include "llvm/ADT/StringExtras.h" 34 #include "llvm/ADT/StringRef.h" 35 #include "llvm/Support/ErrorHandling.h" 36 #include "llvm/Support/SaveAndRestore.h" 37 #include <cassert> 38 39 using namespace clang; 40 41 namespace { 42 43 /// PPValue - Represents the value of a subexpression of a preprocessor 44 /// conditional and the source range covered by it. 45 class PPValue { 46 SourceRange Range; 47 IdentifierInfo *II = nullptr; 48 49 public: 50 llvm::APSInt Val; 51 52 // Default ctor - Construct an 'invalid' PPValue. 53 PPValue(unsigned BitWidth) : Val(BitWidth) {} 54 55 // If this value was produced by directly evaluating an identifier, produce 56 // that identifier. 57 IdentifierInfo *getIdentifier() const { return II; } 58 void setIdentifier(IdentifierInfo *II) { this->II = II; } 59 60 unsigned getBitWidth() const { return Val.getBitWidth(); } 61 bool isUnsigned() const { return Val.isUnsigned(); } 62 63 SourceRange getRange() const { return Range; } 64 65 void setRange(SourceLocation L) { Range.setBegin(L); Range.setEnd(L); } 66 void setRange(SourceLocation B, SourceLocation E) { 67 Range.setBegin(B); Range.setEnd(E); 68 } 69 void setBegin(SourceLocation L) { Range.setBegin(L); } 70 void setEnd(SourceLocation L) { Range.setEnd(L); } 71 }; 72 73 } // end anonymous namespace 74 75 static bool EvaluateDirectiveSubExpr(PPValue &LHS, unsigned MinPrec, 76 Token &PeekTok, bool ValueLive, 77 bool &IncludedUndefinedIds, 78 Preprocessor &PP); 79 80 /// DefinedTracker - This struct is used while parsing expressions to keep track 81 /// of whether !defined(X) has been seen. 82 /// 83 /// With this simple scheme, we handle the basic forms: 84 /// !defined(X) and !defined X 85 /// but we also trivially handle (silly) stuff like: 86 /// !!!defined(X) and +!defined(X) and !+!+!defined(X) and !(defined(X)). 87 struct DefinedTracker { 88 /// Each time a Value is evaluated, it returns information about whether the 89 /// parsed value is of the form defined(X), !defined(X) or is something else. 90 enum TrackerState { 91 DefinedMacro, // defined(X) 92 NotDefinedMacro, // !defined(X) 93 Unknown // Something else. 94 } State; 95 /// TheMacro - When the state is DefinedMacro or NotDefinedMacro, this 96 /// indicates the macro that was checked. 97 IdentifierInfo *TheMacro; 98 bool IncludedUndefinedIds = false; 99 }; 100 101 /// EvaluateDefined - Process a 'defined(sym)' expression. 102 static bool EvaluateDefined(PPValue &Result, Token &PeekTok, DefinedTracker &DT, 103 bool ValueLive, Preprocessor &PP) { 104 SourceLocation beginLoc(PeekTok.getLocation()); 105 Result.setBegin(beginLoc); 106 107 // Get the next token, don't expand it. 108 PP.LexUnexpandedNonComment(PeekTok); 109 110 // Two options, it can either be a pp-identifier or a (. 111 SourceLocation LParenLoc; 112 if (PeekTok.is(tok::l_paren)) { 113 // Found a paren, remember we saw it and skip it. 114 LParenLoc = PeekTok.getLocation(); 115 PP.LexUnexpandedNonComment(PeekTok); 116 } 117 118 if (PeekTok.is(tok::code_completion)) { 119 if (PP.getCodeCompletionHandler()) 120 PP.getCodeCompletionHandler()->CodeCompleteMacroName(false); 121 PP.setCodeCompletionReached(); 122 PP.LexUnexpandedNonComment(PeekTok); 123 } 124 125 // If we don't have a pp-identifier now, this is an error. 126 if (PP.CheckMacroName(PeekTok, MU_Other)) 127 return true; 128 129 // Otherwise, we got an identifier, is it defined to something? 130 IdentifierInfo *II = PeekTok.getIdentifierInfo(); 131 MacroDefinition Macro = PP.getMacroDefinition(II); 132 Result.Val = !!Macro; 133 Result.Val.setIsUnsigned(false); // Result is signed intmax_t. 134 DT.IncludedUndefinedIds = !Macro; 135 136 PP.emitMacroExpansionWarnings(PeekTok); 137 138 // If there is a macro, mark it used. 139 if (Result.Val != 0 && ValueLive) 140 PP.markMacroAsUsed(Macro.getMacroInfo()); 141 142 // Save macro token for callback. 143 Token macroToken(PeekTok); 144 145 // If we are in parens, ensure we have a trailing ). 146 if (LParenLoc.isValid()) { 147 // Consume identifier. 148 Result.setEnd(PeekTok.getLocation()); 149 PP.LexUnexpandedNonComment(PeekTok); 150 151 if (PeekTok.isNot(tok::r_paren)) { 152 PP.Diag(PeekTok.getLocation(), diag::err_pp_expected_after) 153 << "'defined'" << tok::r_paren; 154 PP.Diag(LParenLoc, diag::note_matching) << tok::l_paren; 155 return true; 156 } 157 // Consume the ). 158 PP.LexNonComment(PeekTok); 159 Result.setEnd(PeekTok.getLocation()); 160 } else { 161 // Consume identifier. 162 Result.setEnd(PeekTok.getLocation()); 163 PP.LexNonComment(PeekTok); 164 } 165 166 // [cpp.cond]p4: 167 // Prior to evaluation, macro invocations in the list of preprocessing 168 // tokens that will become the controlling constant expression are replaced 169 // (except for those macro names modified by the 'defined' unary operator), 170 // just as in normal text. If the token 'defined' is generated as a result 171 // of this replacement process or use of the 'defined' unary operator does 172 // not match one of the two specified forms prior to macro replacement, the 173 // behavior is undefined. 174 // This isn't an idle threat, consider this program: 175 // #define FOO 176 // #define BAR defined(FOO) 177 // #if BAR 178 // ... 179 // #else 180 // ... 181 // #endif 182 // clang and gcc will pick the #if branch while Visual Studio will take the 183 // #else branch. Emit a warning about this undefined behavior. 184 if (beginLoc.isMacroID()) { 185 bool IsFunctionTypeMacro = 186 PP.getSourceManager() 187 .getSLocEntry(PP.getSourceManager().getFileID(beginLoc)) 188 .getExpansion() 189 .isFunctionMacroExpansion(); 190 // For object-type macros, it's easy to replace 191 // #define FOO defined(BAR) 192 // with 193 // #if defined(BAR) 194 // #define FOO 1 195 // #else 196 // #define FOO 0 197 // #endif 198 // and doing so makes sense since compilers handle this differently in 199 // practice (see example further up). But for function-type macros, 200 // there is no good way to write 201 // # define FOO(x) (defined(M_ ## x) && M_ ## x) 202 // in a different way, and compilers seem to agree on how to behave here. 203 // So warn by default on object-type macros, but only warn in -pedantic 204 // mode on function-type macros. 205 if (IsFunctionTypeMacro) 206 PP.Diag(beginLoc, diag::warn_defined_in_function_type_macro); 207 else 208 PP.Diag(beginLoc, diag::warn_defined_in_object_type_macro); 209 } 210 211 // Invoke the 'defined' callback. 212 if (PPCallbacks *Callbacks = PP.getPPCallbacks()) { 213 Callbacks->Defined(macroToken, Macro, 214 SourceRange(beginLoc, PeekTok.getLocation())); 215 } 216 217 // Success, remember that we saw defined(X). 218 DT.State = DefinedTracker::DefinedMacro; 219 DT.TheMacro = II; 220 return false; 221 } 222 223 /// EvaluateValue - Evaluate the token PeekTok (and any others needed) and 224 /// return the computed value in Result. Return true if there was an error 225 /// parsing. This function also returns information about the form of the 226 /// expression in DT. See above for information on what DT means. 227 /// 228 /// If ValueLive is false, then this value is being evaluated in a context where 229 /// the result is not used. As such, avoid diagnostics that relate to 230 /// evaluation. 231 static bool EvaluateValue(PPValue &Result, Token &PeekTok, DefinedTracker &DT, 232 bool ValueLive, Preprocessor &PP) { 233 DT.State = DefinedTracker::Unknown; 234 235 Result.setIdentifier(nullptr); 236 237 if (PeekTok.is(tok::code_completion)) { 238 if (PP.getCodeCompletionHandler()) 239 PP.getCodeCompletionHandler()->CodeCompletePreprocessorExpression(); 240 PP.setCodeCompletionReached(); 241 PP.LexNonComment(PeekTok); 242 } 243 244 switch (PeekTok.getKind()) { 245 default: 246 // If this token's spelling is a pp-identifier, check to see if it is 247 // 'defined' or if it is a macro. Note that we check here because many 248 // keywords are pp-identifiers, so we can't check the kind. 249 if (IdentifierInfo *II = PeekTok.getIdentifierInfo()) { 250 // Handle "defined X" and "defined(X)". 251 if (II->isStr("defined")) 252 return EvaluateDefined(Result, PeekTok, DT, ValueLive, PP); 253 254 if (!II->isCPlusPlusOperatorKeyword()) { 255 // If this identifier isn't 'defined' or one of the special 256 // preprocessor keywords and it wasn't macro expanded, it turns 257 // into a simple 0 258 if (ValueLive) { 259 PP.Diag(PeekTok, diag::warn_pp_undef_identifier) << II; 260 261 const DiagnosticsEngine &DiagEngine = PP.getDiagnostics(); 262 // If 'Wundef' is enabled, do not emit 'undef-prefix' diagnostics. 263 if (DiagEngine.isIgnored(diag::warn_pp_undef_identifier, 264 PeekTok.getLocation())) { 265 const std::vector<std::string> UndefPrefixes = 266 DiagEngine.getDiagnosticOptions().UndefPrefixes; 267 const StringRef IdentifierName = II->getName(); 268 if (llvm::any_of(UndefPrefixes, 269 [&IdentifierName](const std::string &Prefix) { 270 return IdentifierName.startswith(Prefix); 271 })) 272 PP.Diag(PeekTok, diag::warn_pp_undef_prefix) 273 << AddFlagValue{llvm::join(UndefPrefixes, ",")} << II; 274 } 275 } 276 Result.Val = 0; 277 Result.Val.setIsUnsigned(false); // "0" is signed intmax_t 0. 278 Result.setIdentifier(II); 279 Result.setRange(PeekTok.getLocation()); 280 DT.IncludedUndefinedIds = true; 281 PP.LexNonComment(PeekTok); 282 return false; 283 } 284 } 285 PP.Diag(PeekTok, diag::err_pp_expr_bad_token_start_expr); 286 return true; 287 case tok::eod: 288 case tok::r_paren: 289 // If there is no expression, report and exit. 290 PP.Diag(PeekTok, diag::err_pp_expected_value_in_expr); 291 return true; 292 case tok::numeric_constant: { 293 SmallString<64> IntegerBuffer; 294 bool NumberInvalid = false; 295 StringRef Spelling = PP.getSpelling(PeekTok, IntegerBuffer, 296 &NumberInvalid); 297 if (NumberInvalid) 298 return true; // a diagnostic was already reported 299 300 NumericLiteralParser Literal(Spelling, PeekTok.getLocation(), 301 PP.getSourceManager(), PP.getLangOpts(), 302 PP.getTargetInfo(), PP.getDiagnostics()); 303 if (Literal.hadError) 304 return true; // a diagnostic was already reported. 305 306 if (Literal.isFloatingLiteral() || Literal.isImaginary) { 307 PP.Diag(PeekTok, diag::err_pp_illegal_floating_literal); 308 return true; 309 } 310 assert(Literal.isIntegerLiteral() && "Unknown ppnumber"); 311 312 // Complain about, and drop, any ud-suffix. 313 if (Literal.hasUDSuffix()) 314 PP.Diag(PeekTok, diag::err_pp_invalid_udl) << /*integer*/1; 315 316 // 'long long' is a C99 or C++11 feature. 317 if (!PP.getLangOpts().C99 && Literal.isLongLong) { 318 if (PP.getLangOpts().CPlusPlus) 319 PP.Diag(PeekTok, 320 PP.getLangOpts().CPlusPlus11 ? 321 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong); 322 else 323 PP.Diag(PeekTok, diag::ext_c99_longlong); 324 } 325 326 // 'z/uz' literals are a C++23 feature. 327 if (Literal.isSizeT) 328 PP.Diag(PeekTok, PP.getLangOpts().CPlusPlus 329 ? PP.getLangOpts().CPlusPlus23 330 ? diag::warn_cxx20_compat_size_t_suffix 331 : diag::ext_cxx23_size_t_suffix 332 : diag::err_cxx23_size_t_suffix); 333 334 // 'wb/uwb' literals are a C2x feature. We explicitly do not support the 335 // suffix in C++ as an extension because a library-based UDL that resolves 336 // to a library type may be more appropriate there. 337 if (Literal.isBitInt) 338 PP.Diag(PeekTok, PP.getLangOpts().C2x 339 ? diag::warn_c2x_compat_bitint_suffix 340 : diag::ext_c2x_bitint_suffix); 341 342 // Parse the integer literal into Result. 343 if (Literal.GetIntegerValue(Result.Val)) { 344 // Overflow parsing integer literal. 345 if (ValueLive) 346 PP.Diag(PeekTok, diag::err_integer_literal_too_large) 347 << /* Unsigned */ 1; 348 Result.Val.setIsUnsigned(true); 349 } else { 350 // Set the signedness of the result to match whether there was a U suffix 351 // or not. 352 Result.Val.setIsUnsigned(Literal.isUnsigned); 353 354 // Detect overflow based on whether the value is signed. If signed 355 // and if the value is too large, emit a warning "integer constant is so 356 // large that it is unsigned" e.g. on 12345678901234567890 where intmax_t 357 // is 64-bits. 358 if (!Literal.isUnsigned && Result.Val.isNegative()) { 359 // Octal, hexadecimal, and binary literals are implicitly unsigned if 360 // the value does not fit into a signed integer type. 361 if (ValueLive && Literal.getRadix() == 10) 362 PP.Diag(PeekTok, diag::ext_integer_literal_too_large_for_signed); 363 Result.Val.setIsUnsigned(true); 364 } 365 } 366 367 // Consume the token. 368 Result.setRange(PeekTok.getLocation()); 369 PP.LexNonComment(PeekTok); 370 return false; 371 } 372 case tok::char_constant: // 'x' 373 case tok::wide_char_constant: // L'x' 374 case tok::utf8_char_constant: // u8'x' 375 case tok::utf16_char_constant: // u'x' 376 case tok::utf32_char_constant: { // U'x' 377 // Complain about, and drop, any ud-suffix. 378 if (PeekTok.hasUDSuffix()) 379 PP.Diag(PeekTok, diag::err_pp_invalid_udl) << /*character*/0; 380 381 SmallString<32> CharBuffer; 382 bool CharInvalid = false; 383 StringRef ThisTok = PP.getSpelling(PeekTok, CharBuffer, &CharInvalid); 384 if (CharInvalid) 385 return true; 386 387 CharLiteralParser Literal(ThisTok.begin(), ThisTok.end(), 388 PeekTok.getLocation(), PP, PeekTok.getKind()); 389 if (Literal.hadError()) 390 return true; // A diagnostic was already emitted. 391 392 // Character literals are always int or wchar_t, expand to intmax_t. 393 const TargetInfo &TI = PP.getTargetInfo(); 394 unsigned NumBits; 395 if (Literal.isMultiChar()) 396 NumBits = TI.getIntWidth(); 397 else if (Literal.isWide()) 398 NumBits = TI.getWCharWidth(); 399 else if (Literal.isUTF16()) 400 NumBits = TI.getChar16Width(); 401 else if (Literal.isUTF32()) 402 NumBits = TI.getChar32Width(); 403 else // char or char8_t 404 NumBits = TI.getCharWidth(); 405 406 // Set the width. 407 llvm::APSInt Val(NumBits); 408 // Set the value. 409 Val = Literal.getValue(); 410 // Set the signedness. UTF-16 and UTF-32 are always unsigned 411 // UTF-8 is unsigned if -fchar8_t is specified. 412 if (Literal.isWide()) 413 Val.setIsUnsigned(!TargetInfo::isTypeSigned(TI.getWCharType())); 414 else if (Literal.isUTF16() || Literal.isUTF32()) 415 Val.setIsUnsigned(true); 416 else if (Literal.isUTF8()) { 417 if (PP.getLangOpts().CPlusPlus) 418 Val.setIsUnsigned( 419 PP.getLangOpts().Char8 ? true : !PP.getLangOpts().CharIsSigned); 420 else 421 Val.setIsUnsigned(true); 422 } else 423 Val.setIsUnsigned(!PP.getLangOpts().CharIsSigned); 424 425 if (Result.Val.getBitWidth() > Val.getBitWidth()) { 426 Result.Val = Val.extend(Result.Val.getBitWidth()); 427 } else { 428 assert(Result.Val.getBitWidth() == Val.getBitWidth() && 429 "intmax_t smaller than char/wchar_t?"); 430 Result.Val = Val; 431 } 432 433 // Consume the token. 434 Result.setRange(PeekTok.getLocation()); 435 PP.LexNonComment(PeekTok); 436 return false; 437 } 438 case tok::l_paren: { 439 SourceLocation Start = PeekTok.getLocation(); 440 PP.LexNonComment(PeekTok); // Eat the (. 441 // Parse the value and if there are any binary operators involved, parse 442 // them. 443 if (EvaluateValue(Result, PeekTok, DT, ValueLive, PP)) return true; 444 445 // If this is a silly value like (X), which doesn't need parens, check for 446 // !(defined X). 447 if (PeekTok.is(tok::r_paren)) { 448 // Just use DT unmodified as our result. 449 } else { 450 // Otherwise, we have something like (x+y), and we consumed '(x'. 451 if (EvaluateDirectiveSubExpr(Result, 1, PeekTok, ValueLive, 452 DT.IncludedUndefinedIds, PP)) 453 return true; 454 455 if (PeekTok.isNot(tok::r_paren)) { 456 PP.Diag(PeekTok.getLocation(), diag::err_pp_expected_rparen) 457 << Result.getRange(); 458 PP.Diag(Start, diag::note_matching) << tok::l_paren; 459 return true; 460 } 461 DT.State = DefinedTracker::Unknown; 462 } 463 Result.setRange(Start, PeekTok.getLocation()); 464 Result.setIdentifier(nullptr); 465 PP.LexNonComment(PeekTok); // Eat the ). 466 return false; 467 } 468 case tok::plus: { 469 SourceLocation Start = PeekTok.getLocation(); 470 // Unary plus doesn't modify the value. 471 PP.LexNonComment(PeekTok); 472 if (EvaluateValue(Result, PeekTok, DT, ValueLive, PP)) return true; 473 Result.setBegin(Start); 474 Result.setIdentifier(nullptr); 475 return false; 476 } 477 case tok::minus: { 478 SourceLocation Loc = PeekTok.getLocation(); 479 PP.LexNonComment(PeekTok); 480 if (EvaluateValue(Result, PeekTok, DT, ValueLive, PP)) return true; 481 Result.setBegin(Loc); 482 Result.setIdentifier(nullptr); 483 484 // C99 6.5.3.3p3: The sign of the result matches the sign of the operand. 485 Result.Val = -Result.Val; 486 487 // -MININT is the only thing that overflows. Unsigned never overflows. 488 bool Overflow = !Result.isUnsigned() && Result.Val.isMinSignedValue(); 489 490 // If this operator is live and overflowed, report the issue. 491 if (Overflow && ValueLive) 492 PP.Diag(Loc, diag::warn_pp_expr_overflow) << Result.getRange(); 493 494 DT.State = DefinedTracker::Unknown; 495 return false; 496 } 497 498 case tok::tilde: { 499 SourceLocation Start = PeekTok.getLocation(); 500 PP.LexNonComment(PeekTok); 501 if (EvaluateValue(Result, PeekTok, DT, ValueLive, PP)) return true; 502 Result.setBegin(Start); 503 Result.setIdentifier(nullptr); 504 505 // C99 6.5.3.3p4: The sign of the result matches the sign of the operand. 506 Result.Val = ~Result.Val; 507 DT.State = DefinedTracker::Unknown; 508 return false; 509 } 510 511 case tok::exclaim: { 512 SourceLocation Start = PeekTok.getLocation(); 513 PP.LexNonComment(PeekTok); 514 if (EvaluateValue(Result, PeekTok, DT, ValueLive, PP)) return true; 515 Result.setBegin(Start); 516 Result.Val = !Result.Val; 517 // C99 6.5.3.3p5: The sign of the result is 'int', aka it is signed. 518 Result.Val.setIsUnsigned(false); 519 Result.setIdentifier(nullptr); 520 521 if (DT.State == DefinedTracker::DefinedMacro) 522 DT.State = DefinedTracker::NotDefinedMacro; 523 else if (DT.State == DefinedTracker::NotDefinedMacro) 524 DT.State = DefinedTracker::DefinedMacro; 525 return false; 526 } 527 case tok::kw_true: 528 case tok::kw_false: 529 Result.Val = PeekTok.getKind() == tok::kw_true; 530 Result.Val.setIsUnsigned(false); // "0" is signed intmax_t 0. 531 Result.setIdentifier(PeekTok.getIdentifierInfo()); 532 Result.setRange(PeekTok.getLocation()); 533 PP.LexNonComment(PeekTok); 534 return false; 535 536 // FIXME: Handle #assert 537 } 538 } 539 540 /// getPrecedence - Return the precedence of the specified binary operator 541 /// token. This returns: 542 /// ~0 - Invalid token. 543 /// 14 -> 3 - various operators. 544 /// 0 - 'eod' or ')' 545 static unsigned getPrecedence(tok::TokenKind Kind) { 546 switch (Kind) { 547 default: return ~0U; 548 case tok::percent: 549 case tok::slash: 550 case tok::star: return 14; 551 case tok::plus: 552 case tok::minus: return 13; 553 case tok::lessless: 554 case tok::greatergreater: return 12; 555 case tok::lessequal: 556 case tok::less: 557 case tok::greaterequal: 558 case tok::greater: return 11; 559 case tok::exclaimequal: 560 case tok::equalequal: return 10; 561 case tok::amp: return 9; 562 case tok::caret: return 8; 563 case tok::pipe: return 7; 564 case tok::ampamp: return 6; 565 case tok::pipepipe: return 5; 566 case tok::question: return 4; 567 case tok::comma: return 3; 568 case tok::colon: return 2; 569 case tok::r_paren: return 0;// Lowest priority, end of expr. 570 case tok::eod: return 0;// Lowest priority, end of directive. 571 } 572 } 573 574 static void diagnoseUnexpectedOperator(Preprocessor &PP, PPValue &LHS, 575 Token &Tok) { 576 if (Tok.is(tok::l_paren) && LHS.getIdentifier()) 577 PP.Diag(LHS.getRange().getBegin(), diag::err_pp_expr_bad_token_lparen) 578 << LHS.getIdentifier(); 579 else 580 PP.Diag(Tok.getLocation(), diag::err_pp_expr_bad_token_binop) 581 << LHS.getRange(); 582 } 583 584 /// EvaluateDirectiveSubExpr - Evaluate the subexpression whose first token is 585 /// PeekTok, and whose precedence is PeekPrec. This returns the result in LHS. 586 /// 587 /// If ValueLive is false, then this value is being evaluated in a context where 588 /// the result is not used. As such, avoid diagnostics that relate to 589 /// evaluation, such as division by zero warnings. 590 static bool EvaluateDirectiveSubExpr(PPValue &LHS, unsigned MinPrec, 591 Token &PeekTok, bool ValueLive, 592 bool &IncludedUndefinedIds, 593 Preprocessor &PP) { 594 unsigned PeekPrec = getPrecedence(PeekTok.getKind()); 595 // If this token isn't valid, report the error. 596 if (PeekPrec == ~0U) { 597 diagnoseUnexpectedOperator(PP, LHS, PeekTok); 598 return true; 599 } 600 601 while (true) { 602 // If this token has a lower precedence than we are allowed to parse, return 603 // it so that higher levels of the recursion can parse it. 604 if (PeekPrec < MinPrec) 605 return false; 606 607 tok::TokenKind Operator = PeekTok.getKind(); 608 609 // If this is a short-circuiting operator, see if the RHS of the operator is 610 // dead. Note that this cannot just clobber ValueLive. Consider 611 // "0 && 1 ? 4 : 1 / 0", which is parsed as "(0 && 1) ? 4 : (1 / 0)". In 612 // this example, the RHS of the && being dead does not make the rest of the 613 // expr dead. 614 bool RHSIsLive; 615 if (Operator == tok::ampamp && LHS.Val == 0) 616 RHSIsLive = false; // RHS of "0 && x" is dead. 617 else if (Operator == tok::pipepipe && LHS.Val != 0) 618 RHSIsLive = false; // RHS of "1 || x" is dead. 619 else if (Operator == tok::question && LHS.Val == 0) 620 RHSIsLive = false; // RHS (x) of "0 ? x : y" is dead. 621 else 622 RHSIsLive = ValueLive; 623 624 // Consume the operator, remembering the operator's location for reporting. 625 SourceLocation OpLoc = PeekTok.getLocation(); 626 PP.LexNonComment(PeekTok); 627 628 PPValue RHS(LHS.getBitWidth()); 629 // Parse the RHS of the operator. 630 DefinedTracker DT; 631 if (EvaluateValue(RHS, PeekTok, DT, RHSIsLive, PP)) return true; 632 IncludedUndefinedIds = DT.IncludedUndefinedIds; 633 634 // Remember the precedence of this operator and get the precedence of the 635 // operator immediately to the right of the RHS. 636 unsigned ThisPrec = PeekPrec; 637 PeekPrec = getPrecedence(PeekTok.getKind()); 638 639 // If this token isn't valid, report the error. 640 if (PeekPrec == ~0U) { 641 diagnoseUnexpectedOperator(PP, RHS, PeekTok); 642 return true; 643 } 644 645 // Decide whether to include the next binop in this subexpression. For 646 // example, when parsing x+y*z and looking at '*', we want to recursively 647 // handle y*z as a single subexpression. We do this because the precedence 648 // of * is higher than that of +. The only strange case we have to handle 649 // here is for the ?: operator, where the precedence is actually lower than 650 // the LHS of the '?'. The grammar rule is: 651 // 652 // conditional-expression ::= 653 // logical-OR-expression ? expression : conditional-expression 654 // where 'expression' is actually comma-expression. 655 unsigned RHSPrec; 656 if (Operator == tok::question) 657 // The RHS of "?" should be maximally consumed as an expression. 658 RHSPrec = getPrecedence(tok::comma); 659 else // All others should munch while higher precedence. 660 RHSPrec = ThisPrec+1; 661 662 if (PeekPrec >= RHSPrec) { 663 if (EvaluateDirectiveSubExpr(RHS, RHSPrec, PeekTok, RHSIsLive, 664 IncludedUndefinedIds, PP)) 665 return true; 666 PeekPrec = getPrecedence(PeekTok.getKind()); 667 } 668 assert(PeekPrec <= ThisPrec && "Recursion didn't work!"); 669 670 // Usual arithmetic conversions (C99 6.3.1.8p1): result is unsigned if 671 // either operand is unsigned. 672 llvm::APSInt Res(LHS.getBitWidth()); 673 switch (Operator) { 674 case tok::question: // No UAC for x and y in "x ? y : z". 675 case tok::lessless: // Shift amount doesn't UAC with shift value. 676 case tok::greatergreater: // Shift amount doesn't UAC with shift value. 677 case tok::comma: // Comma operands are not subject to UACs. 678 case tok::pipepipe: // Logical || does not do UACs. 679 case tok::ampamp: // Logical && does not do UACs. 680 break; // No UAC 681 default: 682 Res.setIsUnsigned(LHS.isUnsigned() || RHS.isUnsigned()); 683 // If this just promoted something from signed to unsigned, and if the 684 // value was negative, warn about it. 685 if (ValueLive && Res.isUnsigned()) { 686 if (!LHS.isUnsigned() && LHS.Val.isNegative()) 687 PP.Diag(OpLoc, diag::warn_pp_convert_to_positive) << 0 688 << toString(LHS.Val, 10, true) + " to " + 689 toString(LHS.Val, 10, false) 690 << LHS.getRange() << RHS.getRange(); 691 if (!RHS.isUnsigned() && RHS.Val.isNegative()) 692 PP.Diag(OpLoc, diag::warn_pp_convert_to_positive) << 1 693 << toString(RHS.Val, 10, true) + " to " + 694 toString(RHS.Val, 10, false) 695 << LHS.getRange() << RHS.getRange(); 696 } 697 LHS.Val.setIsUnsigned(Res.isUnsigned()); 698 RHS.Val.setIsUnsigned(Res.isUnsigned()); 699 } 700 701 bool Overflow = false; 702 switch (Operator) { 703 default: llvm_unreachable("Unknown operator token!"); 704 case tok::percent: 705 if (RHS.Val != 0) 706 Res = LHS.Val % RHS.Val; 707 else if (ValueLive) { 708 PP.Diag(OpLoc, diag::err_pp_remainder_by_zero) 709 << LHS.getRange() << RHS.getRange(); 710 return true; 711 } 712 break; 713 case tok::slash: 714 if (RHS.Val != 0) { 715 if (LHS.Val.isSigned()) 716 Res = llvm::APSInt(LHS.Val.sdiv_ov(RHS.Val, Overflow), false); 717 else 718 Res = LHS.Val / RHS.Val; 719 } else if (ValueLive) { 720 PP.Diag(OpLoc, diag::err_pp_division_by_zero) 721 << LHS.getRange() << RHS.getRange(); 722 return true; 723 } 724 break; 725 726 case tok::star: 727 if (Res.isSigned()) 728 Res = llvm::APSInt(LHS.Val.smul_ov(RHS.Val, Overflow), false); 729 else 730 Res = LHS.Val * RHS.Val; 731 break; 732 case tok::lessless: { 733 // Determine whether overflow is about to happen. 734 if (LHS.isUnsigned()) 735 Res = LHS.Val.ushl_ov(RHS.Val, Overflow); 736 else 737 Res = llvm::APSInt(LHS.Val.sshl_ov(RHS.Val, Overflow), false); 738 break; 739 } 740 case tok::greatergreater: { 741 // Determine whether overflow is about to happen. 742 unsigned ShAmt = static_cast<unsigned>(RHS.Val.getLimitedValue()); 743 if (ShAmt >= LHS.getBitWidth()) { 744 Overflow = true; 745 ShAmt = LHS.getBitWidth()-1; 746 } 747 Res = LHS.Val >> ShAmt; 748 break; 749 } 750 case tok::plus: 751 if (LHS.isUnsigned()) 752 Res = LHS.Val + RHS.Val; 753 else 754 Res = llvm::APSInt(LHS.Val.sadd_ov(RHS.Val, Overflow), false); 755 break; 756 case tok::minus: 757 if (LHS.isUnsigned()) 758 Res = LHS.Val - RHS.Val; 759 else 760 Res = llvm::APSInt(LHS.Val.ssub_ov(RHS.Val, Overflow), false); 761 break; 762 case tok::lessequal: 763 Res = LHS.Val <= RHS.Val; 764 Res.setIsUnsigned(false); // C99 6.5.8p6, result is always int (signed) 765 break; 766 case tok::less: 767 Res = LHS.Val < RHS.Val; 768 Res.setIsUnsigned(false); // C99 6.5.8p6, result is always int (signed) 769 break; 770 case tok::greaterequal: 771 Res = LHS.Val >= RHS.Val; 772 Res.setIsUnsigned(false); // C99 6.5.8p6, result is always int (signed) 773 break; 774 case tok::greater: 775 Res = LHS.Val > RHS.Val; 776 Res.setIsUnsigned(false); // C99 6.5.8p6, result is always int (signed) 777 break; 778 case tok::exclaimequal: 779 Res = LHS.Val != RHS.Val; 780 Res.setIsUnsigned(false); // C99 6.5.9p3, result is always int (signed) 781 break; 782 case tok::equalequal: 783 Res = LHS.Val == RHS.Val; 784 Res.setIsUnsigned(false); // C99 6.5.9p3, result is always int (signed) 785 break; 786 case tok::amp: 787 Res = LHS.Val & RHS.Val; 788 break; 789 case tok::caret: 790 Res = LHS.Val ^ RHS.Val; 791 break; 792 case tok::pipe: 793 Res = LHS.Val | RHS.Val; 794 break; 795 case tok::ampamp: 796 Res = (LHS.Val != 0 && RHS.Val != 0); 797 Res.setIsUnsigned(false); // C99 6.5.13p3, result is always int (signed) 798 break; 799 case tok::pipepipe: 800 Res = (LHS.Val != 0 || RHS.Val != 0); 801 Res.setIsUnsigned(false); // C99 6.5.14p3, result is always int (signed) 802 break; 803 case tok::comma: 804 // Comma is invalid in pp expressions in c89/c++ mode, but is valid in C99 805 // if not being evaluated. 806 if (!PP.getLangOpts().C99 || ValueLive) 807 PP.Diag(OpLoc, diag::ext_pp_comma_expr) 808 << LHS.getRange() << RHS.getRange(); 809 Res = RHS.Val; // LHS = LHS,RHS -> RHS. 810 break; 811 case tok::question: { 812 // Parse the : part of the expression. 813 if (PeekTok.isNot(tok::colon)) { 814 PP.Diag(PeekTok.getLocation(), diag::err_expected) 815 << tok::colon << LHS.getRange() << RHS.getRange(); 816 PP.Diag(OpLoc, diag::note_matching) << tok::question; 817 return true; 818 } 819 // Consume the :. 820 PP.LexNonComment(PeekTok); 821 822 // Evaluate the value after the :. 823 bool AfterColonLive = ValueLive && LHS.Val == 0; 824 PPValue AfterColonVal(LHS.getBitWidth()); 825 DefinedTracker DT; 826 if (EvaluateValue(AfterColonVal, PeekTok, DT, AfterColonLive, PP)) 827 return true; 828 829 // Parse anything after the : with the same precedence as ?. We allow 830 // things of equal precedence because ?: is right associative. 831 if (EvaluateDirectiveSubExpr(AfterColonVal, ThisPrec, 832 PeekTok, AfterColonLive, 833 IncludedUndefinedIds, PP)) 834 return true; 835 836 // Now that we have the condition, the LHS and the RHS of the :, evaluate. 837 Res = LHS.Val != 0 ? RHS.Val : AfterColonVal.Val; 838 RHS.setEnd(AfterColonVal.getRange().getEnd()); 839 840 // Usual arithmetic conversions (C99 6.3.1.8p1): result is unsigned if 841 // either operand is unsigned. 842 Res.setIsUnsigned(RHS.isUnsigned() || AfterColonVal.isUnsigned()); 843 844 // Figure out the precedence of the token after the : part. 845 PeekPrec = getPrecedence(PeekTok.getKind()); 846 break; 847 } 848 case tok::colon: 849 // Don't allow :'s to float around without being part of ?: exprs. 850 PP.Diag(OpLoc, diag::err_pp_colon_without_question) 851 << LHS.getRange() << RHS.getRange(); 852 return true; 853 } 854 855 // If this operator is live and overflowed, report the issue. 856 if (Overflow && ValueLive) 857 PP.Diag(OpLoc, diag::warn_pp_expr_overflow) 858 << LHS.getRange() << RHS.getRange(); 859 860 // Put the result back into 'LHS' for our next iteration. 861 LHS.Val = Res; 862 LHS.setEnd(RHS.getRange().getEnd()); 863 RHS.setIdentifier(nullptr); 864 } 865 } 866 867 /// EvaluateDirectiveExpression - Evaluate an integer constant expression that 868 /// may occur after a #if or #elif directive. If the expression is equivalent 869 /// to "!defined(X)" return X in IfNDefMacro. 870 Preprocessor::DirectiveEvalResult 871 Preprocessor::EvaluateDirectiveExpression(IdentifierInfo *&IfNDefMacro) { 872 SaveAndRestore PPDir(ParsingIfOrElifDirective, true); 873 // Save the current state of 'DisableMacroExpansion' and reset it to false. If 874 // 'DisableMacroExpansion' is true, then we must be in a macro argument list 875 // in which case a directive is undefined behavior. We want macros to be able 876 // to recursively expand in order to get more gcc-list behavior, so we force 877 // DisableMacroExpansion to false and restore it when we're done parsing the 878 // expression. 879 bool DisableMacroExpansionAtStartOfDirective = DisableMacroExpansion; 880 DisableMacroExpansion = false; 881 882 // Peek ahead one token. 883 Token Tok; 884 LexNonComment(Tok); 885 886 // C99 6.10.1p3 - All expressions are evaluated as intmax_t or uintmax_t. 887 unsigned BitWidth = getTargetInfo().getIntMaxTWidth(); 888 889 PPValue ResVal(BitWidth); 890 DefinedTracker DT; 891 SourceLocation ExprStartLoc = SourceMgr.getExpansionLoc(Tok.getLocation()); 892 if (EvaluateValue(ResVal, Tok, DT, true, *this)) { 893 // Parse error, skip the rest of the macro line. 894 SourceRange ConditionRange = ExprStartLoc; 895 if (Tok.isNot(tok::eod)) 896 ConditionRange = DiscardUntilEndOfDirective(); 897 898 // Restore 'DisableMacroExpansion'. 899 DisableMacroExpansion = DisableMacroExpansionAtStartOfDirective; 900 901 // We cannot trust the source range from the value because there was a 902 // parse error. Track the range manually -- the end of the directive is the 903 // end of the condition range. 904 return {false, 905 DT.IncludedUndefinedIds, 906 {ExprStartLoc, ConditionRange.getEnd()}}; 907 } 908 909 // If we are at the end of the expression after just parsing a value, there 910 // must be no (unparenthesized) binary operators involved, so we can exit 911 // directly. 912 if (Tok.is(tok::eod)) { 913 // If the expression we parsed was of the form !defined(macro), return the 914 // macro in IfNDefMacro. 915 if (DT.State == DefinedTracker::NotDefinedMacro) 916 IfNDefMacro = DT.TheMacro; 917 918 // Restore 'DisableMacroExpansion'. 919 DisableMacroExpansion = DisableMacroExpansionAtStartOfDirective; 920 return {ResVal.Val != 0, DT.IncludedUndefinedIds, ResVal.getRange()}; 921 } 922 923 // Otherwise, we must have a binary operator (e.g. "#if 1 < 2"), so parse the 924 // operator and the stuff after it. 925 if (EvaluateDirectiveSubExpr(ResVal, getPrecedence(tok::question), 926 Tok, true, DT.IncludedUndefinedIds, *this)) { 927 // Parse error, skip the rest of the macro line. 928 if (Tok.isNot(tok::eod)) 929 DiscardUntilEndOfDirective(); 930 931 // Restore 'DisableMacroExpansion'. 932 DisableMacroExpansion = DisableMacroExpansionAtStartOfDirective; 933 return {false, DT.IncludedUndefinedIds, ResVal.getRange()}; 934 } 935 936 // If we aren't at the tok::eod token, something bad happened, like an extra 937 // ')' token. 938 if (Tok.isNot(tok::eod)) { 939 Diag(Tok, diag::err_pp_expected_eol); 940 DiscardUntilEndOfDirective(); 941 } 942 943 // Restore 'DisableMacroExpansion'. 944 DisableMacroExpansion = DisableMacroExpansionAtStartOfDirective; 945 return {ResVal.Val != 0, DT.IncludedUndefinedIds, ResVal.getRange()}; 946 } 947