ExprConstant.cpp revision 3ed4d1cbaad763c103771bdefb8b986a08f165fc
1//===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Expr constant evaluator. 11// 12// Constant expression evaluation produces four main results: 13// 14// * A success/failure flag indicating whether constant folding was successful. 15// This is the 'bool' return value used by most of the code in this file. A 16// 'false' return value indicates that constant folding has failed, and any 17// appropriate diagnostic has already been produced. 18// 19// * An evaluated result, valid only if constant folding has not failed. 20// 21// * A flag indicating if evaluation encountered (unevaluated) side-effects. 22// These arise in cases such as (sideEffect(), 0) and (sideEffect() || 1), 23// where it is possible to determine the evaluated result regardless. 24// 25// * A set of notes indicating why the evaluation was not a constant expression 26// (under the C++11 / C++1y rules only, at the moment), or, if folding failed 27// too, why the expression could not be folded. 28// 29// If we are checking for a potential constant expression, failure to constant 30// fold a potential constant sub-expression will be indicated by a 'false' 31// return value (the expression could not be folded) and no diagnostic (the 32// expression is not necessarily non-constant). 33// 34//===----------------------------------------------------------------------===// 35 36#include "clang/AST/APValue.h" 37#include "clang/AST/ASTContext.h" 38#include "clang/AST/ASTDiagnostic.h" 39#include "clang/AST/CharUnits.h" 40#include "clang/AST/Expr.h" 41#include "clang/AST/RecordLayout.h" 42#include "clang/AST/StmtVisitor.h" 43#include "clang/AST/TypeLoc.h" 44#include "clang/Basic/Builtins.h" 45#include "clang/Basic/TargetInfo.h" 46#include "llvm/ADT/SmallString.h" 47#include "llvm/Support/raw_ostream.h" 48#include <cstring> 49#include <functional> 50 51using namespace clang; 52using llvm::APSInt; 53using llvm::APFloat; 54 55static bool IsGlobalLValue(APValue::LValueBase B); 56 57namespace { 58 struct LValue; 59 struct CallStackFrame; 60 struct EvalInfo; 61 62 static QualType getType(APValue::LValueBase B) { 63 if (!B) return QualType(); 64 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) 65 return D->getType(); 66 67 const Expr *Base = B.get<const Expr*>(); 68 69 // For a materialized temporary, the type of the temporary we materialized 70 // may not be the type of the expression. 71 if (const MaterializeTemporaryExpr *MTE = 72 dyn_cast<MaterializeTemporaryExpr>(Base)) { 73 SmallVector<const Expr *, 2> CommaLHSs; 74 SmallVector<SubobjectAdjustment, 2> Adjustments; 75 const Expr *Temp = MTE->GetTemporaryExpr(); 76 const Expr *Inner = Temp->skipRValueSubobjectAdjustments(CommaLHSs, 77 Adjustments); 78 // Keep any cv-qualifiers from the reference if we generated a temporary 79 // for it. 80 if (Inner != Temp) 81 return Inner->getType(); 82 } 83 84 return Base->getType(); 85 } 86 87 /// Get an LValue path entry, which is known to not be an array index, as a 88 /// field or base class. 89 static 90 APValue::BaseOrMemberType getAsBaseOrMember(APValue::LValuePathEntry E) { 91 APValue::BaseOrMemberType Value; 92 Value.setFromOpaqueValue(E.BaseOrMember); 93 return Value; 94 } 95 96 /// Get an LValue path entry, which is known to not be an array index, as a 97 /// field declaration. 98 static const FieldDecl *getAsField(APValue::LValuePathEntry E) { 99 return dyn_cast<FieldDecl>(getAsBaseOrMember(E).getPointer()); 100 } 101 /// Get an LValue path entry, which is known to not be an array index, as a 102 /// base class declaration. 103 static const CXXRecordDecl *getAsBaseClass(APValue::LValuePathEntry E) { 104 return dyn_cast<CXXRecordDecl>(getAsBaseOrMember(E).getPointer()); 105 } 106 /// Determine whether this LValue path entry for a base class names a virtual 107 /// base class. 108 static bool isVirtualBaseClass(APValue::LValuePathEntry E) { 109 return getAsBaseOrMember(E).getInt(); 110 } 111 112 /// Find the path length and type of the most-derived subobject in the given 113 /// path, and find the size of the containing array, if any. 114 static 115 unsigned findMostDerivedSubobject(ASTContext &Ctx, QualType Base, 116 ArrayRef<APValue::LValuePathEntry> Path, 117 uint64_t &ArraySize, QualType &Type) { 118 unsigned MostDerivedLength = 0; 119 Type = Base; 120 for (unsigned I = 0, N = Path.size(); I != N; ++I) { 121 if (Type->isArrayType()) { 122 const ConstantArrayType *CAT = 123 cast<ConstantArrayType>(Ctx.getAsArrayType(Type)); 124 Type = CAT->getElementType(); 125 ArraySize = CAT->getSize().getZExtValue(); 126 MostDerivedLength = I + 1; 127 } else if (Type->isAnyComplexType()) { 128 const ComplexType *CT = Type->castAs<ComplexType>(); 129 Type = CT->getElementType(); 130 ArraySize = 2; 131 MostDerivedLength = I + 1; 132 } else if (const FieldDecl *FD = getAsField(Path[I])) { 133 Type = FD->getType(); 134 ArraySize = 0; 135 MostDerivedLength = I + 1; 136 } else { 137 // Path[I] describes a base class. 138 ArraySize = 0; 139 } 140 } 141 return MostDerivedLength; 142 } 143 144 // The order of this enum is important for diagnostics. 145 enum CheckSubobjectKind { 146 CSK_Base, CSK_Derived, CSK_Field, CSK_ArrayToPointer, CSK_ArrayIndex, 147 CSK_This, CSK_Real, CSK_Imag 148 }; 149 150 /// A path from a glvalue to a subobject of that glvalue. 151 struct SubobjectDesignator { 152 /// True if the subobject was named in a manner not supported by C++11. Such 153 /// lvalues can still be folded, but they are not core constant expressions 154 /// and we cannot perform lvalue-to-rvalue conversions on them. 155 bool Invalid : 1; 156 157 /// Is this a pointer one past the end of an object? 158 bool IsOnePastTheEnd : 1; 159 160 /// The length of the path to the most-derived object of which this is a 161 /// subobject. 162 unsigned MostDerivedPathLength : 30; 163 164 /// The size of the array of which the most-derived object is an element, or 165 /// 0 if the most-derived object is not an array element. 166 uint64_t MostDerivedArraySize; 167 168 /// The type of the most derived object referred to by this address. 169 QualType MostDerivedType; 170 171 typedef APValue::LValuePathEntry PathEntry; 172 173 /// The entries on the path from the glvalue to the designated subobject. 174 SmallVector<PathEntry, 8> Entries; 175 176 SubobjectDesignator() : Invalid(true) {} 177 178 explicit SubobjectDesignator(QualType T) 179 : Invalid(false), IsOnePastTheEnd(false), MostDerivedPathLength(0), 180 MostDerivedArraySize(0), MostDerivedType(T) {} 181 182 SubobjectDesignator(ASTContext &Ctx, const APValue &V) 183 : Invalid(!V.isLValue() || !V.hasLValuePath()), IsOnePastTheEnd(false), 184 MostDerivedPathLength(0), MostDerivedArraySize(0) { 185 if (!Invalid) { 186 IsOnePastTheEnd = V.isLValueOnePastTheEnd(); 187 ArrayRef<PathEntry> VEntries = V.getLValuePath(); 188 Entries.insert(Entries.end(), VEntries.begin(), VEntries.end()); 189 if (V.getLValueBase()) 190 MostDerivedPathLength = 191 findMostDerivedSubobject(Ctx, getType(V.getLValueBase()), 192 V.getLValuePath(), MostDerivedArraySize, 193 MostDerivedType); 194 } 195 } 196 197 void setInvalid() { 198 Invalid = true; 199 Entries.clear(); 200 } 201 202 /// Determine whether this is a one-past-the-end pointer. 203 bool isOnePastTheEnd() const { 204 if (IsOnePastTheEnd) 205 return true; 206 if (MostDerivedArraySize && 207 Entries[MostDerivedPathLength - 1].ArrayIndex == MostDerivedArraySize) 208 return true; 209 return false; 210 } 211 212 /// Check that this refers to a valid subobject. 213 bool isValidSubobject() const { 214 if (Invalid) 215 return false; 216 return !isOnePastTheEnd(); 217 } 218 /// Check that this refers to a valid subobject, and if not, produce a 219 /// relevant diagnostic and set the designator as invalid. 220 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK); 221 222 /// Update this designator to refer to the first element within this array. 223 void addArrayUnchecked(const ConstantArrayType *CAT) { 224 PathEntry Entry; 225 Entry.ArrayIndex = 0; 226 Entries.push_back(Entry); 227 228 // This is a most-derived object. 229 MostDerivedType = CAT->getElementType(); 230 MostDerivedArraySize = CAT->getSize().getZExtValue(); 231 MostDerivedPathLength = Entries.size(); 232 } 233 /// Update this designator to refer to the given base or member of this 234 /// object. 235 void addDeclUnchecked(const Decl *D, bool Virtual = false) { 236 PathEntry Entry; 237 APValue::BaseOrMemberType Value(D, Virtual); 238 Entry.BaseOrMember = Value.getOpaqueValue(); 239 Entries.push_back(Entry); 240 241 // If this isn't a base class, it's a new most-derived object. 242 if (const FieldDecl *FD = dyn_cast<FieldDecl>(D)) { 243 MostDerivedType = FD->getType(); 244 MostDerivedArraySize = 0; 245 MostDerivedPathLength = Entries.size(); 246 } 247 } 248 /// Update this designator to refer to the given complex component. 249 void addComplexUnchecked(QualType EltTy, bool Imag) { 250 PathEntry Entry; 251 Entry.ArrayIndex = Imag; 252 Entries.push_back(Entry); 253 254 // This is technically a most-derived object, though in practice this 255 // is unlikely to matter. 256 MostDerivedType = EltTy; 257 MostDerivedArraySize = 2; 258 MostDerivedPathLength = Entries.size(); 259 } 260 void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E, uint64_t N); 261 /// Add N to the address of this subobject. 262 void adjustIndex(EvalInfo &Info, const Expr *E, uint64_t N) { 263 if (Invalid) return; 264 if (MostDerivedPathLength == Entries.size() && MostDerivedArraySize) { 265 Entries.back().ArrayIndex += N; 266 if (Entries.back().ArrayIndex > MostDerivedArraySize) { 267 diagnosePointerArithmetic(Info, E, Entries.back().ArrayIndex); 268 setInvalid(); 269 } 270 return; 271 } 272 // [expr.add]p4: For the purposes of these operators, a pointer to a 273 // nonarray object behaves the same as a pointer to the first element of 274 // an array of length one with the type of the object as its element type. 275 if (IsOnePastTheEnd && N == (uint64_t)-1) 276 IsOnePastTheEnd = false; 277 else if (!IsOnePastTheEnd && N == 1) 278 IsOnePastTheEnd = true; 279 else if (N != 0) { 280 diagnosePointerArithmetic(Info, E, uint64_t(IsOnePastTheEnd) + N); 281 setInvalid(); 282 } 283 } 284 }; 285 286 /// A stack frame in the constexpr call stack. 287 struct CallStackFrame { 288 EvalInfo &Info; 289 290 /// Parent - The caller of this stack frame. 291 CallStackFrame *Caller; 292 293 /// CallLoc - The location of the call expression for this call. 294 SourceLocation CallLoc; 295 296 /// Callee - The function which was called. 297 const FunctionDecl *Callee; 298 299 /// Index - The call index of this call. 300 unsigned Index; 301 302 /// This - The binding for the this pointer in this call, if any. 303 const LValue *This; 304 305 /// ParmBindings - Parameter bindings for this function call, indexed by 306 /// parameters' function scope indices. 307 APValue *Arguments; 308 309 // Note that we intentionally use std::map here so that references to 310 // values are stable. 311 typedef std::map<const void*, APValue> MapTy; 312 typedef MapTy::const_iterator temp_iterator; 313 /// Temporaries - Temporary lvalues materialized within this stack frame. 314 MapTy Temporaries; 315 316 CallStackFrame(EvalInfo &Info, SourceLocation CallLoc, 317 const FunctionDecl *Callee, const LValue *This, 318 APValue *Arguments); 319 ~CallStackFrame(); 320 }; 321 322 /// Temporarily override 'this'. 323 class ThisOverrideRAII { 324 public: 325 ThisOverrideRAII(CallStackFrame &Frame, const LValue *NewThis, bool Enable) 326 : Frame(Frame), OldThis(Frame.This) { 327 if (Enable) 328 Frame.This = NewThis; 329 } 330 ~ThisOverrideRAII() { 331 Frame.This = OldThis; 332 } 333 private: 334 CallStackFrame &Frame; 335 const LValue *OldThis; 336 }; 337 338 /// A partial diagnostic which we might know in advance that we are not going 339 /// to emit. 340 class OptionalDiagnostic { 341 PartialDiagnostic *Diag; 342 343 public: 344 explicit OptionalDiagnostic(PartialDiagnostic *Diag = 0) : Diag(Diag) {} 345 346 template<typename T> 347 OptionalDiagnostic &operator<<(const T &v) { 348 if (Diag) 349 *Diag << v; 350 return *this; 351 } 352 353 OptionalDiagnostic &operator<<(const APSInt &I) { 354 if (Diag) { 355 SmallVector<char, 32> Buffer; 356 I.toString(Buffer); 357 *Diag << StringRef(Buffer.data(), Buffer.size()); 358 } 359 return *this; 360 } 361 362 OptionalDiagnostic &operator<<(const APFloat &F) { 363 if (Diag) { 364 SmallVector<char, 32> Buffer; 365 F.toString(Buffer); 366 *Diag << StringRef(Buffer.data(), Buffer.size()); 367 } 368 return *this; 369 } 370 }; 371 372 /// EvalInfo - This is a private struct used by the evaluator to capture 373 /// information about a subexpression as it is folded. It retains information 374 /// about the AST context, but also maintains information about the folded 375 /// expression. 376 /// 377 /// If an expression could be evaluated, it is still possible it is not a C 378 /// "integer constant expression" or constant expression. If not, this struct 379 /// captures information about how and why not. 380 /// 381 /// One bit of information passed *into* the request for constant folding 382 /// indicates whether the subexpression is "evaluated" or not according to C 383 /// rules. For example, the RHS of (0 && foo()) is not evaluated. We can 384 /// evaluate the expression regardless of what the RHS is, but C only allows 385 /// certain things in certain situations. 386 struct EvalInfo { 387 ASTContext &Ctx; 388 389 /// EvalStatus - Contains information about the evaluation. 390 Expr::EvalStatus &EvalStatus; 391 392 /// CurrentCall - The top of the constexpr call stack. 393 CallStackFrame *CurrentCall; 394 395 /// CallStackDepth - The number of calls in the call stack right now. 396 unsigned CallStackDepth; 397 398 /// NextCallIndex - The next call index to assign. 399 unsigned NextCallIndex; 400 401 /// StepsLeft - The remaining number of evaluation steps we're permitted 402 /// to perform. This is essentially a limit for the number of statements 403 /// we will evaluate. 404 unsigned StepsLeft; 405 406 /// BottomFrame - The frame in which evaluation started. This must be 407 /// initialized after CurrentCall and CallStackDepth. 408 CallStackFrame BottomFrame; 409 410 /// EvaluatingDecl - This is the declaration whose initializer is being 411 /// evaluated, if any. 412 APValue::LValueBase EvaluatingDecl; 413 414 /// EvaluatingDeclValue - This is the value being constructed for the 415 /// declaration whose initializer is being evaluated, if any. 416 APValue *EvaluatingDeclValue; 417 418 /// HasActiveDiagnostic - Was the previous diagnostic stored? If so, further 419 /// notes attached to it will also be stored, otherwise they will not be. 420 bool HasActiveDiagnostic; 421 422 /// CheckingPotentialConstantExpression - Are we checking whether the 423 /// expression is a potential constant expression? If so, some diagnostics 424 /// are suppressed. 425 bool CheckingPotentialConstantExpression; 426 427 bool IntOverflowCheckMode; 428 429 EvalInfo(const ASTContext &C, Expr::EvalStatus &S, 430 bool OverflowCheckMode = false) 431 : Ctx(const_cast<ASTContext&>(C)), EvalStatus(S), CurrentCall(0), 432 CallStackDepth(0), NextCallIndex(1), 433 StepsLeft(getLangOpts().ConstexprStepLimit), 434 BottomFrame(*this, SourceLocation(), 0, 0, 0), 435 EvaluatingDecl((const ValueDecl*)0), EvaluatingDeclValue(0), 436 HasActiveDiagnostic(false), CheckingPotentialConstantExpression(false), 437 IntOverflowCheckMode(OverflowCheckMode) {} 438 439 void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value) { 440 EvaluatingDecl = Base; 441 EvaluatingDeclValue = &Value; 442 } 443 444 const LangOptions &getLangOpts() const { return Ctx.getLangOpts(); } 445 446 bool CheckCallLimit(SourceLocation Loc) { 447 // Don't perform any constexpr calls (other than the call we're checking) 448 // when checking a potential constant expression. 449 if (CheckingPotentialConstantExpression && CallStackDepth > 1) 450 return false; 451 if (NextCallIndex == 0) { 452 // NextCallIndex has wrapped around. 453 Diag(Loc, diag::note_constexpr_call_limit_exceeded); 454 return false; 455 } 456 if (CallStackDepth <= getLangOpts().ConstexprCallDepth) 457 return true; 458 Diag(Loc, diag::note_constexpr_depth_limit_exceeded) 459 << getLangOpts().ConstexprCallDepth; 460 return false; 461 } 462 463 CallStackFrame *getCallFrame(unsigned CallIndex) { 464 assert(CallIndex && "no call index in getCallFrame"); 465 // We will eventually hit BottomFrame, which has Index 1, so Frame can't 466 // be null in this loop. 467 CallStackFrame *Frame = CurrentCall; 468 while (Frame->Index > CallIndex) 469 Frame = Frame->Caller; 470 return (Frame->Index == CallIndex) ? Frame : 0; 471 } 472 473 bool nextStep(const Stmt *S) { 474 if (!StepsLeft) { 475 Diag(S->getLocStart(), diag::note_constexpr_step_limit_exceeded); 476 return false; 477 } 478 --StepsLeft; 479 return true; 480 } 481 482 private: 483 /// Add a diagnostic to the diagnostics list. 484 PartialDiagnostic &addDiag(SourceLocation Loc, diag::kind DiagId) { 485 PartialDiagnostic PD(DiagId, Ctx.getDiagAllocator()); 486 EvalStatus.Diag->push_back(std::make_pair(Loc, PD)); 487 return EvalStatus.Diag->back().second; 488 } 489 490 /// Add notes containing a call stack to the current point of evaluation. 491 void addCallStack(unsigned Limit); 492 493 public: 494 /// Diagnose that the evaluation cannot be folded. 495 OptionalDiagnostic Diag(SourceLocation Loc, diag::kind DiagId 496 = diag::note_invalid_subexpr_in_const_expr, 497 unsigned ExtraNotes = 0) { 498 // If we have a prior diagnostic, it will be noting that the expression 499 // isn't a constant expression. This diagnostic is more important. 500 // FIXME: We might want to show both diagnostics to the user. 501 if (EvalStatus.Diag) { 502 unsigned CallStackNotes = CallStackDepth - 1; 503 unsigned Limit = Ctx.getDiagnostics().getConstexprBacktraceLimit(); 504 if (Limit) 505 CallStackNotes = std::min(CallStackNotes, Limit + 1); 506 if (CheckingPotentialConstantExpression) 507 CallStackNotes = 0; 508 509 HasActiveDiagnostic = true; 510 EvalStatus.Diag->clear(); 511 EvalStatus.Diag->reserve(1 + ExtraNotes + CallStackNotes); 512 addDiag(Loc, DiagId); 513 if (!CheckingPotentialConstantExpression) 514 addCallStack(Limit); 515 return OptionalDiagnostic(&(*EvalStatus.Diag)[0].second); 516 } 517 HasActiveDiagnostic = false; 518 return OptionalDiagnostic(); 519 } 520 521 OptionalDiagnostic Diag(const Expr *E, diag::kind DiagId 522 = diag::note_invalid_subexpr_in_const_expr, 523 unsigned ExtraNotes = 0) { 524 if (EvalStatus.Diag) 525 return Diag(E->getExprLoc(), DiagId, ExtraNotes); 526 HasActiveDiagnostic = false; 527 return OptionalDiagnostic(); 528 } 529 530 bool getIntOverflowCheckMode() { return IntOverflowCheckMode; } 531 532 /// Diagnose that the evaluation does not produce a C++11 core constant 533 /// expression. 534 template<typename LocArg> 535 OptionalDiagnostic CCEDiag(LocArg Loc, diag::kind DiagId 536 = diag::note_invalid_subexpr_in_const_expr, 537 unsigned ExtraNotes = 0) { 538 // Don't override a previous diagnostic. 539 if (!EvalStatus.Diag || !EvalStatus.Diag->empty()) { 540 HasActiveDiagnostic = false; 541 return OptionalDiagnostic(); 542 } 543 return Diag(Loc, DiagId, ExtraNotes); 544 } 545 546 /// Add a note to a prior diagnostic. 547 OptionalDiagnostic Note(SourceLocation Loc, diag::kind DiagId) { 548 if (!HasActiveDiagnostic) 549 return OptionalDiagnostic(); 550 return OptionalDiagnostic(&addDiag(Loc, DiagId)); 551 } 552 553 /// Add a stack of notes to a prior diagnostic. 554 void addNotes(ArrayRef<PartialDiagnosticAt> Diags) { 555 if (HasActiveDiagnostic) { 556 EvalStatus.Diag->insert(EvalStatus.Diag->end(), 557 Diags.begin(), Diags.end()); 558 } 559 } 560 561 /// Should we continue evaluation as much as possible after encountering a 562 /// construct which can't be folded? 563 bool keepEvaluatingAfterFailure() { 564 // Should return true in IntOverflowCheckMode, so that we check for 565 // overflow even if some subexpressions can't be evaluated as constants. 566 return StepsLeft && (IntOverflowCheckMode || 567 (CheckingPotentialConstantExpression && 568 EvalStatus.Diag && EvalStatus.Diag->empty())); 569 } 570 }; 571 572 /// Object used to treat all foldable expressions as constant expressions. 573 struct FoldConstant { 574 bool Enabled; 575 576 explicit FoldConstant(EvalInfo &Info) 577 : Enabled(Info.EvalStatus.Diag && Info.EvalStatus.Diag->empty() && 578 !Info.EvalStatus.HasSideEffects) { 579 } 580 // Treat the value we've computed since this object was created as constant. 581 void Fold(EvalInfo &Info) { 582 if (Enabled && !Info.EvalStatus.Diag->empty() && 583 !Info.EvalStatus.HasSideEffects) 584 Info.EvalStatus.Diag->clear(); 585 } 586 }; 587 588 /// RAII object used to suppress diagnostics and side-effects from a 589 /// speculative evaluation. 590 class SpeculativeEvaluationRAII { 591 EvalInfo &Info; 592 Expr::EvalStatus Old; 593 594 public: 595 SpeculativeEvaluationRAII(EvalInfo &Info, 596 SmallVectorImpl<PartialDiagnosticAt> *NewDiag = 0) 597 : Info(Info), Old(Info.EvalStatus) { 598 Info.EvalStatus.Diag = NewDiag; 599 } 600 ~SpeculativeEvaluationRAII() { 601 Info.EvalStatus = Old; 602 } 603 }; 604} 605 606bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E, 607 CheckSubobjectKind CSK) { 608 if (Invalid) 609 return false; 610 if (isOnePastTheEnd()) { 611 Info.CCEDiag(E, diag::note_constexpr_past_end_subobject) 612 << CSK; 613 setInvalid(); 614 return false; 615 } 616 return true; 617} 618 619void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info, 620 const Expr *E, uint64_t N) { 621 if (MostDerivedPathLength == Entries.size() && MostDerivedArraySize) 622 Info.CCEDiag(E, diag::note_constexpr_array_index) 623 << static_cast<int>(N) << /*array*/ 0 624 << static_cast<unsigned>(MostDerivedArraySize); 625 else 626 Info.CCEDiag(E, diag::note_constexpr_array_index) 627 << static_cast<int>(N) << /*non-array*/ 1; 628 setInvalid(); 629} 630 631CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc, 632 const FunctionDecl *Callee, const LValue *This, 633 APValue *Arguments) 634 : Info(Info), Caller(Info.CurrentCall), CallLoc(CallLoc), Callee(Callee), 635 Index(Info.NextCallIndex++), This(This), Arguments(Arguments) { 636 Info.CurrentCall = this; 637 ++Info.CallStackDepth; 638} 639 640CallStackFrame::~CallStackFrame() { 641 assert(Info.CurrentCall == this && "calls retired out of order"); 642 --Info.CallStackDepth; 643 Info.CurrentCall = Caller; 644} 645 646static void describeCall(CallStackFrame *Frame, raw_ostream &Out); 647 648void EvalInfo::addCallStack(unsigned Limit) { 649 // Determine which calls to skip, if any. 650 unsigned ActiveCalls = CallStackDepth - 1; 651 unsigned SkipStart = ActiveCalls, SkipEnd = SkipStart; 652 if (Limit && Limit < ActiveCalls) { 653 SkipStart = Limit / 2 + Limit % 2; 654 SkipEnd = ActiveCalls - Limit / 2; 655 } 656 657 // Walk the call stack and add the diagnostics. 658 unsigned CallIdx = 0; 659 for (CallStackFrame *Frame = CurrentCall; Frame != &BottomFrame; 660 Frame = Frame->Caller, ++CallIdx) { 661 // Skip this call? 662 if (CallIdx >= SkipStart && CallIdx < SkipEnd) { 663 if (CallIdx == SkipStart) { 664 // Note that we're skipping calls. 665 addDiag(Frame->CallLoc, diag::note_constexpr_calls_suppressed) 666 << unsigned(ActiveCalls - Limit); 667 } 668 continue; 669 } 670 671 SmallVector<char, 128> Buffer; 672 llvm::raw_svector_ostream Out(Buffer); 673 describeCall(Frame, Out); 674 addDiag(Frame->CallLoc, diag::note_constexpr_call_here) << Out.str(); 675 } 676} 677 678namespace { 679 struct ComplexValue { 680 private: 681 bool IsInt; 682 683 public: 684 APSInt IntReal, IntImag; 685 APFloat FloatReal, FloatImag; 686 687 ComplexValue() : FloatReal(APFloat::Bogus), FloatImag(APFloat::Bogus) {} 688 689 void makeComplexFloat() { IsInt = false; } 690 bool isComplexFloat() const { return !IsInt; } 691 APFloat &getComplexFloatReal() { return FloatReal; } 692 APFloat &getComplexFloatImag() { return FloatImag; } 693 694 void makeComplexInt() { IsInt = true; } 695 bool isComplexInt() const { return IsInt; } 696 APSInt &getComplexIntReal() { return IntReal; } 697 APSInt &getComplexIntImag() { return IntImag; } 698 699 void moveInto(APValue &v) const { 700 if (isComplexFloat()) 701 v = APValue(FloatReal, FloatImag); 702 else 703 v = APValue(IntReal, IntImag); 704 } 705 void setFrom(const APValue &v) { 706 assert(v.isComplexFloat() || v.isComplexInt()); 707 if (v.isComplexFloat()) { 708 makeComplexFloat(); 709 FloatReal = v.getComplexFloatReal(); 710 FloatImag = v.getComplexFloatImag(); 711 } else { 712 makeComplexInt(); 713 IntReal = v.getComplexIntReal(); 714 IntImag = v.getComplexIntImag(); 715 } 716 } 717 }; 718 719 struct LValue { 720 APValue::LValueBase Base; 721 CharUnits Offset; 722 unsigned CallIndex; 723 SubobjectDesignator Designator; 724 725 const APValue::LValueBase getLValueBase() const { return Base; } 726 CharUnits &getLValueOffset() { return Offset; } 727 const CharUnits &getLValueOffset() const { return Offset; } 728 unsigned getLValueCallIndex() const { return CallIndex; } 729 SubobjectDesignator &getLValueDesignator() { return Designator; } 730 const SubobjectDesignator &getLValueDesignator() const { return Designator;} 731 732 void moveInto(APValue &V) const { 733 if (Designator.Invalid) 734 V = APValue(Base, Offset, APValue::NoLValuePath(), CallIndex); 735 else 736 V = APValue(Base, Offset, Designator.Entries, 737 Designator.IsOnePastTheEnd, CallIndex); 738 } 739 void setFrom(ASTContext &Ctx, const APValue &V) { 740 assert(V.isLValue()); 741 Base = V.getLValueBase(); 742 Offset = V.getLValueOffset(); 743 CallIndex = V.getLValueCallIndex(); 744 Designator = SubobjectDesignator(Ctx, V); 745 } 746 747 void set(APValue::LValueBase B, unsigned I = 0) { 748 Base = B; 749 Offset = CharUnits::Zero(); 750 CallIndex = I; 751 Designator = SubobjectDesignator(getType(B)); 752 } 753 754 // Check that this LValue is not based on a null pointer. If it is, produce 755 // a diagnostic and mark the designator as invalid. 756 bool checkNullPointer(EvalInfo &Info, const Expr *E, 757 CheckSubobjectKind CSK) { 758 if (Designator.Invalid) 759 return false; 760 if (!Base) { 761 Info.CCEDiag(E, diag::note_constexpr_null_subobject) 762 << CSK; 763 Designator.setInvalid(); 764 return false; 765 } 766 return true; 767 } 768 769 // Check this LValue refers to an object. If not, set the designator to be 770 // invalid and emit a diagnostic. 771 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) { 772 // Outside C++11, do not build a designator referring to a subobject of 773 // any object: we won't use such a designator for anything. 774 if (!Info.getLangOpts().CPlusPlus11) 775 Designator.setInvalid(); 776 return checkNullPointer(Info, E, CSK) && 777 Designator.checkSubobject(Info, E, CSK); 778 } 779 780 void addDecl(EvalInfo &Info, const Expr *E, 781 const Decl *D, bool Virtual = false) { 782 if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base)) 783 Designator.addDeclUnchecked(D, Virtual); 784 } 785 void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) { 786 if (checkSubobject(Info, E, CSK_ArrayToPointer)) 787 Designator.addArrayUnchecked(CAT); 788 } 789 void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) { 790 if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real)) 791 Designator.addComplexUnchecked(EltTy, Imag); 792 } 793 void adjustIndex(EvalInfo &Info, const Expr *E, uint64_t N) { 794 if (checkNullPointer(Info, E, CSK_ArrayIndex)) 795 Designator.adjustIndex(Info, E, N); 796 } 797 }; 798 799 struct MemberPtr { 800 MemberPtr() {} 801 explicit MemberPtr(const ValueDecl *Decl) : 802 DeclAndIsDerivedMember(Decl, false), Path() {} 803 804 /// The member or (direct or indirect) field referred to by this member 805 /// pointer, or 0 if this is a null member pointer. 806 const ValueDecl *getDecl() const { 807 return DeclAndIsDerivedMember.getPointer(); 808 } 809 /// Is this actually a member of some type derived from the relevant class? 810 bool isDerivedMember() const { 811 return DeclAndIsDerivedMember.getInt(); 812 } 813 /// Get the class which the declaration actually lives in. 814 const CXXRecordDecl *getContainingRecord() const { 815 return cast<CXXRecordDecl>( 816 DeclAndIsDerivedMember.getPointer()->getDeclContext()); 817 } 818 819 void moveInto(APValue &V) const { 820 V = APValue(getDecl(), isDerivedMember(), Path); 821 } 822 void setFrom(const APValue &V) { 823 assert(V.isMemberPointer()); 824 DeclAndIsDerivedMember.setPointer(V.getMemberPointerDecl()); 825 DeclAndIsDerivedMember.setInt(V.isMemberPointerToDerivedMember()); 826 Path.clear(); 827 ArrayRef<const CXXRecordDecl*> P = V.getMemberPointerPath(); 828 Path.insert(Path.end(), P.begin(), P.end()); 829 } 830 831 /// DeclAndIsDerivedMember - The member declaration, and a flag indicating 832 /// whether the member is a member of some class derived from the class type 833 /// of the member pointer. 834 llvm::PointerIntPair<const ValueDecl*, 1, bool> DeclAndIsDerivedMember; 835 /// Path - The path of base/derived classes from the member declaration's 836 /// class (exclusive) to the class type of the member pointer (inclusive). 837 SmallVector<const CXXRecordDecl*, 4> Path; 838 839 /// Perform a cast towards the class of the Decl (either up or down the 840 /// hierarchy). 841 bool castBack(const CXXRecordDecl *Class) { 842 assert(!Path.empty()); 843 const CXXRecordDecl *Expected; 844 if (Path.size() >= 2) 845 Expected = Path[Path.size() - 2]; 846 else 847 Expected = getContainingRecord(); 848 if (Expected->getCanonicalDecl() != Class->getCanonicalDecl()) { 849 // C++11 [expr.static.cast]p12: In a conversion from (D::*) to (B::*), 850 // if B does not contain the original member and is not a base or 851 // derived class of the class containing the original member, the result 852 // of the cast is undefined. 853 // C++11 [conv.mem]p2 does not cover this case for a cast from (B::*) to 854 // (D::*). We consider that to be a language defect. 855 return false; 856 } 857 Path.pop_back(); 858 return true; 859 } 860 /// Perform a base-to-derived member pointer cast. 861 bool castToDerived(const CXXRecordDecl *Derived) { 862 if (!getDecl()) 863 return true; 864 if (!isDerivedMember()) { 865 Path.push_back(Derived); 866 return true; 867 } 868 if (!castBack(Derived)) 869 return false; 870 if (Path.empty()) 871 DeclAndIsDerivedMember.setInt(false); 872 return true; 873 } 874 /// Perform a derived-to-base member pointer cast. 875 bool castToBase(const CXXRecordDecl *Base) { 876 if (!getDecl()) 877 return true; 878 if (Path.empty()) 879 DeclAndIsDerivedMember.setInt(true); 880 if (isDerivedMember()) { 881 Path.push_back(Base); 882 return true; 883 } 884 return castBack(Base); 885 } 886 }; 887 888 /// Compare two member pointers, which are assumed to be of the same type. 889 static bool operator==(const MemberPtr &LHS, const MemberPtr &RHS) { 890 if (!LHS.getDecl() || !RHS.getDecl()) 891 return !LHS.getDecl() && !RHS.getDecl(); 892 if (LHS.getDecl()->getCanonicalDecl() != RHS.getDecl()->getCanonicalDecl()) 893 return false; 894 return LHS.Path == RHS.Path; 895 } 896} 897 898static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E); 899static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, 900 const LValue &This, const Expr *E, 901 bool AllowNonLiteralTypes = false); 902static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info); 903static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info); 904static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result, 905 EvalInfo &Info); 906static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info); 907static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info); 908static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result, 909 EvalInfo &Info); 910static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info); 911static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info); 912static bool EvaluateAtomic(const Expr *E, APValue &Result, EvalInfo &Info); 913 914//===----------------------------------------------------------------------===// 915// Misc utilities 916//===----------------------------------------------------------------------===// 917 918/// Produce a string describing the given constexpr call. 919static void describeCall(CallStackFrame *Frame, raw_ostream &Out) { 920 unsigned ArgIndex = 0; 921 bool IsMemberCall = isa<CXXMethodDecl>(Frame->Callee) && 922 !isa<CXXConstructorDecl>(Frame->Callee) && 923 cast<CXXMethodDecl>(Frame->Callee)->isInstance(); 924 925 if (!IsMemberCall) 926 Out << *Frame->Callee << '('; 927 928 if (Frame->This && IsMemberCall) { 929 APValue Val; 930 Frame->This->moveInto(Val); 931 Val.printPretty(Out, Frame->Info.Ctx, 932 Frame->This->Designator.MostDerivedType); 933 // FIXME: Add parens around Val if needed. 934 Out << "->" << *Frame->Callee << '('; 935 IsMemberCall = false; 936 } 937 938 for (FunctionDecl::param_const_iterator I = Frame->Callee->param_begin(), 939 E = Frame->Callee->param_end(); I != E; ++I, ++ArgIndex) { 940 if (ArgIndex > (unsigned)IsMemberCall) 941 Out << ", "; 942 943 const ParmVarDecl *Param = *I; 944 const APValue &Arg = Frame->Arguments[ArgIndex]; 945 Arg.printPretty(Out, Frame->Info.Ctx, Param->getType()); 946 947 if (ArgIndex == 0 && IsMemberCall) 948 Out << "->" << *Frame->Callee << '('; 949 } 950 951 Out << ')'; 952} 953 954/// Evaluate an expression to see if it had side-effects, and discard its 955/// result. 956/// \return \c true if the caller should keep evaluating. 957static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) { 958 APValue Scratch; 959 if (!Evaluate(Scratch, Info, E)) { 960 Info.EvalStatus.HasSideEffects = true; 961 return Info.keepEvaluatingAfterFailure(); 962 } 963 return true; 964} 965 966/// Sign- or zero-extend a value to 64 bits. If it's already 64 bits, just 967/// return its existing value. 968static int64_t getExtValue(const APSInt &Value) { 969 return Value.isSigned() ? Value.getSExtValue() 970 : static_cast<int64_t>(Value.getZExtValue()); 971} 972 973/// Should this call expression be treated as a string literal? 974static bool IsStringLiteralCall(const CallExpr *E) { 975 unsigned Builtin = E->isBuiltinCall(); 976 return (Builtin == Builtin::BI__builtin___CFStringMakeConstantString || 977 Builtin == Builtin::BI__builtin___NSStringMakeConstantString); 978} 979 980static bool IsGlobalLValue(APValue::LValueBase B) { 981 // C++11 [expr.const]p3 An address constant expression is a prvalue core 982 // constant expression of pointer type that evaluates to... 983 984 // ... a null pointer value, or a prvalue core constant expression of type 985 // std::nullptr_t. 986 if (!B) return true; 987 988 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) { 989 // ... the address of an object with static storage duration, 990 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 991 return VD->hasGlobalStorage(); 992 // ... the address of a function, 993 return isa<FunctionDecl>(D); 994 } 995 996 const Expr *E = B.get<const Expr*>(); 997 switch (E->getStmtClass()) { 998 default: 999 return false; 1000 case Expr::CompoundLiteralExprClass: { 1001 const CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 1002 return CLE->isFileScope() && CLE->isLValue(); 1003 } 1004 case Expr::MaterializeTemporaryExprClass: 1005 // A materialized temporary might have been lifetime-extended to static 1006 // storage duration. 1007 return cast<MaterializeTemporaryExpr>(E)->getStorageDuration() == SD_Static; 1008 // A string literal has static storage duration. 1009 case Expr::StringLiteralClass: 1010 case Expr::PredefinedExprClass: 1011 case Expr::ObjCStringLiteralClass: 1012 case Expr::ObjCEncodeExprClass: 1013 case Expr::CXXTypeidExprClass: 1014 case Expr::CXXUuidofExprClass: 1015 return true; 1016 case Expr::CallExprClass: 1017 return IsStringLiteralCall(cast<CallExpr>(E)); 1018 // For GCC compatibility, &&label has static storage duration. 1019 case Expr::AddrLabelExprClass: 1020 return true; 1021 // A Block literal expression may be used as the initialization value for 1022 // Block variables at global or local static scope. 1023 case Expr::BlockExprClass: 1024 return !cast<BlockExpr>(E)->getBlockDecl()->hasCaptures(); 1025 case Expr::ImplicitValueInitExprClass: 1026 // FIXME: 1027 // We can never form an lvalue with an implicit value initialization as its 1028 // base through expression evaluation, so these only appear in one case: the 1029 // implicit variable declaration we invent when checking whether a constexpr 1030 // constructor can produce a constant expression. We must assume that such 1031 // an expression might be a global lvalue. 1032 return true; 1033 } 1034} 1035 1036static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) { 1037 assert(Base && "no location for a null lvalue"); 1038 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>(); 1039 if (VD) 1040 Info.Note(VD->getLocation(), diag::note_declared_at); 1041 else 1042 Info.Note(Base.get<const Expr*>()->getExprLoc(), 1043 diag::note_constexpr_temporary_here); 1044} 1045 1046/// Check that this reference or pointer core constant expression is a valid 1047/// value for an address or reference constant expression. Return true if we 1048/// can fold this expression, whether or not it's a constant expression. 1049static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc, 1050 QualType Type, const LValue &LVal) { 1051 bool IsReferenceType = Type->isReferenceType(); 1052 1053 APValue::LValueBase Base = LVal.getLValueBase(); 1054 const SubobjectDesignator &Designator = LVal.getLValueDesignator(); 1055 1056 // Check that the object is a global. Note that the fake 'this' object we 1057 // manufacture when checking potential constant expressions is conservatively 1058 // assumed to be global here. 1059 if (!IsGlobalLValue(Base)) { 1060 if (Info.getLangOpts().CPlusPlus11) { 1061 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>(); 1062 Info.Diag(Loc, diag::note_constexpr_non_global, 1) 1063 << IsReferenceType << !Designator.Entries.empty() 1064 << !!VD << VD; 1065 NoteLValueLocation(Info, Base); 1066 } else { 1067 Info.Diag(Loc); 1068 } 1069 // Don't allow references to temporaries to escape. 1070 return false; 1071 } 1072 assert((Info.CheckingPotentialConstantExpression || 1073 LVal.getLValueCallIndex() == 0) && 1074 "have call index for global lvalue"); 1075 1076 // Check if this is a thread-local variable. 1077 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) { 1078 if (const VarDecl *Var = dyn_cast<const VarDecl>(VD)) { 1079 if (Var->getTLSKind()) 1080 return false; 1081 } 1082 } 1083 1084 // Allow address constant expressions to be past-the-end pointers. This is 1085 // an extension: the standard requires them to point to an object. 1086 if (!IsReferenceType) 1087 return true; 1088 1089 // A reference constant expression must refer to an object. 1090 if (!Base) { 1091 // FIXME: diagnostic 1092 Info.CCEDiag(Loc); 1093 return true; 1094 } 1095 1096 // Does this refer one past the end of some object? 1097 if (Designator.isOnePastTheEnd()) { 1098 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>(); 1099 Info.Diag(Loc, diag::note_constexpr_past_end, 1) 1100 << !Designator.Entries.empty() << !!VD << VD; 1101 NoteLValueLocation(Info, Base); 1102 } 1103 1104 return true; 1105} 1106 1107/// Check that this core constant expression is of literal type, and if not, 1108/// produce an appropriate diagnostic. 1109static bool CheckLiteralType(EvalInfo &Info, const Expr *E, 1110 const LValue *This = 0) { 1111 if (!E->isRValue() || E->getType()->isLiteralType(Info.Ctx)) 1112 return true; 1113 1114 // C++1y: A constant initializer for an object o [...] may also invoke 1115 // constexpr constructors for o and its subobjects even if those objects 1116 // are of non-literal class types. 1117 if (Info.getLangOpts().CPlusPlus1y && This && 1118 Info.EvaluatingDecl == This->getLValueBase()) 1119 return true; 1120 1121 // Prvalue constant expressions must be of literal types. 1122 if (Info.getLangOpts().CPlusPlus11) 1123 Info.Diag(E, diag::note_constexpr_nonliteral) 1124 << E->getType(); 1125 else 1126 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr); 1127 return false; 1128} 1129 1130/// Check that this core constant expression value is a valid value for a 1131/// constant expression. If not, report an appropriate diagnostic. Does not 1132/// check that the expression is of literal type. 1133static bool CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc, 1134 QualType Type, const APValue &Value) { 1135 if (Value.isUninit()) { 1136 Info.Diag(DiagLoc, diag::note_constexpr_uninitialized) << Type; 1137 return false; 1138 } 1139 1140 // Core issue 1454: For a literal constant expression of array or class type, 1141 // each subobject of its value shall have been initialized by a constant 1142 // expression. 1143 if (Value.isArray()) { 1144 QualType EltTy = Type->castAsArrayTypeUnsafe()->getElementType(); 1145 for (unsigned I = 0, N = Value.getArrayInitializedElts(); I != N; ++I) { 1146 if (!CheckConstantExpression(Info, DiagLoc, EltTy, 1147 Value.getArrayInitializedElt(I))) 1148 return false; 1149 } 1150 if (!Value.hasArrayFiller()) 1151 return true; 1152 return CheckConstantExpression(Info, DiagLoc, EltTy, 1153 Value.getArrayFiller()); 1154 } 1155 if (Value.isUnion() && Value.getUnionField()) { 1156 return CheckConstantExpression(Info, DiagLoc, 1157 Value.getUnionField()->getType(), 1158 Value.getUnionValue()); 1159 } 1160 if (Value.isStruct()) { 1161 RecordDecl *RD = Type->castAs<RecordType>()->getDecl(); 1162 if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) { 1163 unsigned BaseIndex = 0; 1164 for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(), 1165 End = CD->bases_end(); I != End; ++I, ++BaseIndex) { 1166 if (!CheckConstantExpression(Info, DiagLoc, I->getType(), 1167 Value.getStructBase(BaseIndex))) 1168 return false; 1169 } 1170 } 1171 for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end(); 1172 I != E; ++I) { 1173 if (!CheckConstantExpression(Info, DiagLoc, I->getType(), 1174 Value.getStructField(I->getFieldIndex()))) 1175 return false; 1176 } 1177 } 1178 1179 if (Value.isLValue()) { 1180 LValue LVal; 1181 LVal.setFrom(Info.Ctx, Value); 1182 return CheckLValueConstantExpression(Info, DiagLoc, Type, LVal); 1183 } 1184 1185 // Everything else is fine. 1186 return true; 1187} 1188 1189const ValueDecl *GetLValueBaseDecl(const LValue &LVal) { 1190 return LVal.Base.dyn_cast<const ValueDecl*>(); 1191} 1192 1193static bool IsLiteralLValue(const LValue &Value) { 1194 if (Value.CallIndex) 1195 return false; 1196 const Expr *E = Value.Base.dyn_cast<const Expr*>(); 1197 return E && !isa<MaterializeTemporaryExpr>(E); 1198} 1199 1200static bool IsWeakLValue(const LValue &Value) { 1201 const ValueDecl *Decl = GetLValueBaseDecl(Value); 1202 return Decl && Decl->isWeak(); 1203} 1204 1205static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) { 1206 // A null base expression indicates a null pointer. These are always 1207 // evaluatable, and they are false unless the offset is zero. 1208 if (!Value.getLValueBase()) { 1209 Result = !Value.getLValueOffset().isZero(); 1210 return true; 1211 } 1212 1213 // We have a non-null base. These are generally known to be true, but if it's 1214 // a weak declaration it can be null at runtime. 1215 Result = true; 1216 const ValueDecl *Decl = Value.getLValueBase().dyn_cast<const ValueDecl*>(); 1217 return !Decl || !Decl->isWeak(); 1218} 1219 1220static bool HandleConversionToBool(const APValue &Val, bool &Result) { 1221 switch (Val.getKind()) { 1222 case APValue::Uninitialized: 1223 return false; 1224 case APValue::Int: 1225 Result = Val.getInt().getBoolValue(); 1226 return true; 1227 case APValue::Float: 1228 Result = !Val.getFloat().isZero(); 1229 return true; 1230 case APValue::ComplexInt: 1231 Result = Val.getComplexIntReal().getBoolValue() || 1232 Val.getComplexIntImag().getBoolValue(); 1233 return true; 1234 case APValue::ComplexFloat: 1235 Result = !Val.getComplexFloatReal().isZero() || 1236 !Val.getComplexFloatImag().isZero(); 1237 return true; 1238 case APValue::LValue: 1239 return EvalPointerValueAsBool(Val, Result); 1240 case APValue::MemberPointer: 1241 Result = Val.getMemberPointerDecl(); 1242 return true; 1243 case APValue::Vector: 1244 case APValue::Array: 1245 case APValue::Struct: 1246 case APValue::Union: 1247 case APValue::AddrLabelDiff: 1248 return false; 1249 } 1250 1251 llvm_unreachable("unknown APValue kind"); 1252} 1253 1254static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result, 1255 EvalInfo &Info) { 1256 assert(E->isRValue() && "missing lvalue-to-rvalue conv in bool condition"); 1257 APValue Val; 1258 if (!Evaluate(Val, Info, E)) 1259 return false; 1260 return HandleConversionToBool(Val, Result); 1261} 1262 1263template<typename T> 1264static void HandleOverflow(EvalInfo &Info, const Expr *E, 1265 const T &SrcValue, QualType DestType) { 1266 Info.CCEDiag(E, diag::note_constexpr_overflow) 1267 << SrcValue << DestType; 1268} 1269 1270static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E, 1271 QualType SrcType, const APFloat &Value, 1272 QualType DestType, APSInt &Result) { 1273 unsigned DestWidth = Info.Ctx.getIntWidth(DestType); 1274 // Determine whether we are converting to unsigned or signed. 1275 bool DestSigned = DestType->isSignedIntegerOrEnumerationType(); 1276 1277 Result = APSInt(DestWidth, !DestSigned); 1278 bool ignored; 1279 if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored) 1280 & APFloat::opInvalidOp) 1281 HandleOverflow(Info, E, Value, DestType); 1282 return true; 1283} 1284 1285static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E, 1286 QualType SrcType, QualType DestType, 1287 APFloat &Result) { 1288 APFloat Value = Result; 1289 bool ignored; 1290 if (Result.convert(Info.Ctx.getFloatTypeSemantics(DestType), 1291 APFloat::rmNearestTiesToEven, &ignored) 1292 & APFloat::opOverflow) 1293 HandleOverflow(Info, E, Value, DestType); 1294 return true; 1295} 1296 1297static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E, 1298 QualType DestType, QualType SrcType, 1299 APSInt &Value) { 1300 unsigned DestWidth = Info.Ctx.getIntWidth(DestType); 1301 APSInt Result = Value; 1302 // Figure out if this is a truncate, extend or noop cast. 1303 // If the input is signed, do a sign extend, noop, or truncate. 1304 Result = Result.extOrTrunc(DestWidth); 1305 Result.setIsUnsigned(DestType->isUnsignedIntegerOrEnumerationType()); 1306 return Result; 1307} 1308 1309static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E, 1310 QualType SrcType, const APSInt &Value, 1311 QualType DestType, APFloat &Result) { 1312 Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1); 1313 if (Result.convertFromAPInt(Value, Value.isSigned(), 1314 APFloat::rmNearestTiesToEven) 1315 & APFloat::opOverflow) 1316 HandleOverflow(Info, E, Value, DestType); 1317 return true; 1318} 1319 1320static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E, 1321 llvm::APInt &Res) { 1322 APValue SVal; 1323 if (!Evaluate(SVal, Info, E)) 1324 return false; 1325 if (SVal.isInt()) { 1326 Res = SVal.getInt(); 1327 return true; 1328 } 1329 if (SVal.isFloat()) { 1330 Res = SVal.getFloat().bitcastToAPInt(); 1331 return true; 1332 } 1333 if (SVal.isVector()) { 1334 QualType VecTy = E->getType(); 1335 unsigned VecSize = Info.Ctx.getTypeSize(VecTy); 1336 QualType EltTy = VecTy->castAs<VectorType>()->getElementType(); 1337 unsigned EltSize = Info.Ctx.getTypeSize(EltTy); 1338 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian(); 1339 Res = llvm::APInt::getNullValue(VecSize); 1340 for (unsigned i = 0; i < SVal.getVectorLength(); i++) { 1341 APValue &Elt = SVal.getVectorElt(i); 1342 llvm::APInt EltAsInt; 1343 if (Elt.isInt()) { 1344 EltAsInt = Elt.getInt(); 1345 } else if (Elt.isFloat()) { 1346 EltAsInt = Elt.getFloat().bitcastToAPInt(); 1347 } else { 1348 // Don't try to handle vectors of anything other than int or float 1349 // (not sure if it's possible to hit this case). 1350 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr); 1351 return false; 1352 } 1353 unsigned BaseEltSize = EltAsInt.getBitWidth(); 1354 if (BigEndian) 1355 Res |= EltAsInt.zextOrTrunc(VecSize).rotr(i*EltSize+BaseEltSize); 1356 else 1357 Res |= EltAsInt.zextOrTrunc(VecSize).rotl(i*EltSize); 1358 } 1359 return true; 1360 } 1361 // Give up if the input isn't an int, float, or vector. For example, we 1362 // reject "(v4i16)(intptr_t)&a". 1363 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr); 1364 return false; 1365} 1366 1367/// Perform the given integer operation, which is known to need at most BitWidth 1368/// bits, and check for overflow in the original type (if that type was not an 1369/// unsigned type). 1370template<typename Operation> 1371static APSInt CheckedIntArithmetic(EvalInfo &Info, const Expr *E, 1372 const APSInt &LHS, const APSInt &RHS, 1373 unsigned BitWidth, Operation Op) { 1374 if (LHS.isUnsigned()) 1375 return Op(LHS, RHS); 1376 1377 APSInt Value(Op(LHS.extend(BitWidth), RHS.extend(BitWidth)), false); 1378 APSInt Result = Value.trunc(LHS.getBitWidth()); 1379 if (Result.extend(BitWidth) != Value) { 1380 if (Info.getIntOverflowCheckMode()) 1381 Info.Ctx.getDiagnostics().Report(E->getExprLoc(), 1382 diag::warn_integer_constant_overflow) 1383 << Result.toString(10) << E->getType(); 1384 else 1385 HandleOverflow(Info, E, Value, E->getType()); 1386 } 1387 return Result; 1388} 1389 1390/// Perform the given binary integer operation. 1391static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS, 1392 BinaryOperatorKind Opcode, APSInt RHS, 1393 APSInt &Result) { 1394 switch (Opcode) { 1395 default: 1396 Info.Diag(E); 1397 return false; 1398 case BO_Mul: 1399 Result = CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() * 2, 1400 std::multiplies<APSInt>()); 1401 return true; 1402 case BO_Add: 1403 Result = CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1, 1404 std::plus<APSInt>()); 1405 return true; 1406 case BO_Sub: 1407 Result = CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1, 1408 std::minus<APSInt>()); 1409 return true; 1410 case BO_And: Result = LHS & RHS; return true; 1411 case BO_Xor: Result = LHS ^ RHS; return true; 1412 case BO_Or: Result = LHS | RHS; return true; 1413 case BO_Div: 1414 case BO_Rem: 1415 if (RHS == 0) { 1416 Info.Diag(E, diag::note_expr_divide_by_zero); 1417 return false; 1418 } 1419 // Check for overflow case: INT_MIN / -1 or INT_MIN % -1. 1420 if (RHS.isNegative() && RHS.isAllOnesValue() && 1421 LHS.isSigned() && LHS.isMinSignedValue()) 1422 HandleOverflow(Info, E, -LHS.extend(LHS.getBitWidth() + 1), E->getType()); 1423 Result = (Opcode == BO_Rem ? LHS % RHS : LHS / RHS); 1424 return true; 1425 case BO_Shl: { 1426 if (Info.getLangOpts().OpenCL) 1427 // OpenCL 6.3j: shift values are effectively % word size of LHS. 1428 RHS &= APSInt(llvm::APInt(RHS.getBitWidth(), 1429 static_cast<uint64_t>(LHS.getBitWidth() - 1)), 1430 RHS.isUnsigned()); 1431 else if (RHS.isSigned() && RHS.isNegative()) { 1432 // During constant-folding, a negative shift is an opposite shift. Such 1433 // a shift is not a constant expression. 1434 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS; 1435 RHS = -RHS; 1436 goto shift_right; 1437 } 1438 shift_left: 1439 // C++11 [expr.shift]p1: Shift width must be less than the bit width of 1440 // the shifted type. 1441 unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1); 1442 if (SA != RHS) { 1443 Info.CCEDiag(E, diag::note_constexpr_large_shift) 1444 << RHS << E->getType() << LHS.getBitWidth(); 1445 } else if (LHS.isSigned()) { 1446 // C++11 [expr.shift]p2: A signed left shift must have a non-negative 1447 // operand, and must not overflow the corresponding unsigned type. 1448 if (LHS.isNegative()) 1449 Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS; 1450 else if (LHS.countLeadingZeros() < SA) 1451 Info.CCEDiag(E, diag::note_constexpr_lshift_discards); 1452 } 1453 Result = LHS << SA; 1454 return true; 1455 } 1456 case BO_Shr: { 1457 if (Info.getLangOpts().OpenCL) 1458 // OpenCL 6.3j: shift values are effectively % word size of LHS. 1459 RHS &= APSInt(llvm::APInt(RHS.getBitWidth(), 1460 static_cast<uint64_t>(LHS.getBitWidth() - 1)), 1461 RHS.isUnsigned()); 1462 else if (RHS.isSigned() && RHS.isNegative()) { 1463 // During constant-folding, a negative shift is an opposite shift. Such a 1464 // shift is not a constant expression. 1465 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS; 1466 RHS = -RHS; 1467 goto shift_left; 1468 } 1469 shift_right: 1470 // C++11 [expr.shift]p1: Shift width must be less than the bit width of the 1471 // shifted type. 1472 unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1); 1473 if (SA != RHS) 1474 Info.CCEDiag(E, diag::note_constexpr_large_shift) 1475 << RHS << E->getType() << LHS.getBitWidth(); 1476 Result = LHS >> SA; 1477 return true; 1478 } 1479 1480 case BO_LT: Result = LHS < RHS; return true; 1481 case BO_GT: Result = LHS > RHS; return true; 1482 case BO_LE: Result = LHS <= RHS; return true; 1483 case BO_GE: Result = LHS >= RHS; return true; 1484 case BO_EQ: Result = LHS == RHS; return true; 1485 case BO_NE: Result = LHS != RHS; return true; 1486 } 1487} 1488 1489/// Perform the given binary floating-point operation, in-place, on LHS. 1490static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E, 1491 APFloat &LHS, BinaryOperatorKind Opcode, 1492 const APFloat &RHS) { 1493 switch (Opcode) { 1494 default: 1495 Info.Diag(E); 1496 return false; 1497 case BO_Mul: 1498 LHS.multiply(RHS, APFloat::rmNearestTiesToEven); 1499 break; 1500 case BO_Add: 1501 LHS.add(RHS, APFloat::rmNearestTiesToEven); 1502 break; 1503 case BO_Sub: 1504 LHS.subtract(RHS, APFloat::rmNearestTiesToEven); 1505 break; 1506 case BO_Div: 1507 LHS.divide(RHS, APFloat::rmNearestTiesToEven); 1508 break; 1509 } 1510 1511 if (LHS.isInfinity() || LHS.isNaN()) 1512 Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN(); 1513 return true; 1514} 1515 1516/// Cast an lvalue referring to a base subobject to a derived class, by 1517/// truncating the lvalue's path to the given length. 1518static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result, 1519 const RecordDecl *TruncatedType, 1520 unsigned TruncatedElements) { 1521 SubobjectDesignator &D = Result.Designator; 1522 1523 // Check we actually point to a derived class object. 1524 if (TruncatedElements == D.Entries.size()) 1525 return true; 1526 assert(TruncatedElements >= D.MostDerivedPathLength && 1527 "not casting to a derived class"); 1528 if (!Result.checkSubobject(Info, E, CSK_Derived)) 1529 return false; 1530 1531 // Truncate the path to the subobject, and remove any derived-to-base offsets. 1532 const RecordDecl *RD = TruncatedType; 1533 for (unsigned I = TruncatedElements, N = D.Entries.size(); I != N; ++I) { 1534 if (RD->isInvalidDecl()) return false; 1535 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 1536 const CXXRecordDecl *Base = getAsBaseClass(D.Entries[I]); 1537 if (isVirtualBaseClass(D.Entries[I])) 1538 Result.Offset -= Layout.getVBaseClassOffset(Base); 1539 else 1540 Result.Offset -= Layout.getBaseClassOffset(Base); 1541 RD = Base; 1542 } 1543 D.Entries.resize(TruncatedElements); 1544 return true; 1545} 1546 1547static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj, 1548 const CXXRecordDecl *Derived, 1549 const CXXRecordDecl *Base, 1550 const ASTRecordLayout *RL = 0) { 1551 if (!RL) { 1552 if (Derived->isInvalidDecl()) return false; 1553 RL = &Info.Ctx.getASTRecordLayout(Derived); 1554 } 1555 1556 Obj.getLValueOffset() += RL->getBaseClassOffset(Base); 1557 Obj.addDecl(Info, E, Base, /*Virtual*/ false); 1558 return true; 1559} 1560 1561static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj, 1562 const CXXRecordDecl *DerivedDecl, 1563 const CXXBaseSpecifier *Base) { 1564 const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl(); 1565 1566 if (!Base->isVirtual()) 1567 return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl); 1568 1569 SubobjectDesignator &D = Obj.Designator; 1570 if (D.Invalid) 1571 return false; 1572 1573 // Extract most-derived object and corresponding type. 1574 DerivedDecl = D.MostDerivedType->getAsCXXRecordDecl(); 1575 if (!CastToDerivedClass(Info, E, Obj, DerivedDecl, D.MostDerivedPathLength)) 1576 return false; 1577 1578 // Find the virtual base class. 1579 if (DerivedDecl->isInvalidDecl()) return false; 1580 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl); 1581 Obj.getLValueOffset() += Layout.getVBaseClassOffset(BaseDecl); 1582 Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true); 1583 return true; 1584} 1585 1586static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E, 1587 QualType Type, LValue &Result) { 1588 for (CastExpr::path_const_iterator PathI = E->path_begin(), 1589 PathE = E->path_end(); 1590 PathI != PathE; ++PathI) { 1591 if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(), 1592 *PathI)) 1593 return false; 1594 Type = (*PathI)->getType(); 1595 } 1596 return true; 1597} 1598 1599/// Update LVal to refer to the given field, which must be a member of the type 1600/// currently described by LVal. 1601static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal, 1602 const FieldDecl *FD, 1603 const ASTRecordLayout *RL = 0) { 1604 if (!RL) { 1605 if (FD->getParent()->isInvalidDecl()) return false; 1606 RL = &Info.Ctx.getASTRecordLayout(FD->getParent()); 1607 } 1608 1609 unsigned I = FD->getFieldIndex(); 1610 LVal.Offset += Info.Ctx.toCharUnitsFromBits(RL->getFieldOffset(I)); 1611 LVal.addDecl(Info, E, FD); 1612 return true; 1613} 1614 1615/// Update LVal to refer to the given indirect field. 1616static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E, 1617 LValue &LVal, 1618 const IndirectFieldDecl *IFD) { 1619 for (IndirectFieldDecl::chain_iterator C = IFD->chain_begin(), 1620 CE = IFD->chain_end(); C != CE; ++C) 1621 if (!HandleLValueMember(Info, E, LVal, cast<FieldDecl>(*C))) 1622 return false; 1623 return true; 1624} 1625 1626/// Get the size of the given type in char units. 1627static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc, 1628 QualType Type, CharUnits &Size) { 1629 // sizeof(void), __alignof__(void), sizeof(function) = 1 as a gcc 1630 // extension. 1631 if (Type->isVoidType() || Type->isFunctionType()) { 1632 Size = CharUnits::One(); 1633 return true; 1634 } 1635 1636 if (!Type->isConstantSizeType()) { 1637 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2. 1638 // FIXME: Better diagnostic. 1639 Info.Diag(Loc); 1640 return false; 1641 } 1642 1643 Size = Info.Ctx.getTypeSizeInChars(Type); 1644 return true; 1645} 1646 1647/// Update a pointer value to model pointer arithmetic. 1648/// \param Info - Information about the ongoing evaluation. 1649/// \param E - The expression being evaluated, for diagnostic purposes. 1650/// \param LVal - The pointer value to be updated. 1651/// \param EltTy - The pointee type represented by LVal. 1652/// \param Adjustment - The adjustment, in objects of type EltTy, to add. 1653static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E, 1654 LValue &LVal, QualType EltTy, 1655 int64_t Adjustment) { 1656 CharUnits SizeOfPointee; 1657 if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfPointee)) 1658 return false; 1659 1660 // Compute the new offset in the appropriate width. 1661 LVal.Offset += Adjustment * SizeOfPointee; 1662 LVal.adjustIndex(Info, E, Adjustment); 1663 return true; 1664} 1665 1666/// Update an lvalue to refer to a component of a complex number. 1667/// \param Info - Information about the ongoing evaluation. 1668/// \param LVal - The lvalue to be updated. 1669/// \param EltTy - The complex number's component type. 1670/// \param Imag - False for the real component, true for the imaginary. 1671static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E, 1672 LValue &LVal, QualType EltTy, 1673 bool Imag) { 1674 if (Imag) { 1675 CharUnits SizeOfComponent; 1676 if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent)) 1677 return false; 1678 LVal.Offset += SizeOfComponent; 1679 } 1680 LVal.addComplex(Info, E, EltTy, Imag); 1681 return true; 1682} 1683 1684/// Try to evaluate the initializer for a variable declaration. 1685/// 1686/// \param Info Information about the ongoing evaluation. 1687/// \param E An expression to be used when printing diagnostics. 1688/// \param VD The variable whose initializer should be obtained. 1689/// \param Frame The frame in which the variable was created. Must be null 1690/// if this variable is not local to the evaluation. 1691/// \param Result Filled in with a pointer to the value of the variable. 1692static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, 1693 const VarDecl *VD, CallStackFrame *Frame, 1694 APValue *&Result) { 1695 // If this is a parameter to an active constexpr function call, perform 1696 // argument substitution. 1697 if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) { 1698 // Assume arguments of a potential constant expression are unknown 1699 // constant expressions. 1700 if (Info.CheckingPotentialConstantExpression) 1701 return false; 1702 if (!Frame || !Frame->Arguments) { 1703 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr); 1704 return false; 1705 } 1706 Result = &Frame->Arguments[PVD->getFunctionScopeIndex()]; 1707 return true; 1708 } 1709 1710 // If this is a local variable, dig out its value. 1711 if (Frame) { 1712 Result = &Frame->Temporaries[VD]; 1713 // If we've carried on past an unevaluatable local variable initializer, 1714 // we can't go any further. This can happen during potential constant 1715 // expression checking. 1716 return !Result->isUninit(); 1717 } 1718 1719 // Dig out the initializer, and use the declaration which it's attached to. 1720 const Expr *Init = VD->getAnyInitializer(VD); 1721 if (!Init || Init->isValueDependent()) { 1722 // If we're checking a potential constant expression, the variable could be 1723 // initialized later. 1724 if (!Info.CheckingPotentialConstantExpression) 1725 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr); 1726 return false; 1727 } 1728 1729 // If we're currently evaluating the initializer of this declaration, use that 1730 // in-flight value. 1731 if (Info.EvaluatingDecl.dyn_cast<const ValueDecl*>() == VD) { 1732 Result = Info.EvaluatingDeclValue; 1733 return !Result->isUninit(); 1734 } 1735 1736 // Never evaluate the initializer of a weak variable. We can't be sure that 1737 // this is the definition which will be used. 1738 if (VD->isWeak()) { 1739 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr); 1740 return false; 1741 } 1742 1743 // Check that we can fold the initializer. In C++, we will have already done 1744 // this in the cases where it matters for conformance. 1745 SmallVector<PartialDiagnosticAt, 8> Notes; 1746 if (!VD->evaluateValue(Notes)) { 1747 Info.Diag(E, diag::note_constexpr_var_init_non_constant, 1748 Notes.size() + 1) << VD; 1749 Info.Note(VD->getLocation(), diag::note_declared_at); 1750 Info.addNotes(Notes); 1751 return false; 1752 } else if (!VD->checkInitIsICE()) { 1753 Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant, 1754 Notes.size() + 1) << VD; 1755 Info.Note(VD->getLocation(), diag::note_declared_at); 1756 Info.addNotes(Notes); 1757 } 1758 1759 Result = VD->getEvaluatedValue(); 1760 return true; 1761} 1762 1763static bool IsConstNonVolatile(QualType T) { 1764 Qualifiers Quals = T.getQualifiers(); 1765 return Quals.hasConst() && !Quals.hasVolatile(); 1766} 1767 1768/// Get the base index of the given base class within an APValue representing 1769/// the given derived class. 1770static unsigned getBaseIndex(const CXXRecordDecl *Derived, 1771 const CXXRecordDecl *Base) { 1772 Base = Base->getCanonicalDecl(); 1773 unsigned Index = 0; 1774 for (CXXRecordDecl::base_class_const_iterator I = Derived->bases_begin(), 1775 E = Derived->bases_end(); I != E; ++I, ++Index) { 1776 if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == Base) 1777 return Index; 1778 } 1779 1780 llvm_unreachable("base class missing from derived class's bases list"); 1781} 1782 1783/// Extract the value of a character from a string literal. 1784static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit, 1785 uint64_t Index) { 1786 // FIXME: Support PredefinedExpr, ObjCEncodeExpr, MakeStringConstant 1787 const StringLiteral *S = cast<StringLiteral>(Lit); 1788 const ConstantArrayType *CAT = 1789 Info.Ctx.getAsConstantArrayType(S->getType()); 1790 assert(CAT && "string literal isn't an array"); 1791 QualType CharType = CAT->getElementType(); 1792 assert(CharType->isIntegerType() && "unexpected character type"); 1793 1794 APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(), 1795 CharType->isUnsignedIntegerType()); 1796 if (Index < S->getLength()) 1797 Value = S->getCodeUnit(Index); 1798 return Value; 1799} 1800 1801// Expand a string literal into an array of characters. 1802static void expandStringLiteral(EvalInfo &Info, const Expr *Lit, 1803 APValue &Result) { 1804 const StringLiteral *S = cast<StringLiteral>(Lit); 1805 const ConstantArrayType *CAT = 1806 Info.Ctx.getAsConstantArrayType(S->getType()); 1807 assert(CAT && "string literal isn't an array"); 1808 QualType CharType = CAT->getElementType(); 1809 assert(CharType->isIntegerType() && "unexpected character type"); 1810 1811 unsigned Elts = CAT->getSize().getZExtValue(); 1812 Result = APValue(APValue::UninitArray(), 1813 std::min(S->getLength(), Elts), Elts); 1814 APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(), 1815 CharType->isUnsignedIntegerType()); 1816 if (Result.hasArrayFiller()) 1817 Result.getArrayFiller() = APValue(Value); 1818 for (unsigned I = 0, N = Result.getArrayInitializedElts(); I != N; ++I) { 1819 Value = S->getCodeUnit(I); 1820 Result.getArrayInitializedElt(I) = APValue(Value); 1821 } 1822} 1823 1824// Expand an array so that it has more than Index filled elements. 1825static void expandArray(APValue &Array, unsigned Index) { 1826 unsigned Size = Array.getArraySize(); 1827 assert(Index < Size); 1828 1829 // Always at least double the number of elements for which we store a value. 1830 unsigned OldElts = Array.getArrayInitializedElts(); 1831 unsigned NewElts = std::max(Index+1, OldElts * 2); 1832 NewElts = std::min(Size, std::max(NewElts, 8u)); 1833 1834 // Copy the data across. 1835 APValue NewValue(APValue::UninitArray(), NewElts, Size); 1836 for (unsigned I = 0; I != OldElts; ++I) 1837 NewValue.getArrayInitializedElt(I).swap(Array.getArrayInitializedElt(I)); 1838 for (unsigned I = OldElts; I != NewElts; ++I) 1839 NewValue.getArrayInitializedElt(I) = Array.getArrayFiller(); 1840 if (NewValue.hasArrayFiller()) 1841 NewValue.getArrayFiller() = Array.getArrayFiller(); 1842 Array.swap(NewValue); 1843} 1844 1845/// Kinds of access we can perform on an object, for diagnostics. 1846enum AccessKinds { 1847 AK_Read, 1848 AK_Assign, 1849 AK_Increment, 1850 AK_Decrement 1851}; 1852 1853/// A handle to a complete object (an object that is not a subobject of 1854/// another object). 1855struct CompleteObject { 1856 /// The value of the complete object. 1857 APValue *Value; 1858 /// The type of the complete object. 1859 QualType Type; 1860 1861 CompleteObject() : Value(0) {} 1862 CompleteObject(APValue *Value, QualType Type) 1863 : Value(Value), Type(Type) { 1864 assert(Value && "missing value for complete object"); 1865 } 1866 1867 LLVM_EXPLICIT operator bool() const { return Value; } 1868}; 1869 1870/// Find the designated sub-object of an rvalue. 1871template<typename SubobjectHandler> 1872typename SubobjectHandler::result_type 1873findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, 1874 const SubobjectDesignator &Sub, SubobjectHandler &handler) { 1875 if (Sub.Invalid) 1876 // A diagnostic will have already been produced. 1877 return handler.failed(); 1878 if (Sub.isOnePastTheEnd()) { 1879 if (Info.getLangOpts().CPlusPlus11) 1880 Info.Diag(E, diag::note_constexpr_access_past_end) 1881 << handler.AccessKind; 1882 else 1883 Info.Diag(E); 1884 return handler.failed(); 1885 } 1886 if (Sub.Entries.empty()) 1887 return handler.found(*Obj.Value, Obj.Type); 1888 if (Info.CheckingPotentialConstantExpression && Obj.Value->isUninit()) 1889 // This object might be initialized later. 1890 return handler.failed(); 1891 1892 APValue *O = Obj.Value; 1893 QualType ObjType = Obj.Type; 1894 // Walk the designator's path to find the subobject. 1895 for (unsigned I = 0, N = Sub.Entries.size(); I != N; ++I) { 1896 if (ObjType->isArrayType()) { 1897 // Next subobject is an array element. 1898 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(ObjType); 1899 assert(CAT && "vla in literal type?"); 1900 uint64_t Index = Sub.Entries[I].ArrayIndex; 1901 if (CAT->getSize().ule(Index)) { 1902 // Note, it should not be possible to form a pointer with a valid 1903 // designator which points more than one past the end of the array. 1904 if (Info.getLangOpts().CPlusPlus11) 1905 Info.Diag(E, diag::note_constexpr_access_past_end) 1906 << handler.AccessKind; 1907 else 1908 Info.Diag(E); 1909 return handler.failed(); 1910 } 1911 1912 ObjType = CAT->getElementType(); 1913 1914 // An array object is represented as either an Array APValue or as an 1915 // LValue which refers to a string literal. 1916 if (O->isLValue()) { 1917 assert(I == N - 1 && "extracting subobject of character?"); 1918 assert(!O->hasLValuePath() || O->getLValuePath().empty()); 1919 if (handler.AccessKind != AK_Read) 1920 expandStringLiteral(Info, O->getLValueBase().get<const Expr *>(), 1921 *O); 1922 else 1923 return handler.foundString(*O, ObjType, Index); 1924 } 1925 1926 if (O->getArrayInitializedElts() > Index) 1927 O = &O->getArrayInitializedElt(Index); 1928 else if (handler.AccessKind != AK_Read) { 1929 expandArray(*O, Index); 1930 O = &O->getArrayInitializedElt(Index); 1931 } else 1932 O = &O->getArrayFiller(); 1933 } else if (ObjType->isAnyComplexType()) { 1934 // Next subobject is a complex number. 1935 uint64_t Index = Sub.Entries[I].ArrayIndex; 1936 if (Index > 1) { 1937 if (Info.getLangOpts().CPlusPlus11) 1938 Info.Diag(E, diag::note_constexpr_access_past_end) 1939 << handler.AccessKind; 1940 else 1941 Info.Diag(E); 1942 return handler.failed(); 1943 } 1944 1945 bool WasConstQualified = ObjType.isConstQualified(); 1946 ObjType = ObjType->castAs<ComplexType>()->getElementType(); 1947 if (WasConstQualified) 1948 ObjType.addConst(); 1949 1950 assert(I == N - 1 && "extracting subobject of scalar?"); 1951 if (O->isComplexInt()) { 1952 return handler.found(Index ? O->getComplexIntImag() 1953 : O->getComplexIntReal(), ObjType); 1954 } else { 1955 assert(O->isComplexFloat()); 1956 return handler.found(Index ? O->getComplexFloatImag() 1957 : O->getComplexFloatReal(), ObjType); 1958 } 1959 } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) { 1960 if (Field->isMutable() && handler.AccessKind == AK_Read) { 1961 Info.Diag(E, diag::note_constexpr_ltor_mutable, 1) 1962 << Field; 1963 Info.Note(Field->getLocation(), diag::note_declared_at); 1964 return handler.failed(); 1965 } 1966 1967 // Next subobject is a class, struct or union field. 1968 RecordDecl *RD = ObjType->castAs<RecordType>()->getDecl(); 1969 if (RD->isUnion()) { 1970 const FieldDecl *UnionField = O->getUnionField(); 1971 if (!UnionField || 1972 UnionField->getCanonicalDecl() != Field->getCanonicalDecl()) { 1973 Info.Diag(E, diag::note_constexpr_access_inactive_union_member) 1974 << handler.AccessKind << Field << !UnionField << UnionField; 1975 return handler.failed(); 1976 } 1977 O = &O->getUnionValue(); 1978 } else 1979 O = &O->getStructField(Field->getFieldIndex()); 1980 1981 bool WasConstQualified = ObjType.isConstQualified(); 1982 ObjType = Field->getType(); 1983 if (WasConstQualified && !Field->isMutable()) 1984 ObjType.addConst(); 1985 1986 if (ObjType.isVolatileQualified()) { 1987 if (Info.getLangOpts().CPlusPlus) { 1988 // FIXME: Include a description of the path to the volatile subobject. 1989 Info.Diag(E, diag::note_constexpr_access_volatile_obj, 1) 1990 << handler.AccessKind << 2 << Field; 1991 Info.Note(Field->getLocation(), diag::note_declared_at); 1992 } else { 1993 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr); 1994 } 1995 return handler.failed(); 1996 } 1997 } else { 1998 // Next subobject is a base class. 1999 const CXXRecordDecl *Derived = ObjType->getAsCXXRecordDecl(); 2000 const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]); 2001 O = &O->getStructBase(getBaseIndex(Derived, Base)); 2002 2003 bool WasConstQualified = ObjType.isConstQualified(); 2004 ObjType = Info.Ctx.getRecordType(Base); 2005 if (WasConstQualified) 2006 ObjType.addConst(); 2007 } 2008 2009 if (O->isUninit()) { 2010 if (!Info.CheckingPotentialConstantExpression) 2011 Info.Diag(E, diag::note_constexpr_access_uninit) << handler.AccessKind; 2012 return handler.failed(); 2013 } 2014 } 2015 2016 return handler.found(*O, ObjType); 2017} 2018 2019namespace { 2020struct ExtractSubobjectHandler { 2021 EvalInfo &Info; 2022 APValue &Result; 2023 2024 static const AccessKinds AccessKind = AK_Read; 2025 2026 typedef bool result_type; 2027 bool failed() { return false; } 2028 bool found(APValue &Subobj, QualType SubobjType) { 2029 Result = Subobj; 2030 return true; 2031 } 2032 bool found(APSInt &Value, QualType SubobjType) { 2033 Result = APValue(Value); 2034 return true; 2035 } 2036 bool found(APFloat &Value, QualType SubobjType) { 2037 Result = APValue(Value); 2038 return true; 2039 } 2040 bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) { 2041 Result = APValue(extractStringLiteralCharacter( 2042 Info, Subobj.getLValueBase().get<const Expr *>(), Character)); 2043 return true; 2044 } 2045}; 2046} // end anonymous namespace 2047 2048const AccessKinds ExtractSubobjectHandler::AccessKind; 2049 2050/// Extract the designated sub-object of an rvalue. 2051static bool extractSubobject(EvalInfo &Info, const Expr *E, 2052 const CompleteObject &Obj, 2053 const SubobjectDesignator &Sub, 2054 APValue &Result) { 2055 ExtractSubobjectHandler Handler = { Info, Result }; 2056 return findSubobject(Info, E, Obj, Sub, Handler); 2057} 2058 2059namespace { 2060struct ModifySubobjectHandler { 2061 EvalInfo &Info; 2062 APValue &NewVal; 2063 const Expr *E; 2064 2065 typedef bool result_type; 2066 static const AccessKinds AccessKind = AK_Assign; 2067 2068 bool checkConst(QualType QT) { 2069 // Assigning to a const object has undefined behavior. 2070 if (QT.isConstQualified()) { 2071 Info.Diag(E, diag::note_constexpr_modify_const_type) << QT; 2072 return false; 2073 } 2074 return true; 2075 } 2076 2077 bool failed() { return false; } 2078 bool found(APValue &Subobj, QualType SubobjType) { 2079 if (!checkConst(SubobjType)) 2080 return false; 2081 // We've been given ownership of NewVal, so just swap it in. 2082 Subobj.swap(NewVal); 2083 return true; 2084 } 2085 bool found(APSInt &Value, QualType SubobjType) { 2086 if (!checkConst(SubobjType)) 2087 return false; 2088 if (!NewVal.isInt()) { 2089 // Maybe trying to write a cast pointer value into a complex? 2090 Info.Diag(E); 2091 return false; 2092 } 2093 Value = NewVal.getInt(); 2094 return true; 2095 } 2096 bool found(APFloat &Value, QualType SubobjType) { 2097 if (!checkConst(SubobjType)) 2098 return false; 2099 Value = NewVal.getFloat(); 2100 return true; 2101 } 2102 bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) { 2103 llvm_unreachable("shouldn't encounter string elements with ExpandArrays"); 2104 } 2105}; 2106} // end anonymous namespace 2107 2108const AccessKinds ModifySubobjectHandler::AccessKind; 2109 2110/// Update the designated sub-object of an rvalue to the given value. 2111static bool modifySubobject(EvalInfo &Info, const Expr *E, 2112 const CompleteObject &Obj, 2113 const SubobjectDesignator &Sub, 2114 APValue &NewVal) { 2115 ModifySubobjectHandler Handler = { Info, NewVal, E }; 2116 return findSubobject(Info, E, Obj, Sub, Handler); 2117} 2118 2119/// Find the position where two subobject designators diverge, or equivalently 2120/// the length of the common initial subsequence. 2121static unsigned FindDesignatorMismatch(QualType ObjType, 2122 const SubobjectDesignator &A, 2123 const SubobjectDesignator &B, 2124 bool &WasArrayIndex) { 2125 unsigned I = 0, N = std::min(A.Entries.size(), B.Entries.size()); 2126 for (/**/; I != N; ++I) { 2127 if (!ObjType.isNull() && 2128 (ObjType->isArrayType() || ObjType->isAnyComplexType())) { 2129 // Next subobject is an array element. 2130 if (A.Entries[I].ArrayIndex != B.Entries[I].ArrayIndex) { 2131 WasArrayIndex = true; 2132 return I; 2133 } 2134 if (ObjType->isAnyComplexType()) 2135 ObjType = ObjType->castAs<ComplexType>()->getElementType(); 2136 else 2137 ObjType = ObjType->castAsArrayTypeUnsafe()->getElementType(); 2138 } else { 2139 if (A.Entries[I].BaseOrMember != B.Entries[I].BaseOrMember) { 2140 WasArrayIndex = false; 2141 return I; 2142 } 2143 if (const FieldDecl *FD = getAsField(A.Entries[I])) 2144 // Next subobject is a field. 2145 ObjType = FD->getType(); 2146 else 2147 // Next subobject is a base class. 2148 ObjType = QualType(); 2149 } 2150 } 2151 WasArrayIndex = false; 2152 return I; 2153} 2154 2155/// Determine whether the given subobject designators refer to elements of the 2156/// same array object. 2157static bool AreElementsOfSameArray(QualType ObjType, 2158 const SubobjectDesignator &A, 2159 const SubobjectDesignator &B) { 2160 if (A.Entries.size() != B.Entries.size()) 2161 return false; 2162 2163 bool IsArray = A.MostDerivedArraySize != 0; 2164 if (IsArray && A.MostDerivedPathLength != A.Entries.size()) 2165 // A is a subobject of the array element. 2166 return false; 2167 2168 // If A (and B) designates an array element, the last entry will be the array 2169 // index. That doesn't have to match. Otherwise, we're in the 'implicit array 2170 // of length 1' case, and the entire path must match. 2171 bool WasArrayIndex; 2172 unsigned CommonLength = FindDesignatorMismatch(ObjType, A, B, WasArrayIndex); 2173 return CommonLength >= A.Entries.size() - IsArray; 2174} 2175 2176/// Find the complete object to which an LValue refers. 2177CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, 2178 const LValue &LVal, QualType LValType) { 2179 if (!LVal.Base) { 2180 Info.Diag(E, diag::note_constexpr_access_null) << AK; 2181 return CompleteObject(); 2182 } 2183 2184 CallStackFrame *Frame = 0; 2185 if (LVal.CallIndex) { 2186 Frame = Info.getCallFrame(LVal.CallIndex); 2187 if (!Frame) { 2188 Info.Diag(E, diag::note_constexpr_lifetime_ended, 1) 2189 << AK << LVal.Base.is<const ValueDecl*>(); 2190 NoteLValueLocation(Info, LVal.Base); 2191 return CompleteObject(); 2192 } 2193 } 2194 2195 // C++11 DR1311: An lvalue-to-rvalue conversion on a volatile-qualified type 2196 // is not a constant expression (even if the object is non-volatile). We also 2197 // apply this rule to C++98, in order to conform to the expected 'volatile' 2198 // semantics. 2199 if (LValType.isVolatileQualified()) { 2200 if (Info.getLangOpts().CPlusPlus) 2201 Info.Diag(E, diag::note_constexpr_access_volatile_type) 2202 << AK << LValType; 2203 else 2204 Info.Diag(E); 2205 return CompleteObject(); 2206 } 2207 2208 // Compute value storage location and type of base object. 2209 APValue *BaseVal = 0; 2210 QualType BaseType = getType(LVal.Base); 2211 2212 if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl*>()) { 2213 // In C++98, const, non-volatile integers initialized with ICEs are ICEs. 2214 // In C++11, constexpr, non-volatile variables initialized with constant 2215 // expressions are constant expressions too. Inside constexpr functions, 2216 // parameters are constant expressions even if they're non-const. 2217 // In C++1y, objects local to a constant expression (those with a Frame) are 2218 // both readable and writable inside constant expressions. 2219 // In C, such things can also be folded, although they are not ICEs. 2220 const VarDecl *VD = dyn_cast<VarDecl>(D); 2221 if (VD) { 2222 if (const VarDecl *VDef = VD->getDefinition(Info.Ctx)) 2223 VD = VDef; 2224 } 2225 if (!VD || VD->isInvalidDecl()) { 2226 Info.Diag(E); 2227 return CompleteObject(); 2228 } 2229 2230 // Accesses of volatile-qualified objects are not allowed. 2231 if (BaseType.isVolatileQualified()) { 2232 if (Info.getLangOpts().CPlusPlus) { 2233 Info.Diag(E, diag::note_constexpr_access_volatile_obj, 1) 2234 << AK << 1 << VD; 2235 Info.Note(VD->getLocation(), diag::note_declared_at); 2236 } else { 2237 Info.Diag(E); 2238 } 2239 return CompleteObject(); 2240 } 2241 2242 // Unless we're looking at a local variable or argument in a constexpr call, 2243 // the variable we're reading must be const. 2244 if (!Frame) { 2245 if (Info.getLangOpts().CPlusPlus1y && 2246 VD == Info.EvaluatingDecl.dyn_cast<const ValueDecl *>()) { 2247 // OK, we can read and modify an object if we're in the process of 2248 // evaluating its initializer, because its lifetime began in this 2249 // evaluation. 2250 } else if (AK != AK_Read) { 2251 // All the remaining cases only permit reading. 2252 Info.Diag(E, diag::note_constexpr_modify_global); 2253 return CompleteObject(); 2254 } else if (VD->isConstexpr()) { 2255 // OK, we can read this variable. 2256 } else if (BaseType->isIntegralOrEnumerationType()) { 2257 if (!BaseType.isConstQualified()) { 2258 if (Info.getLangOpts().CPlusPlus) { 2259 Info.Diag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD; 2260 Info.Note(VD->getLocation(), diag::note_declared_at); 2261 } else { 2262 Info.Diag(E); 2263 } 2264 return CompleteObject(); 2265 } 2266 } else if (BaseType->isFloatingType() && BaseType.isConstQualified()) { 2267 // We support folding of const floating-point types, in order to make 2268 // static const data members of such types (supported as an extension) 2269 // more useful. 2270 if (Info.getLangOpts().CPlusPlus11) { 2271 Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD; 2272 Info.Note(VD->getLocation(), diag::note_declared_at); 2273 } else { 2274 Info.CCEDiag(E); 2275 } 2276 } else { 2277 // FIXME: Allow folding of values of any literal type in all languages. 2278 if (Info.getLangOpts().CPlusPlus11) { 2279 Info.Diag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD; 2280 Info.Note(VD->getLocation(), diag::note_declared_at); 2281 } else { 2282 Info.Diag(E); 2283 } 2284 return CompleteObject(); 2285 } 2286 } 2287 2288 if (!evaluateVarDeclInit(Info, E, VD, Frame, BaseVal)) 2289 return CompleteObject(); 2290 } else { 2291 const Expr *Base = LVal.Base.dyn_cast<const Expr*>(); 2292 2293 if (!Frame) { 2294 if (const MaterializeTemporaryExpr *MTE = 2295 dyn_cast<MaterializeTemporaryExpr>(Base)) { 2296 assert(MTE->getStorageDuration() == SD_Static && 2297 "should have a frame for a non-global materialized temporary"); 2298 2299 // Per C++1y [expr.const]p2: 2300 // an lvalue-to-rvalue conversion [is not allowed unless it applies to] 2301 // - a [...] glvalue of integral or enumeration type that refers to 2302 // a non-volatile const object [...] 2303 // [...] 2304 // - a [...] glvalue of literal type that refers to a non-volatile 2305 // object whose lifetime began within the evaluation of e. 2306 // 2307 // C++11 misses the 'began within the evaluation of e' check and 2308 // instead allows all temporaries, including things like: 2309 // int &&r = 1; 2310 // int x = ++r; 2311 // constexpr int k = r; 2312 // Therefore we use the C++1y rules in C++11 too. 2313 const ValueDecl *VD = Info.EvaluatingDecl.dyn_cast<const ValueDecl*>(); 2314 const ValueDecl *ED = MTE->getExtendingDecl(); 2315 if (!(BaseType.isConstQualified() && 2316 BaseType->isIntegralOrEnumerationType()) && 2317 !(VD && VD->getCanonicalDecl() == ED->getCanonicalDecl())) { 2318 Info.Diag(E, diag::note_constexpr_access_static_temporary, 1) << AK; 2319 Info.Note(MTE->getExprLoc(), diag::note_constexpr_temporary_here); 2320 return CompleteObject(); 2321 } 2322 2323 BaseVal = Info.Ctx.getMaterializedTemporaryValue(MTE, false); 2324 assert(BaseVal && "got reference to unevaluated temporary"); 2325 } else { 2326 Info.Diag(E); 2327 return CompleteObject(); 2328 } 2329 } else { 2330 BaseVal = &Frame->Temporaries[Base]; 2331 } 2332 2333 // Volatile temporary objects cannot be accessed in constant expressions. 2334 if (BaseType.isVolatileQualified()) { 2335 if (Info.getLangOpts().CPlusPlus) { 2336 Info.Diag(E, diag::note_constexpr_access_volatile_obj, 1) 2337 << AK << 0; 2338 Info.Note(Base->getExprLoc(), diag::note_constexpr_temporary_here); 2339 } else { 2340 Info.Diag(E); 2341 } 2342 return CompleteObject(); 2343 } 2344 } 2345 2346 // During the construction of an object, it is not yet 'const'. 2347 // FIXME: We don't set up EvaluatingDecl for local variables or temporaries, 2348 // and this doesn't do quite the right thing for const subobjects of the 2349 // object under construction. 2350 if (LVal.getLValueBase() == Info.EvaluatingDecl) { 2351 BaseType = Info.Ctx.getCanonicalType(BaseType); 2352 BaseType.removeLocalConst(); 2353 } 2354 2355 // In C++1y, we can't safely access any mutable state when checking a 2356 // potential constant expression. 2357 if (Frame && Info.getLangOpts().CPlusPlus1y && 2358 Info.CheckingPotentialConstantExpression) 2359 return CompleteObject(); 2360 2361 return CompleteObject(BaseVal, BaseType); 2362} 2363 2364/// \brief Perform an lvalue-to-rvalue conversion on the given glvalue. This 2365/// can also be used for 'lvalue-to-lvalue' conversions for looking up the 2366/// glvalue referred to by an entity of reference type. 2367/// 2368/// \param Info - Information about the ongoing evaluation. 2369/// \param Conv - The expression for which we are performing the conversion. 2370/// Used for diagnostics. 2371/// \param Type - The type of the glvalue (before stripping cv-qualifiers in the 2372/// case of a non-class type). 2373/// \param LVal - The glvalue on which we are attempting to perform this action. 2374/// \param RVal - The produced value will be placed here. 2375static bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv, 2376 QualType Type, 2377 const LValue &LVal, APValue &RVal) { 2378 if (LVal.Designator.Invalid) 2379 return false; 2380 2381 // Check for special cases where there is no existing APValue to look at. 2382 const Expr *Base = LVal.Base.dyn_cast<const Expr*>(); 2383 if (!LVal.Designator.Invalid && Base && !LVal.CallIndex && 2384 !Type.isVolatileQualified()) { 2385 if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) { 2386 // In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the 2387 // initializer until now for such expressions. Such an expression can't be 2388 // an ICE in C, so this only matters for fold. 2389 assert(!Info.getLangOpts().CPlusPlus && "lvalue compound literal in c++?"); 2390 if (Type.isVolatileQualified()) { 2391 Info.Diag(Conv); 2392 return false; 2393 } 2394 APValue Lit; 2395 if (!Evaluate(Lit, Info, CLE->getInitializer())) 2396 return false; 2397 CompleteObject LitObj(&Lit, Base->getType()); 2398 return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal); 2399 } else if (isa<StringLiteral>(Base)) { 2400 // We represent a string literal array as an lvalue pointing at the 2401 // corresponding expression, rather than building an array of chars. 2402 // FIXME: Support PredefinedExpr, ObjCEncodeExpr, MakeStringConstant 2403 APValue Str(Base, CharUnits::Zero(), APValue::NoLValuePath(), 0); 2404 CompleteObject StrObj(&Str, Base->getType()); 2405 return extractSubobject(Info, Conv, StrObj, LVal.Designator, RVal); 2406 } 2407 } 2408 2409 CompleteObject Obj = findCompleteObject(Info, Conv, AK_Read, LVal, Type); 2410 return Obj && extractSubobject(Info, Conv, Obj, LVal.Designator, RVal); 2411} 2412 2413/// Perform an assignment of Val to LVal. Takes ownership of Val. 2414static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal, 2415 QualType LValType, APValue &Val) { 2416 if (LVal.Designator.Invalid) 2417 return false; 2418 2419 if (!Info.getLangOpts().CPlusPlus1y) { 2420 Info.Diag(E); 2421 return false; 2422 } 2423 2424 CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType); 2425 return Obj && modifySubobject(Info, E, Obj, LVal.Designator, Val); 2426} 2427 2428static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T) { 2429 return T->isSignedIntegerType() && 2430 Ctx.getIntWidth(T) >= Ctx.getIntWidth(Ctx.IntTy); 2431} 2432 2433namespace { 2434struct CompoundAssignSubobjectHandler { 2435 EvalInfo &Info; 2436 const Expr *E; 2437 QualType PromotedLHSType; 2438 BinaryOperatorKind Opcode; 2439 const APValue &RHS; 2440 2441 static const AccessKinds AccessKind = AK_Assign; 2442 2443 typedef bool result_type; 2444 2445 bool checkConst(QualType QT) { 2446 // Assigning to a const object has undefined behavior. 2447 if (QT.isConstQualified()) { 2448 Info.Diag(E, diag::note_constexpr_modify_const_type) << QT; 2449 return false; 2450 } 2451 return true; 2452 } 2453 2454 bool failed() { return false; } 2455 bool found(APValue &Subobj, QualType SubobjType) { 2456 switch (Subobj.getKind()) { 2457 case APValue::Int: 2458 return found(Subobj.getInt(), SubobjType); 2459 case APValue::Float: 2460 return found(Subobj.getFloat(), SubobjType); 2461 case APValue::ComplexInt: 2462 case APValue::ComplexFloat: 2463 // FIXME: Implement complex compound assignment. 2464 Info.Diag(E); 2465 return false; 2466 case APValue::LValue: 2467 return foundPointer(Subobj, SubobjType); 2468 default: 2469 // FIXME: can this happen? 2470 Info.Diag(E); 2471 return false; 2472 } 2473 } 2474 bool found(APSInt &Value, QualType SubobjType) { 2475 if (!checkConst(SubobjType)) 2476 return false; 2477 2478 if (!SubobjType->isIntegerType() || !RHS.isInt()) { 2479 // We don't support compound assignment on integer-cast-to-pointer 2480 // values. 2481 Info.Diag(E); 2482 return false; 2483 } 2484 2485 APSInt LHS = HandleIntToIntCast(Info, E, PromotedLHSType, 2486 SubobjType, Value); 2487 if (!handleIntIntBinOp(Info, E, LHS, Opcode, RHS.getInt(), LHS)) 2488 return false; 2489 Value = HandleIntToIntCast(Info, E, SubobjType, PromotedLHSType, LHS); 2490 return true; 2491 } 2492 bool found(APFloat &Value, QualType SubobjType) { 2493 return checkConst(SubobjType) && 2494 HandleFloatToFloatCast(Info, E, SubobjType, PromotedLHSType, 2495 Value) && 2496 handleFloatFloatBinOp(Info, E, Value, Opcode, RHS.getFloat()) && 2497 HandleFloatToFloatCast(Info, E, PromotedLHSType, SubobjType, Value); 2498 } 2499 bool foundPointer(APValue &Subobj, QualType SubobjType) { 2500 if (!checkConst(SubobjType)) 2501 return false; 2502 2503 QualType PointeeType; 2504 if (const PointerType *PT = SubobjType->getAs<PointerType>()) 2505 PointeeType = PT->getPointeeType(); 2506 2507 if (PointeeType.isNull() || !RHS.isInt() || 2508 (Opcode != BO_Add && Opcode != BO_Sub)) { 2509 Info.Diag(E); 2510 return false; 2511 } 2512 2513 int64_t Offset = getExtValue(RHS.getInt()); 2514 if (Opcode == BO_Sub) 2515 Offset = -Offset; 2516 2517 LValue LVal; 2518 LVal.setFrom(Info.Ctx, Subobj); 2519 if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType, Offset)) 2520 return false; 2521 LVal.moveInto(Subobj); 2522 return true; 2523 } 2524 bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) { 2525 llvm_unreachable("shouldn't encounter string elements here"); 2526 } 2527}; 2528} // end anonymous namespace 2529 2530const AccessKinds CompoundAssignSubobjectHandler::AccessKind; 2531 2532/// Perform a compound assignment of LVal <op>= RVal. 2533static bool handleCompoundAssignment( 2534 EvalInfo &Info, const Expr *E, 2535 const LValue &LVal, QualType LValType, QualType PromotedLValType, 2536 BinaryOperatorKind Opcode, const APValue &RVal) { 2537 if (LVal.Designator.Invalid) 2538 return false; 2539 2540 if (!Info.getLangOpts().CPlusPlus1y) { 2541 Info.Diag(E); 2542 return false; 2543 } 2544 2545 CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType); 2546 CompoundAssignSubobjectHandler Handler = { Info, E, PromotedLValType, Opcode, 2547 RVal }; 2548 return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler); 2549} 2550 2551namespace { 2552struct IncDecSubobjectHandler { 2553 EvalInfo &Info; 2554 const Expr *E; 2555 AccessKinds AccessKind; 2556 APValue *Old; 2557 2558 typedef bool result_type; 2559 2560 bool checkConst(QualType QT) { 2561 // Assigning to a const object has undefined behavior. 2562 if (QT.isConstQualified()) { 2563 Info.Diag(E, diag::note_constexpr_modify_const_type) << QT; 2564 return false; 2565 } 2566 return true; 2567 } 2568 2569 bool failed() { return false; } 2570 bool found(APValue &Subobj, QualType SubobjType) { 2571 // Stash the old value. Also clear Old, so we don't clobber it later 2572 // if we're post-incrementing a complex. 2573 if (Old) { 2574 *Old = Subobj; 2575 Old = 0; 2576 } 2577 2578 switch (Subobj.getKind()) { 2579 case APValue::Int: 2580 return found(Subobj.getInt(), SubobjType); 2581 case APValue::Float: 2582 return found(Subobj.getFloat(), SubobjType); 2583 case APValue::ComplexInt: 2584 return found(Subobj.getComplexIntReal(), 2585 SubobjType->castAs<ComplexType>()->getElementType() 2586 .withCVRQualifiers(SubobjType.getCVRQualifiers())); 2587 case APValue::ComplexFloat: 2588 return found(Subobj.getComplexFloatReal(), 2589 SubobjType->castAs<ComplexType>()->getElementType() 2590 .withCVRQualifiers(SubobjType.getCVRQualifiers())); 2591 case APValue::LValue: 2592 return foundPointer(Subobj, SubobjType); 2593 default: 2594 // FIXME: can this happen? 2595 Info.Diag(E); 2596 return false; 2597 } 2598 } 2599 bool found(APSInt &Value, QualType SubobjType) { 2600 if (!checkConst(SubobjType)) 2601 return false; 2602 2603 if (!SubobjType->isIntegerType()) { 2604 // We don't support increment / decrement on integer-cast-to-pointer 2605 // values. 2606 Info.Diag(E); 2607 return false; 2608 } 2609 2610 if (Old) *Old = APValue(Value); 2611 2612 // bool arithmetic promotes to int, and the conversion back to bool 2613 // doesn't reduce mod 2^n, so special-case it. 2614 if (SubobjType->isBooleanType()) { 2615 if (AccessKind == AK_Increment) 2616 Value = 1; 2617 else 2618 Value = !Value; 2619 return true; 2620 } 2621 2622 bool WasNegative = Value.isNegative(); 2623 if (AccessKind == AK_Increment) { 2624 ++Value; 2625 2626 if (!WasNegative && Value.isNegative() && 2627 isOverflowingIntegerType(Info.Ctx, SubobjType)) { 2628 APSInt ActualValue(Value, /*IsUnsigned*/true); 2629 HandleOverflow(Info, E, ActualValue, SubobjType); 2630 } 2631 } else { 2632 --Value; 2633 2634 if (WasNegative && !Value.isNegative() && 2635 isOverflowingIntegerType(Info.Ctx, SubobjType)) { 2636 unsigned BitWidth = Value.getBitWidth(); 2637 APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/false); 2638 ActualValue.setBit(BitWidth); 2639 HandleOverflow(Info, E, ActualValue, SubobjType); 2640 } 2641 } 2642 return true; 2643 } 2644 bool found(APFloat &Value, QualType SubobjType) { 2645 if (!checkConst(SubobjType)) 2646 return false; 2647 2648 if (Old) *Old = APValue(Value); 2649 2650 APFloat One(Value.getSemantics(), 1); 2651 if (AccessKind == AK_Increment) 2652 Value.add(One, APFloat::rmNearestTiesToEven); 2653 else 2654 Value.subtract(One, APFloat::rmNearestTiesToEven); 2655 return true; 2656 } 2657 bool foundPointer(APValue &Subobj, QualType SubobjType) { 2658 if (!checkConst(SubobjType)) 2659 return false; 2660 2661 QualType PointeeType; 2662 if (const PointerType *PT = SubobjType->getAs<PointerType>()) 2663 PointeeType = PT->getPointeeType(); 2664 else { 2665 Info.Diag(E); 2666 return false; 2667 } 2668 2669 LValue LVal; 2670 LVal.setFrom(Info.Ctx, Subobj); 2671 if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType, 2672 AccessKind == AK_Increment ? 1 : -1)) 2673 return false; 2674 LVal.moveInto(Subobj); 2675 return true; 2676 } 2677 bool foundString(APValue &Subobj, QualType SubobjType, uint64_t Character) { 2678 llvm_unreachable("shouldn't encounter string elements here"); 2679 } 2680}; 2681} // end anonymous namespace 2682 2683/// Perform an increment or decrement on LVal. 2684static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal, 2685 QualType LValType, bool IsIncrement, APValue *Old) { 2686 if (LVal.Designator.Invalid) 2687 return false; 2688 2689 if (!Info.getLangOpts().CPlusPlus1y) { 2690 Info.Diag(E); 2691 return false; 2692 } 2693 2694 AccessKinds AK = IsIncrement ? AK_Increment : AK_Decrement; 2695 CompleteObject Obj = findCompleteObject(Info, E, AK, LVal, LValType); 2696 IncDecSubobjectHandler Handler = { Info, E, AK, Old }; 2697 return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler); 2698} 2699 2700/// Build an lvalue for the object argument of a member function call. 2701static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object, 2702 LValue &This) { 2703 if (Object->getType()->isPointerType()) 2704 return EvaluatePointer(Object, This, Info); 2705 2706 if (Object->isGLValue()) 2707 return EvaluateLValue(Object, This, Info); 2708 2709 if (Object->getType()->isLiteralType(Info.Ctx)) 2710 return EvaluateTemporary(Object, This, Info); 2711 2712 return false; 2713} 2714 2715/// HandleMemberPointerAccess - Evaluate a member access operation and build an 2716/// lvalue referring to the result. 2717/// 2718/// \param Info - Information about the ongoing evaluation. 2719/// \param LV - An lvalue referring to the base of the member pointer. 2720/// \param RHS - The member pointer expression. 2721/// \param IncludeMember - Specifies whether the member itself is included in 2722/// the resulting LValue subobject designator. This is not possible when 2723/// creating a bound member function. 2724/// \return The field or method declaration to which the member pointer refers, 2725/// or 0 if evaluation fails. 2726static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info, 2727 QualType LVType, 2728 LValue &LV, 2729 const Expr *RHS, 2730 bool IncludeMember = true) { 2731 MemberPtr MemPtr; 2732 if (!EvaluateMemberPointer(RHS, MemPtr, Info)) 2733 return 0; 2734 2735 // C++11 [expr.mptr.oper]p6: If the second operand is the null pointer to 2736 // member value, the behavior is undefined. 2737 if (!MemPtr.getDecl()) { 2738 // FIXME: Specific diagnostic. 2739 Info.Diag(RHS); 2740 return 0; 2741 } 2742 2743 if (MemPtr.isDerivedMember()) { 2744 // This is a member of some derived class. Truncate LV appropriately. 2745 // The end of the derived-to-base path for the base object must match the 2746 // derived-to-base path for the member pointer. 2747 if (LV.Designator.MostDerivedPathLength + MemPtr.Path.size() > 2748 LV.Designator.Entries.size()) { 2749 Info.Diag(RHS); 2750 return 0; 2751 } 2752 unsigned PathLengthToMember = 2753 LV.Designator.Entries.size() - MemPtr.Path.size(); 2754 for (unsigned I = 0, N = MemPtr.Path.size(); I != N; ++I) { 2755 const CXXRecordDecl *LVDecl = getAsBaseClass( 2756 LV.Designator.Entries[PathLengthToMember + I]); 2757 const CXXRecordDecl *MPDecl = MemPtr.Path[I]; 2758 if (LVDecl->getCanonicalDecl() != MPDecl->getCanonicalDecl()) { 2759 Info.Diag(RHS); 2760 return 0; 2761 } 2762 } 2763 2764 // Truncate the lvalue to the appropriate derived class. 2765 if (!CastToDerivedClass(Info, RHS, LV, MemPtr.getContainingRecord(), 2766 PathLengthToMember)) 2767 return 0; 2768 } else if (!MemPtr.Path.empty()) { 2769 // Extend the LValue path with the member pointer's path. 2770 LV.Designator.Entries.reserve(LV.Designator.Entries.size() + 2771 MemPtr.Path.size() + IncludeMember); 2772 2773 // Walk down to the appropriate base class. 2774 if (const PointerType *PT = LVType->getAs<PointerType>()) 2775 LVType = PT->getPointeeType(); 2776 const CXXRecordDecl *RD = LVType->getAsCXXRecordDecl(); 2777 assert(RD && "member pointer access on non-class-type expression"); 2778 // The first class in the path is that of the lvalue. 2779 for (unsigned I = 1, N = MemPtr.Path.size(); I != N; ++I) { 2780 const CXXRecordDecl *Base = MemPtr.Path[N - I - 1]; 2781 if (!HandleLValueDirectBase(Info, RHS, LV, RD, Base)) 2782 return 0; 2783 RD = Base; 2784 } 2785 // Finally cast to the class containing the member. 2786 if (!HandleLValueDirectBase(Info, RHS, LV, RD, 2787 MemPtr.getContainingRecord())) 2788 return 0; 2789 } 2790 2791 // Add the member. Note that we cannot build bound member functions here. 2792 if (IncludeMember) { 2793 if (const FieldDecl *FD = dyn_cast<FieldDecl>(MemPtr.getDecl())) { 2794 if (!HandleLValueMember(Info, RHS, LV, FD)) 2795 return 0; 2796 } else if (const IndirectFieldDecl *IFD = 2797 dyn_cast<IndirectFieldDecl>(MemPtr.getDecl())) { 2798 if (!HandleLValueIndirectMember(Info, RHS, LV, IFD)) 2799 return 0; 2800 } else { 2801 llvm_unreachable("can't construct reference to bound member function"); 2802 } 2803 } 2804 2805 return MemPtr.getDecl(); 2806} 2807 2808static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info, 2809 const BinaryOperator *BO, 2810 LValue &LV, 2811 bool IncludeMember = true) { 2812 assert(BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI); 2813 2814 if (!EvaluateObjectArgument(Info, BO->getLHS(), LV)) { 2815 if (Info.keepEvaluatingAfterFailure()) { 2816 MemberPtr MemPtr; 2817 EvaluateMemberPointer(BO->getRHS(), MemPtr, Info); 2818 } 2819 return 0; 2820 } 2821 2822 return HandleMemberPointerAccess(Info, BO->getLHS()->getType(), LV, 2823 BO->getRHS(), IncludeMember); 2824} 2825 2826/// HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on 2827/// the provided lvalue, which currently refers to the base object. 2828static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E, 2829 LValue &Result) { 2830 SubobjectDesignator &D = Result.Designator; 2831 if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived)) 2832 return false; 2833 2834 QualType TargetQT = E->getType(); 2835 if (const PointerType *PT = TargetQT->getAs<PointerType>()) 2836 TargetQT = PT->getPointeeType(); 2837 2838 // Check this cast lands within the final derived-to-base subobject path. 2839 if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) { 2840 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast) 2841 << D.MostDerivedType << TargetQT; 2842 return false; 2843 } 2844 2845 // Check the type of the final cast. We don't need to check the path, 2846 // since a cast can only be formed if the path is unique. 2847 unsigned NewEntriesSize = D.Entries.size() - E->path_size(); 2848 const CXXRecordDecl *TargetType = TargetQT->getAsCXXRecordDecl(); 2849 const CXXRecordDecl *FinalType; 2850 if (NewEntriesSize == D.MostDerivedPathLength) 2851 FinalType = D.MostDerivedType->getAsCXXRecordDecl(); 2852 else 2853 FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]); 2854 if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) { 2855 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast) 2856 << D.MostDerivedType << TargetQT; 2857 return false; 2858 } 2859 2860 // Truncate the lvalue to the appropriate derived class. 2861 return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize); 2862} 2863 2864namespace { 2865enum EvalStmtResult { 2866 /// Evaluation failed. 2867 ESR_Failed, 2868 /// Hit a 'return' statement. 2869 ESR_Returned, 2870 /// Evaluation succeeded. 2871 ESR_Succeeded, 2872 /// Hit a 'continue' statement. 2873 ESR_Continue, 2874 /// Hit a 'break' statement. 2875 ESR_Break, 2876 /// Still scanning for 'case' or 'default' statement. 2877 ESR_CaseNotFound 2878}; 2879} 2880 2881static bool EvaluateDecl(EvalInfo &Info, const Decl *D) { 2882 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 2883 // We don't need to evaluate the initializer for a static local. 2884 if (!VD->hasLocalStorage()) 2885 return true; 2886 2887 LValue Result; 2888 Result.set(VD, Info.CurrentCall->Index); 2889 APValue &Val = Info.CurrentCall->Temporaries[VD]; 2890 2891 if (!EvaluateInPlace(Val, Info, Result, VD->getInit())) { 2892 // Wipe out any partially-computed value, to allow tracking that this 2893 // evaluation failed. 2894 Val = APValue(); 2895 return false; 2896 } 2897 } 2898 2899 return true; 2900} 2901 2902/// Evaluate a condition (either a variable declaration or an expression). 2903static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl, 2904 const Expr *Cond, bool &Result) { 2905 if (CondDecl && !EvaluateDecl(Info, CondDecl)) 2906 return false; 2907 return EvaluateAsBooleanCondition(Cond, Result, Info); 2908} 2909 2910static EvalStmtResult EvaluateStmt(APValue &Result, EvalInfo &Info, 2911 const Stmt *S, const SwitchCase *SC = 0); 2912 2913/// Evaluate the body of a loop, and translate the result as appropriate. 2914static EvalStmtResult EvaluateLoopBody(APValue &Result, EvalInfo &Info, 2915 const Stmt *Body, 2916 const SwitchCase *Case = 0) { 2917 switch (EvalStmtResult ESR = EvaluateStmt(Result, Info, Body, Case)) { 2918 case ESR_Break: 2919 return ESR_Succeeded; 2920 case ESR_Succeeded: 2921 case ESR_Continue: 2922 return ESR_Continue; 2923 case ESR_Failed: 2924 case ESR_Returned: 2925 case ESR_CaseNotFound: 2926 return ESR; 2927 } 2928 llvm_unreachable("Invalid EvalStmtResult!"); 2929} 2930 2931/// Evaluate a switch statement. 2932static EvalStmtResult EvaluateSwitch(APValue &Result, EvalInfo &Info, 2933 const SwitchStmt *SS) { 2934 // Evaluate the switch condition. 2935 if (SS->getConditionVariable() && 2936 !EvaluateDecl(Info, SS->getConditionVariable())) 2937 return ESR_Failed; 2938 APSInt Value; 2939 if (!EvaluateInteger(SS->getCond(), Value, Info)) 2940 return ESR_Failed; 2941 2942 // Find the switch case corresponding to the value of the condition. 2943 // FIXME: Cache this lookup. 2944 const SwitchCase *Found = 0; 2945 for (const SwitchCase *SC = SS->getSwitchCaseList(); SC; 2946 SC = SC->getNextSwitchCase()) { 2947 if (isa<DefaultStmt>(SC)) { 2948 Found = SC; 2949 continue; 2950 } 2951 2952 const CaseStmt *CS = cast<CaseStmt>(SC); 2953 APSInt LHS = CS->getLHS()->EvaluateKnownConstInt(Info.Ctx); 2954 APSInt RHS = CS->getRHS() ? CS->getRHS()->EvaluateKnownConstInt(Info.Ctx) 2955 : LHS; 2956 if (LHS <= Value && Value <= RHS) { 2957 Found = SC; 2958 break; 2959 } 2960 } 2961 2962 if (!Found) 2963 return ESR_Succeeded; 2964 2965 // Search the switch body for the switch case and evaluate it from there. 2966 switch (EvalStmtResult ESR = EvaluateStmt(Result, Info, SS->getBody(), Found)) { 2967 case ESR_Break: 2968 return ESR_Succeeded; 2969 case ESR_Succeeded: 2970 case ESR_Continue: 2971 case ESR_Failed: 2972 case ESR_Returned: 2973 return ESR; 2974 case ESR_CaseNotFound: 2975 llvm_unreachable("couldn't find switch case"); 2976 } 2977 llvm_unreachable("Invalid EvalStmtResult!"); 2978} 2979 2980// Evaluate a statement. 2981static EvalStmtResult EvaluateStmt(APValue &Result, EvalInfo &Info, 2982 const Stmt *S, const SwitchCase *Case) { 2983 if (!Info.nextStep(S)) 2984 return ESR_Failed; 2985 2986 // If we're hunting down a 'case' or 'default' label, recurse through 2987 // substatements until we hit the label. 2988 if (Case) { 2989 // FIXME: We don't start the lifetime of objects whose initialization we 2990 // jump over. However, such objects must be of class type with a trivial 2991 // default constructor that initialize all subobjects, so must be empty, 2992 // so this almost never matters. 2993 switch (S->getStmtClass()) { 2994 case Stmt::CompoundStmtClass: 2995 // FIXME: Precompute which substatement of a compound statement we 2996 // would jump to, and go straight there rather than performing a 2997 // linear scan each time. 2998 case Stmt::LabelStmtClass: 2999 case Stmt::AttributedStmtClass: 3000 case Stmt::DoStmtClass: 3001 break; 3002 3003 case Stmt::CaseStmtClass: 3004 case Stmt::DefaultStmtClass: 3005 if (Case == S) 3006 Case = 0; 3007 break; 3008 3009 case Stmt::IfStmtClass: { 3010 // FIXME: Precompute which side of an 'if' we would jump to, and go 3011 // straight there rather than scanning both sides. 3012 const IfStmt *IS = cast<IfStmt>(S); 3013 EvalStmtResult ESR = EvaluateStmt(Result, Info, IS->getThen(), Case); 3014 if (ESR != ESR_CaseNotFound || !IS->getElse()) 3015 return ESR; 3016 return EvaluateStmt(Result, Info, IS->getElse(), Case); 3017 } 3018 3019 case Stmt::WhileStmtClass: { 3020 EvalStmtResult ESR = 3021 EvaluateLoopBody(Result, Info, cast<WhileStmt>(S)->getBody(), Case); 3022 if (ESR != ESR_Continue) 3023 return ESR; 3024 break; 3025 } 3026 3027 case Stmt::ForStmtClass: { 3028 const ForStmt *FS = cast<ForStmt>(S); 3029 EvalStmtResult ESR = 3030 EvaluateLoopBody(Result, Info, FS->getBody(), Case); 3031 if (ESR != ESR_Continue) 3032 return ESR; 3033 if (FS->getInc() && !EvaluateIgnoredValue(Info, FS->getInc())) 3034 return ESR_Failed; 3035 break; 3036 } 3037 3038 case Stmt::DeclStmtClass: 3039 // FIXME: If the variable has initialization that can't be jumped over, 3040 // bail out of any immediately-surrounding compound-statement too. 3041 default: 3042 return ESR_CaseNotFound; 3043 } 3044 } 3045 3046 // FIXME: Mark all temporaries in the current frame as destroyed at 3047 // the end of each full-expression. 3048 switch (S->getStmtClass()) { 3049 default: 3050 if (const Expr *E = dyn_cast<Expr>(S)) { 3051 // Don't bother evaluating beyond an expression-statement which couldn't 3052 // be evaluated. 3053 if (!EvaluateIgnoredValue(Info, E)) 3054 return ESR_Failed; 3055 return ESR_Succeeded; 3056 } 3057 3058 Info.Diag(S->getLocStart()); 3059 return ESR_Failed; 3060 3061 case Stmt::NullStmtClass: 3062 return ESR_Succeeded; 3063 3064 case Stmt::DeclStmtClass: { 3065 const DeclStmt *DS = cast<DeclStmt>(S); 3066 for (DeclStmt::const_decl_iterator DclIt = DS->decl_begin(), 3067 DclEnd = DS->decl_end(); DclIt != DclEnd; ++DclIt) 3068 if (!EvaluateDecl(Info, *DclIt) && !Info.keepEvaluatingAfterFailure()) 3069 return ESR_Failed; 3070 return ESR_Succeeded; 3071 } 3072 3073 case Stmt::ReturnStmtClass: { 3074 const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue(); 3075 if (RetExpr && !Evaluate(Result, Info, RetExpr)) 3076 return ESR_Failed; 3077 return ESR_Returned; 3078 } 3079 3080 case Stmt::CompoundStmtClass: { 3081 const CompoundStmt *CS = cast<CompoundStmt>(S); 3082 for (CompoundStmt::const_body_iterator BI = CS->body_begin(), 3083 BE = CS->body_end(); BI != BE; ++BI) { 3084 EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI, Case); 3085 if (ESR == ESR_Succeeded) 3086 Case = 0; 3087 else if (ESR != ESR_CaseNotFound) 3088 return ESR; 3089 } 3090 return Case ? ESR_CaseNotFound : ESR_Succeeded; 3091 } 3092 3093 case Stmt::IfStmtClass: { 3094 const IfStmt *IS = cast<IfStmt>(S); 3095 3096 // Evaluate the condition, as either a var decl or as an expression. 3097 bool Cond; 3098 if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond)) 3099 return ESR_Failed; 3100 3101 if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) { 3102 EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt); 3103 if (ESR != ESR_Succeeded) 3104 return ESR; 3105 } 3106 return ESR_Succeeded; 3107 } 3108 3109 case Stmt::WhileStmtClass: { 3110 const WhileStmt *WS = cast<WhileStmt>(S); 3111 while (true) { 3112 bool Continue; 3113 if (!EvaluateCond(Info, WS->getConditionVariable(), WS->getCond(), 3114 Continue)) 3115 return ESR_Failed; 3116 if (!Continue) 3117 break; 3118 3119 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, WS->getBody()); 3120 if (ESR != ESR_Continue) 3121 return ESR; 3122 } 3123 return ESR_Succeeded; 3124 } 3125 3126 case Stmt::DoStmtClass: { 3127 const DoStmt *DS = cast<DoStmt>(S); 3128 bool Continue; 3129 do { 3130 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, DS->getBody(), Case); 3131 if (ESR != ESR_Continue) 3132 return ESR; 3133 Case = 0; 3134 3135 if (!EvaluateAsBooleanCondition(DS->getCond(), Continue, Info)) 3136 return ESR_Failed; 3137 } while (Continue); 3138 return ESR_Succeeded; 3139 } 3140 3141 case Stmt::ForStmtClass: { 3142 const ForStmt *FS = cast<ForStmt>(S); 3143 if (FS->getInit()) { 3144 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit()); 3145 if (ESR != ESR_Succeeded) 3146 return ESR; 3147 } 3148 while (true) { 3149 bool Continue = true; 3150 if (FS->getCond() && !EvaluateCond(Info, FS->getConditionVariable(), 3151 FS->getCond(), Continue)) 3152 return ESR_Failed; 3153 if (!Continue) 3154 break; 3155 3156 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, FS->getBody()); 3157 if (ESR != ESR_Continue) 3158 return ESR; 3159 3160 if (FS->getInc() && !EvaluateIgnoredValue(Info, FS->getInc())) 3161 return ESR_Failed; 3162 } 3163 return ESR_Succeeded; 3164 } 3165 3166 case Stmt::CXXForRangeStmtClass: { 3167 const CXXForRangeStmt *FS = cast<CXXForRangeStmt>(S); 3168 3169 // Initialize the __range variable. 3170 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getRangeStmt()); 3171 if (ESR != ESR_Succeeded) 3172 return ESR; 3173 3174 // Create the __begin and __end iterators. 3175 ESR = EvaluateStmt(Result, Info, FS->getBeginEndStmt()); 3176 if (ESR != ESR_Succeeded) 3177 return ESR; 3178 3179 while (true) { 3180 // Condition: __begin != __end. 3181 bool Continue = true; 3182 if (!EvaluateAsBooleanCondition(FS->getCond(), Continue, Info)) 3183 return ESR_Failed; 3184 if (!Continue) 3185 break; 3186 3187 // User's variable declaration, initialized by *__begin. 3188 ESR = EvaluateStmt(Result, Info, FS->getLoopVarStmt()); 3189 if (ESR != ESR_Succeeded) 3190 return ESR; 3191 3192 // Loop body. 3193 ESR = EvaluateLoopBody(Result, Info, FS->getBody()); 3194 if (ESR != ESR_Continue) 3195 return ESR; 3196 3197 // Increment: ++__begin 3198 if (!EvaluateIgnoredValue(Info, FS->getInc())) 3199 return ESR_Failed; 3200 } 3201 3202 return ESR_Succeeded; 3203 } 3204 3205 case Stmt::SwitchStmtClass: 3206 return EvaluateSwitch(Result, Info, cast<SwitchStmt>(S)); 3207 3208 case Stmt::ContinueStmtClass: 3209 return ESR_Continue; 3210 3211 case Stmt::BreakStmtClass: 3212 return ESR_Break; 3213 3214 case Stmt::LabelStmtClass: 3215 return EvaluateStmt(Result, Info, cast<LabelStmt>(S)->getSubStmt(), Case); 3216 3217 case Stmt::AttributedStmtClass: 3218 // As a general principle, C++11 attributes can be ignored without 3219 // any semantic impact. 3220 return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(), 3221 Case); 3222 3223 case Stmt::CaseStmtClass: 3224 case Stmt::DefaultStmtClass: 3225 return EvaluateStmt(Result, Info, cast<SwitchCase>(S)->getSubStmt(), Case); 3226 } 3227} 3228 3229/// CheckTrivialDefaultConstructor - Check whether a constructor is a trivial 3230/// default constructor. If so, we'll fold it whether or not it's marked as 3231/// constexpr. If it is marked as constexpr, we will never implicitly define it, 3232/// so we need special handling. 3233static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc, 3234 const CXXConstructorDecl *CD, 3235 bool IsValueInitialization) { 3236 if (!CD->isTrivial() || !CD->isDefaultConstructor()) 3237 return false; 3238 3239 // Value-initialization does not call a trivial default constructor, so such a 3240 // call is a core constant expression whether or not the constructor is 3241 // constexpr. 3242 if (!CD->isConstexpr() && !IsValueInitialization) { 3243 if (Info.getLangOpts().CPlusPlus11) { 3244 // FIXME: If DiagDecl is an implicitly-declared special member function, 3245 // we should be much more explicit about why it's not constexpr. 3246 Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1) 3247 << /*IsConstexpr*/0 << /*IsConstructor*/1 << CD; 3248 Info.Note(CD->getLocation(), diag::note_declared_at); 3249 } else { 3250 Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr); 3251 } 3252 } 3253 return true; 3254} 3255 3256/// CheckConstexprFunction - Check that a function can be called in a constant 3257/// expression. 3258static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc, 3259 const FunctionDecl *Declaration, 3260 const FunctionDecl *Definition) { 3261 // Potential constant expressions can contain calls to declared, but not yet 3262 // defined, constexpr functions. 3263 if (Info.CheckingPotentialConstantExpression && !Definition && 3264 Declaration->isConstexpr()) 3265 return false; 3266 3267 // Bail out with no diagnostic if the function declaration itself is invalid. 3268 // We will have produced a relevant diagnostic while parsing it. 3269 if (Declaration->isInvalidDecl()) 3270 return false; 3271 3272 // Can we evaluate this function call? 3273 if (Definition && Definition->isConstexpr() && !Definition->isInvalidDecl()) 3274 return true; 3275 3276 if (Info.getLangOpts().CPlusPlus11) { 3277 const FunctionDecl *DiagDecl = Definition ? Definition : Declaration; 3278 // FIXME: If DiagDecl is an implicitly-declared special member function, we 3279 // should be much more explicit about why it's not constexpr. 3280 Info.Diag(CallLoc, diag::note_constexpr_invalid_function, 1) 3281 << DiagDecl->isConstexpr() << isa<CXXConstructorDecl>(DiagDecl) 3282 << DiagDecl; 3283 Info.Note(DiagDecl->getLocation(), diag::note_declared_at); 3284 } else { 3285 Info.Diag(CallLoc, diag::note_invalid_subexpr_in_const_expr); 3286 } 3287 return false; 3288} 3289 3290namespace { 3291typedef SmallVector<APValue, 8> ArgVector; 3292} 3293 3294/// EvaluateArgs - Evaluate the arguments to a function call. 3295static bool EvaluateArgs(ArrayRef<const Expr*> Args, ArgVector &ArgValues, 3296 EvalInfo &Info) { 3297 bool Success = true; 3298 for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end(); 3299 I != E; ++I) { 3300 if (!Evaluate(ArgValues[I - Args.begin()], Info, *I)) { 3301 // If we're checking for a potential constant expression, evaluate all 3302 // initializers even if some of them fail. 3303 if (!Info.keepEvaluatingAfterFailure()) 3304 return false; 3305 Success = false; 3306 } 3307 } 3308 return Success; 3309} 3310 3311/// Evaluate a function call. 3312static bool HandleFunctionCall(SourceLocation CallLoc, 3313 const FunctionDecl *Callee, const LValue *This, 3314 ArrayRef<const Expr*> Args, const Stmt *Body, 3315 EvalInfo &Info, APValue &Result) { 3316 ArgVector ArgValues(Args.size()); 3317 if (!EvaluateArgs(Args, ArgValues, Info)) 3318 return false; 3319 3320 if (!Info.CheckCallLimit(CallLoc)) 3321 return false; 3322 3323 CallStackFrame Frame(Info, CallLoc, Callee, This, ArgValues.data()); 3324 3325 // For a trivial copy or move assignment, perform an APValue copy. This is 3326 // essential for unions, where the operations performed by the assignment 3327 // operator cannot be represented as statements. 3328 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee); 3329 if (MD && MD->isDefaulted() && MD->isTrivial()) { 3330 assert(This && 3331 (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())); 3332 LValue RHS; 3333 RHS.setFrom(Info.Ctx, ArgValues[0]); 3334 APValue RHSValue; 3335 if (!handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(), 3336 RHS, RHSValue)) 3337 return false; 3338 if (!handleAssignment(Info, Args[0], *This, MD->getThisType(Info.Ctx), 3339 RHSValue)) 3340 return false; 3341 This->moveInto(Result); 3342 return true; 3343 } 3344 3345 EvalStmtResult ESR = EvaluateStmt(Result, Info, Body); 3346 if (ESR == ESR_Succeeded) { 3347 if (Callee->getResultType()->isVoidType()) 3348 return true; 3349 Info.Diag(Callee->getLocEnd(), diag::note_constexpr_no_return); 3350 } 3351 return ESR == ESR_Returned; 3352} 3353 3354/// Evaluate a constructor call. 3355static bool HandleConstructorCall(SourceLocation CallLoc, const LValue &This, 3356 ArrayRef<const Expr*> Args, 3357 const CXXConstructorDecl *Definition, 3358 EvalInfo &Info, APValue &Result) { 3359 ArgVector ArgValues(Args.size()); 3360 if (!EvaluateArgs(Args, ArgValues, Info)) 3361 return false; 3362 3363 if (!Info.CheckCallLimit(CallLoc)) 3364 return false; 3365 3366 const CXXRecordDecl *RD = Definition->getParent(); 3367 if (RD->getNumVBases()) { 3368 Info.Diag(CallLoc, diag::note_constexpr_virtual_base) << RD; 3369 return false; 3370 } 3371 3372 CallStackFrame Frame(Info, CallLoc, Definition, &This, ArgValues.data()); 3373 3374 // If it's a delegating constructor, just delegate. 3375 if (Definition->isDelegatingConstructor()) { 3376 CXXConstructorDecl::init_const_iterator I = Definition->init_begin(); 3377 if (!EvaluateInPlace(Result, Info, This, (*I)->getInit())) 3378 return false; 3379 return EvaluateStmt(Result, Info, Definition->getBody()) != ESR_Failed; 3380 } 3381 3382 // For a trivial copy or move constructor, perform an APValue copy. This is 3383 // essential for unions, where the operations performed by the constructor 3384 // cannot be represented by ctor-initializers. 3385 if (Definition->isDefaulted() && 3386 ((Definition->isCopyConstructor() && Definition->isTrivial()) || 3387 (Definition->isMoveConstructor() && Definition->isTrivial()))) { 3388 LValue RHS; 3389 RHS.setFrom(Info.Ctx, ArgValues[0]); 3390 return handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(), 3391 RHS, Result); 3392 } 3393 3394 // Reserve space for the struct members. 3395 if (!RD->isUnion() && Result.isUninit()) 3396 Result = APValue(APValue::UninitStruct(), RD->getNumBases(), 3397 std::distance(RD->field_begin(), RD->field_end())); 3398 3399 if (RD->isInvalidDecl()) return false; 3400 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 3401 3402 bool Success = true; 3403 unsigned BasesSeen = 0; 3404#ifndef NDEBUG 3405 CXXRecordDecl::base_class_const_iterator BaseIt = RD->bases_begin(); 3406#endif 3407 for (CXXConstructorDecl::init_const_iterator I = Definition->init_begin(), 3408 E = Definition->init_end(); I != E; ++I) { 3409 LValue Subobject = This; 3410 APValue *Value = &Result; 3411 3412 // Determine the subobject to initialize. 3413 if ((*I)->isBaseInitializer()) { 3414 QualType BaseType((*I)->getBaseClass(), 0); 3415#ifndef NDEBUG 3416 // Non-virtual base classes are initialized in the order in the class 3417 // definition. We have already checked for virtual base classes. 3418 assert(!BaseIt->isVirtual() && "virtual base for literal type"); 3419 assert(Info.Ctx.hasSameType(BaseIt->getType(), BaseType) && 3420 "base class initializers not in expected order"); 3421 ++BaseIt; 3422#endif 3423 if (!HandleLValueDirectBase(Info, (*I)->getInit(), Subobject, RD, 3424 BaseType->getAsCXXRecordDecl(), &Layout)) 3425 return false; 3426 Value = &Result.getStructBase(BasesSeen++); 3427 } else if (FieldDecl *FD = (*I)->getMember()) { 3428 if (!HandleLValueMember(Info, (*I)->getInit(), Subobject, FD, &Layout)) 3429 return false; 3430 if (RD->isUnion()) { 3431 Result = APValue(FD); 3432 Value = &Result.getUnionValue(); 3433 } else { 3434 Value = &Result.getStructField(FD->getFieldIndex()); 3435 } 3436 } else if (IndirectFieldDecl *IFD = (*I)->getIndirectMember()) { 3437 // Walk the indirect field decl's chain to find the object to initialize, 3438 // and make sure we've initialized every step along it. 3439 for (IndirectFieldDecl::chain_iterator C = IFD->chain_begin(), 3440 CE = IFD->chain_end(); 3441 C != CE; ++C) { 3442 FieldDecl *FD = cast<FieldDecl>(*C); 3443 CXXRecordDecl *CD = cast<CXXRecordDecl>(FD->getParent()); 3444 // Switch the union field if it differs. This happens if we had 3445 // preceding zero-initialization, and we're now initializing a union 3446 // subobject other than the first. 3447 // FIXME: In this case, the values of the other subobjects are 3448 // specified, since zero-initialization sets all padding bits to zero. 3449 if (Value->isUninit() || 3450 (Value->isUnion() && Value->getUnionField() != FD)) { 3451 if (CD->isUnion()) 3452 *Value = APValue(FD); 3453 else 3454 *Value = APValue(APValue::UninitStruct(), CD->getNumBases(), 3455 std::distance(CD->field_begin(), CD->field_end())); 3456 } 3457 if (!HandleLValueMember(Info, (*I)->getInit(), Subobject, FD)) 3458 return false; 3459 if (CD->isUnion()) 3460 Value = &Value->getUnionValue(); 3461 else 3462 Value = &Value->getStructField(FD->getFieldIndex()); 3463 } 3464 } else { 3465 llvm_unreachable("unknown base initializer kind"); 3466 } 3467 3468 if (!EvaluateInPlace(*Value, Info, Subobject, (*I)->getInit())) { 3469 // If we're checking for a potential constant expression, evaluate all 3470 // initializers even if some of them fail. 3471 if (!Info.keepEvaluatingAfterFailure()) 3472 return false; 3473 Success = false; 3474 } 3475 } 3476 3477 return Success && 3478 EvaluateStmt(Result, Info, Definition->getBody()) != ESR_Failed; 3479} 3480 3481//===----------------------------------------------------------------------===// 3482// Generic Evaluation 3483//===----------------------------------------------------------------------===// 3484namespace { 3485 3486// FIXME: RetTy is always bool. Remove it. 3487template <class Derived, typename RetTy=bool> 3488class ExprEvaluatorBase 3489 : public ConstStmtVisitor<Derived, RetTy> { 3490private: 3491 RetTy DerivedSuccess(const APValue &V, const Expr *E) { 3492 return static_cast<Derived*>(this)->Success(V, E); 3493 } 3494 RetTy DerivedZeroInitialization(const Expr *E) { 3495 return static_cast<Derived*>(this)->ZeroInitialization(E); 3496 } 3497 3498 // Check whether a conditional operator with a non-constant condition is a 3499 // potential constant expression. If neither arm is a potential constant 3500 // expression, then the conditional operator is not either. 3501 template<typename ConditionalOperator> 3502 void CheckPotentialConstantConditional(const ConditionalOperator *E) { 3503 assert(Info.CheckingPotentialConstantExpression); 3504 3505 // Speculatively evaluate both arms. 3506 { 3507 SmallVector<PartialDiagnosticAt, 8> Diag; 3508 SpeculativeEvaluationRAII Speculate(Info, &Diag); 3509 3510 StmtVisitorTy::Visit(E->getFalseExpr()); 3511 if (Diag.empty()) 3512 return; 3513 3514 Diag.clear(); 3515 StmtVisitorTy::Visit(E->getTrueExpr()); 3516 if (Diag.empty()) 3517 return; 3518 } 3519 3520 Error(E, diag::note_constexpr_conditional_never_const); 3521 } 3522 3523 3524 template<typename ConditionalOperator> 3525 bool HandleConditionalOperator(const ConditionalOperator *E) { 3526 bool BoolResult; 3527 if (!EvaluateAsBooleanCondition(E->getCond(), BoolResult, Info)) { 3528 if (Info.CheckingPotentialConstantExpression) 3529 CheckPotentialConstantConditional(E); 3530 return false; 3531 } 3532 3533 Expr *EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr(); 3534 return StmtVisitorTy::Visit(EvalExpr); 3535 } 3536 3537protected: 3538 EvalInfo &Info; 3539 typedef ConstStmtVisitor<Derived, RetTy> StmtVisitorTy; 3540 typedef ExprEvaluatorBase ExprEvaluatorBaseTy; 3541 3542 OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) { 3543 return Info.CCEDiag(E, D); 3544 } 3545 3546 RetTy ZeroInitialization(const Expr *E) { return Error(E); } 3547 3548public: 3549 ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {} 3550 3551 EvalInfo &getEvalInfo() { return Info; } 3552 3553 /// Report an evaluation error. This should only be called when an error is 3554 /// first discovered. When propagating an error, just return false. 3555 bool Error(const Expr *E, diag::kind D) { 3556 Info.Diag(E, D); 3557 return false; 3558 } 3559 bool Error(const Expr *E) { 3560 return Error(E, diag::note_invalid_subexpr_in_const_expr); 3561 } 3562 3563 RetTy VisitStmt(const Stmt *) { 3564 llvm_unreachable("Expression evaluator should not be called on stmts"); 3565 } 3566 RetTy VisitExpr(const Expr *E) { 3567 return Error(E); 3568 } 3569 3570 RetTy VisitParenExpr(const ParenExpr *E) 3571 { return StmtVisitorTy::Visit(E->getSubExpr()); } 3572 RetTy VisitUnaryExtension(const UnaryOperator *E) 3573 { return StmtVisitorTy::Visit(E->getSubExpr()); } 3574 RetTy VisitUnaryPlus(const UnaryOperator *E) 3575 { return StmtVisitorTy::Visit(E->getSubExpr()); } 3576 RetTy VisitChooseExpr(const ChooseExpr *E) 3577 { return StmtVisitorTy::Visit(E->getChosenSubExpr(Info.Ctx)); } 3578 RetTy VisitGenericSelectionExpr(const GenericSelectionExpr *E) 3579 { return StmtVisitorTy::Visit(E->getResultExpr()); } 3580 RetTy VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E) 3581 { return StmtVisitorTy::Visit(E->getReplacement()); } 3582 RetTy VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) 3583 { return StmtVisitorTy::Visit(E->getExpr()); } 3584 RetTy VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) 3585 { return StmtVisitorTy::Visit(E->getExpr()); } 3586 // We cannot create any objects for which cleanups are required, so there is 3587 // nothing to do here; all cleanups must come from unevaluated subexpressions. 3588 RetTy VisitExprWithCleanups(const ExprWithCleanups *E) 3589 { return StmtVisitorTy::Visit(E->getSubExpr()); } 3590 3591 RetTy VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) { 3592 CCEDiag(E, diag::note_constexpr_invalid_cast) << 0; 3593 return static_cast<Derived*>(this)->VisitCastExpr(E); 3594 } 3595 RetTy VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) { 3596 CCEDiag(E, diag::note_constexpr_invalid_cast) << 1; 3597 return static_cast<Derived*>(this)->VisitCastExpr(E); 3598 } 3599 3600 RetTy VisitBinaryOperator(const BinaryOperator *E) { 3601 switch (E->getOpcode()) { 3602 default: 3603 return Error(E); 3604 3605 case BO_Comma: 3606 VisitIgnoredValue(E->getLHS()); 3607 return StmtVisitorTy::Visit(E->getRHS()); 3608 3609 case BO_PtrMemD: 3610 case BO_PtrMemI: { 3611 LValue Obj; 3612 if (!HandleMemberPointerAccess(Info, E, Obj)) 3613 return false; 3614 APValue Result; 3615 if (!handleLValueToRValueConversion(Info, E, E->getType(), Obj, Result)) 3616 return false; 3617 return DerivedSuccess(Result, E); 3618 } 3619 } 3620 } 3621 3622 RetTy VisitBinaryConditionalOperator(const BinaryConditionalOperator *E) { 3623 // Evaluate and cache the common expression. We treat it as a temporary, 3624 // even though it's not quite the same thing. 3625 if (!Evaluate(Info.CurrentCall->Temporaries[E->getOpaqueValue()], 3626 Info, E->getCommon())) 3627 return false; 3628 3629 return HandleConditionalOperator(E); 3630 } 3631 3632 RetTy VisitConditionalOperator(const ConditionalOperator *E) { 3633 bool IsBcpCall = false; 3634 // If the condition (ignoring parens) is a __builtin_constant_p call, 3635 // the result is a constant expression if it can be folded without 3636 // side-effects. This is an important GNU extension. See GCC PR38377 3637 // for discussion. 3638 if (const CallExpr *CallCE = 3639 dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts())) 3640 if (CallCE->isBuiltinCall() == Builtin::BI__builtin_constant_p) 3641 IsBcpCall = true; 3642 3643 // Always assume __builtin_constant_p(...) ? ... : ... is a potential 3644 // constant expression; we can't check whether it's potentially foldable. 3645 if (Info.CheckingPotentialConstantExpression && IsBcpCall) 3646 return false; 3647 3648 FoldConstant Fold(Info); 3649 3650 if (!HandleConditionalOperator(E)) 3651 return false; 3652 3653 if (IsBcpCall) 3654 Fold.Fold(Info); 3655 3656 return true; 3657 } 3658 3659 RetTy VisitOpaqueValueExpr(const OpaqueValueExpr *E) { 3660 APValue &Value = Info.CurrentCall->Temporaries[E]; 3661 if (Value.isUninit()) { 3662 const Expr *Source = E->getSourceExpr(); 3663 if (!Source) 3664 return Error(E); 3665 if (Source == E) { // sanity checking. 3666 assert(0 && "OpaqueValueExpr recursively refers to itself"); 3667 return Error(E); 3668 } 3669 return StmtVisitorTy::Visit(Source); 3670 } 3671 return DerivedSuccess(Value, E); 3672 } 3673 3674 RetTy VisitCallExpr(const CallExpr *E) { 3675 const Expr *Callee = E->getCallee()->IgnoreParens(); 3676 QualType CalleeType = Callee->getType(); 3677 3678 const FunctionDecl *FD = 0; 3679 LValue *This = 0, ThisVal; 3680 ArrayRef<const Expr *> Args(E->getArgs(), E->getNumArgs()); 3681 bool HasQualifier = false; 3682 3683 // Extract function decl and 'this' pointer from the callee. 3684 if (CalleeType->isSpecificBuiltinType(BuiltinType::BoundMember)) { 3685 const ValueDecl *Member = 0; 3686 if (const MemberExpr *ME = dyn_cast<MemberExpr>(Callee)) { 3687 // Explicit bound member calls, such as x.f() or p->g(); 3688 if (!EvaluateObjectArgument(Info, ME->getBase(), ThisVal)) 3689 return false; 3690 Member = ME->getMemberDecl(); 3691 This = &ThisVal; 3692 HasQualifier = ME->hasQualifier(); 3693 } else if (const BinaryOperator *BE = dyn_cast<BinaryOperator>(Callee)) { 3694 // Indirect bound member calls ('.*' or '->*'). 3695 Member = HandleMemberPointerAccess(Info, BE, ThisVal, false); 3696 if (!Member) return false; 3697 This = &ThisVal; 3698 } else 3699 return Error(Callee); 3700 3701 FD = dyn_cast<FunctionDecl>(Member); 3702 if (!FD) 3703 return Error(Callee); 3704 } else if (CalleeType->isFunctionPointerType()) { 3705 LValue Call; 3706 if (!EvaluatePointer(Callee, Call, Info)) 3707 return false; 3708 3709 if (!Call.getLValueOffset().isZero()) 3710 return Error(Callee); 3711 FD = dyn_cast_or_null<FunctionDecl>( 3712 Call.getLValueBase().dyn_cast<const ValueDecl*>()); 3713 if (!FD) 3714 return Error(Callee); 3715 3716 // Overloaded operator calls to member functions are represented as normal 3717 // calls with '*this' as the first argument. 3718 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 3719 if (MD && !MD->isStatic()) { 3720 // FIXME: When selecting an implicit conversion for an overloaded 3721 // operator delete, we sometimes try to evaluate calls to conversion 3722 // operators without a 'this' parameter! 3723 if (Args.empty()) 3724 return Error(E); 3725 3726 if (!EvaluateObjectArgument(Info, Args[0], ThisVal)) 3727 return false; 3728 This = &ThisVal; 3729 Args = Args.slice(1); 3730 } 3731 3732 // Don't call function pointers which have been cast to some other type. 3733 if (!Info.Ctx.hasSameType(CalleeType->getPointeeType(), FD->getType())) 3734 return Error(E); 3735 } else 3736 return Error(E); 3737 3738 if (This && !This->checkSubobject(Info, E, CSK_This)) 3739 return false; 3740 3741 // DR1358 allows virtual constexpr functions in some cases. Don't allow 3742 // calls to such functions in constant expressions. 3743 if (This && !HasQualifier && 3744 isa<CXXMethodDecl>(FD) && cast<CXXMethodDecl>(FD)->isVirtual()) 3745 return Error(E, diag::note_constexpr_virtual_call); 3746 3747 const FunctionDecl *Definition = 0; 3748 Stmt *Body = FD->getBody(Definition); 3749 APValue Result; 3750 3751 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition) || 3752 !HandleFunctionCall(E->getExprLoc(), Definition, This, Args, Body, 3753 Info, Result)) 3754 return false; 3755 3756 return DerivedSuccess(Result, E); 3757 } 3758 3759 RetTy VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) { 3760 return StmtVisitorTy::Visit(E->getInitializer()); 3761 } 3762 RetTy VisitInitListExpr(const InitListExpr *E) { 3763 if (E->getNumInits() == 0) 3764 return DerivedZeroInitialization(E); 3765 if (E->getNumInits() == 1) 3766 return StmtVisitorTy::Visit(E->getInit(0)); 3767 return Error(E); 3768 } 3769 RetTy VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 3770 return DerivedZeroInitialization(E); 3771 } 3772 RetTy VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) { 3773 return DerivedZeroInitialization(E); 3774 } 3775 RetTy VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 3776 return DerivedZeroInitialization(E); 3777 } 3778 3779 /// A member expression where the object is a prvalue is itself a prvalue. 3780 RetTy VisitMemberExpr(const MemberExpr *E) { 3781 assert(!E->isArrow() && "missing call to bound member function?"); 3782 3783 APValue Val; 3784 if (!Evaluate(Val, Info, E->getBase())) 3785 return false; 3786 3787 QualType BaseTy = E->getBase()->getType(); 3788 3789 const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl()); 3790 if (!FD) return Error(E); 3791 assert(!FD->getType()->isReferenceType() && "prvalue reference?"); 3792 assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() == 3793 FD->getParent()->getCanonicalDecl() && "record / field mismatch"); 3794 3795 CompleteObject Obj(&Val, BaseTy); 3796 SubobjectDesignator Designator(BaseTy); 3797 Designator.addDeclUnchecked(FD); 3798 3799 APValue Result; 3800 return extractSubobject(Info, E, Obj, Designator, Result) && 3801 DerivedSuccess(Result, E); 3802 } 3803 3804 RetTy VisitCastExpr(const CastExpr *E) { 3805 switch (E->getCastKind()) { 3806 default: 3807 break; 3808 3809 case CK_AtomicToNonAtomic: { 3810 APValue AtomicVal; 3811 if (!EvaluateAtomic(E->getSubExpr(), AtomicVal, Info)) 3812 return false; 3813 return DerivedSuccess(AtomicVal, E); 3814 } 3815 3816 case CK_NoOp: 3817 case CK_UserDefinedConversion: 3818 return StmtVisitorTy::Visit(E->getSubExpr()); 3819 3820 case CK_LValueToRValue: { 3821 LValue LVal; 3822 if (!EvaluateLValue(E->getSubExpr(), LVal, Info)) 3823 return false; 3824 APValue RVal; 3825 // Note, we use the subexpression's type in order to retain cv-qualifiers. 3826 if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(), 3827 LVal, RVal)) 3828 return false; 3829 return DerivedSuccess(RVal, E); 3830 } 3831 } 3832 3833 return Error(E); 3834 } 3835 3836 RetTy VisitUnaryPostInc(const UnaryOperator *UO) { 3837 return VisitUnaryPostIncDec(UO); 3838 } 3839 RetTy VisitUnaryPostDec(const UnaryOperator *UO) { 3840 return VisitUnaryPostIncDec(UO); 3841 } 3842 RetTy VisitUnaryPostIncDec(const UnaryOperator *UO) { 3843 if (!Info.getLangOpts().CPlusPlus1y && !Info.keepEvaluatingAfterFailure()) 3844 return Error(UO); 3845 3846 LValue LVal; 3847 if (!EvaluateLValue(UO->getSubExpr(), LVal, Info)) 3848 return false; 3849 APValue RVal; 3850 if (!handleIncDec(this->Info, UO, LVal, UO->getSubExpr()->getType(), 3851 UO->isIncrementOp(), &RVal)) 3852 return false; 3853 return DerivedSuccess(RVal, UO); 3854 } 3855 3856 /// Visit a value which is evaluated, but whose value is ignored. 3857 void VisitIgnoredValue(const Expr *E) { 3858 EvaluateIgnoredValue(Info, E); 3859 } 3860}; 3861 3862} 3863 3864//===----------------------------------------------------------------------===// 3865// Common base class for lvalue and temporary evaluation. 3866//===----------------------------------------------------------------------===// 3867namespace { 3868template<class Derived> 3869class LValueExprEvaluatorBase 3870 : public ExprEvaluatorBase<Derived, bool> { 3871protected: 3872 LValue &Result; 3873 typedef LValueExprEvaluatorBase LValueExprEvaluatorBaseTy; 3874 typedef ExprEvaluatorBase<Derived, bool> ExprEvaluatorBaseTy; 3875 3876 bool Success(APValue::LValueBase B) { 3877 Result.set(B); 3878 return true; 3879 } 3880 3881public: 3882 LValueExprEvaluatorBase(EvalInfo &Info, LValue &Result) : 3883 ExprEvaluatorBaseTy(Info), Result(Result) {} 3884 3885 bool Success(const APValue &V, const Expr *E) { 3886 Result.setFrom(this->Info.Ctx, V); 3887 return true; 3888 } 3889 3890 bool VisitMemberExpr(const MemberExpr *E) { 3891 // Handle non-static data members. 3892 QualType BaseTy; 3893 if (E->isArrow()) { 3894 if (!EvaluatePointer(E->getBase(), Result, this->Info)) 3895 return false; 3896 BaseTy = E->getBase()->getType()->castAs<PointerType>()->getPointeeType(); 3897 } else if (E->getBase()->isRValue()) { 3898 assert(E->getBase()->getType()->isRecordType()); 3899 if (!EvaluateTemporary(E->getBase(), Result, this->Info)) 3900 return false; 3901 BaseTy = E->getBase()->getType(); 3902 } else { 3903 if (!this->Visit(E->getBase())) 3904 return false; 3905 BaseTy = E->getBase()->getType(); 3906 } 3907 3908 const ValueDecl *MD = E->getMemberDecl(); 3909 if (const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) { 3910 assert(BaseTy->getAs<RecordType>()->getDecl()->getCanonicalDecl() == 3911 FD->getParent()->getCanonicalDecl() && "record / field mismatch"); 3912 (void)BaseTy; 3913 if (!HandleLValueMember(this->Info, E, Result, FD)) 3914 return false; 3915 } else if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(MD)) { 3916 if (!HandleLValueIndirectMember(this->Info, E, Result, IFD)) 3917 return false; 3918 } else 3919 return this->Error(E); 3920 3921 if (MD->getType()->isReferenceType()) { 3922 APValue RefValue; 3923 if (!handleLValueToRValueConversion(this->Info, E, MD->getType(), Result, 3924 RefValue)) 3925 return false; 3926 return Success(RefValue, E); 3927 } 3928 return true; 3929 } 3930 3931 bool VisitBinaryOperator(const BinaryOperator *E) { 3932 switch (E->getOpcode()) { 3933 default: 3934 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 3935 3936 case BO_PtrMemD: 3937 case BO_PtrMemI: 3938 return HandleMemberPointerAccess(this->Info, E, Result); 3939 } 3940 } 3941 3942 bool VisitCastExpr(const CastExpr *E) { 3943 switch (E->getCastKind()) { 3944 default: 3945 return ExprEvaluatorBaseTy::VisitCastExpr(E); 3946 3947 case CK_DerivedToBase: 3948 case CK_UncheckedDerivedToBase: 3949 if (!this->Visit(E->getSubExpr())) 3950 return false; 3951 3952 // Now figure out the necessary offset to add to the base LV to get from 3953 // the derived class to the base class. 3954 return HandleLValueBasePath(this->Info, E, E->getSubExpr()->getType(), 3955 Result); 3956 } 3957 } 3958}; 3959} 3960 3961//===----------------------------------------------------------------------===// 3962// LValue Evaluation 3963// 3964// This is used for evaluating lvalues (in C and C++), xvalues (in C++11), 3965// function designators (in C), decl references to void objects (in C), and 3966// temporaries (if building with -Wno-address-of-temporary). 3967// 3968// LValue evaluation produces values comprising a base expression of one of the 3969// following types: 3970// - Declarations 3971// * VarDecl 3972// * FunctionDecl 3973// - Literals 3974// * CompoundLiteralExpr in C 3975// * StringLiteral 3976// * CXXTypeidExpr 3977// * PredefinedExpr 3978// * ObjCStringLiteralExpr 3979// * ObjCEncodeExpr 3980// * AddrLabelExpr 3981// * BlockExpr 3982// * CallExpr for a MakeStringConstant builtin 3983// - Locals and temporaries 3984// * MaterializeTemporaryExpr 3985// * Any Expr, with a CallIndex indicating the function in which the temporary 3986// was evaluated, for cases where the MaterializeTemporaryExpr is missing 3987// from the AST (FIXME). 3988// * A MaterializeTemporaryExpr that has static storage duration, with no 3989// CallIndex, for a lifetime-extended temporary. 3990// plus an offset in bytes. 3991//===----------------------------------------------------------------------===// 3992namespace { 3993class LValueExprEvaluator 3994 : public LValueExprEvaluatorBase<LValueExprEvaluator> { 3995public: 3996 LValueExprEvaluator(EvalInfo &Info, LValue &Result) : 3997 LValueExprEvaluatorBaseTy(Info, Result) {} 3998 3999 bool VisitVarDecl(const Expr *E, const VarDecl *VD); 4000 bool VisitUnaryPreIncDec(const UnaryOperator *UO); 4001 4002 bool VisitDeclRefExpr(const DeclRefExpr *E); 4003 bool VisitPredefinedExpr(const PredefinedExpr *E) { return Success(E); } 4004 bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E); 4005 bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E); 4006 bool VisitMemberExpr(const MemberExpr *E); 4007 bool VisitStringLiteral(const StringLiteral *E) { return Success(E); } 4008 bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { return Success(E); } 4009 bool VisitCXXTypeidExpr(const CXXTypeidExpr *E); 4010 bool VisitCXXUuidofExpr(const CXXUuidofExpr *E); 4011 bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E); 4012 bool VisitUnaryDeref(const UnaryOperator *E); 4013 bool VisitUnaryReal(const UnaryOperator *E); 4014 bool VisitUnaryImag(const UnaryOperator *E); 4015 bool VisitUnaryPreInc(const UnaryOperator *UO) { 4016 return VisitUnaryPreIncDec(UO); 4017 } 4018 bool VisitUnaryPreDec(const UnaryOperator *UO) { 4019 return VisitUnaryPreIncDec(UO); 4020 } 4021 bool VisitBinAssign(const BinaryOperator *BO); 4022 bool VisitCompoundAssignOperator(const CompoundAssignOperator *CAO); 4023 4024 bool VisitCastExpr(const CastExpr *E) { 4025 switch (E->getCastKind()) { 4026 default: 4027 return LValueExprEvaluatorBaseTy::VisitCastExpr(E); 4028 4029 case CK_LValueBitCast: 4030 this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2; 4031 if (!Visit(E->getSubExpr())) 4032 return false; 4033 Result.Designator.setInvalid(); 4034 return true; 4035 4036 case CK_BaseToDerived: 4037 if (!Visit(E->getSubExpr())) 4038 return false; 4039 return HandleBaseToDerivedCast(Info, E, Result); 4040 } 4041 } 4042}; 4043} // end anonymous namespace 4044 4045/// Evaluate an expression as an lvalue. This can be legitimately called on 4046/// expressions which are not glvalues, in two cases: 4047/// * function designators in C, and 4048/// * "extern void" objects 4049static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info) { 4050 assert(E->isGLValue() || E->getType()->isFunctionType() || 4051 E->getType()->isVoidType()); 4052 return LValueExprEvaluator(Info, Result).Visit(E); 4053} 4054 4055bool LValueExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) { 4056 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(E->getDecl())) 4057 return Success(FD); 4058 if (const VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) 4059 return VisitVarDecl(E, VD); 4060 return Error(E); 4061} 4062 4063bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) { 4064 CallStackFrame *Frame = 0; 4065 if (VD->hasLocalStorage() && Info.CurrentCall->Index > 1) 4066 Frame = Info.CurrentCall; 4067 4068 if (!VD->getType()->isReferenceType()) { 4069 if (Frame) { 4070 Result.set(VD, Frame->Index); 4071 return true; 4072 } 4073 return Success(VD); 4074 } 4075 4076 APValue *V; 4077 if (!evaluateVarDeclInit(Info, E, VD, Frame, V)) 4078 return false; 4079 return Success(*V, E); 4080} 4081 4082bool LValueExprEvaluator::VisitMaterializeTemporaryExpr( 4083 const MaterializeTemporaryExpr *E) { 4084 // Walk through the expression to find the materialized temporary itself. 4085 SmallVector<const Expr *, 2> CommaLHSs; 4086 SmallVector<SubobjectAdjustment, 2> Adjustments; 4087 const Expr *Inner = E->GetTemporaryExpr()-> 4088 skipRValueSubobjectAdjustments(CommaLHSs, Adjustments); 4089 4090 // If we passed any comma operators, evaluate their LHSs. 4091 for (unsigned I = 0, N = CommaLHSs.size(); I != N; ++I) 4092 if (!EvaluateIgnoredValue(Info, CommaLHSs[I])) 4093 return false; 4094 4095 // A materialized temporary with static storage duration can appear within the 4096 // result of a constant expression evaluation, so we need to preserve its 4097 // value for use outside this evaluation. 4098 APValue *Value; 4099 if (E->getStorageDuration() == SD_Static) { 4100 Value = Info.Ctx.getMaterializedTemporaryValue(E, true); 4101 *Value = APValue(); 4102 Result.set(E); 4103 } else { 4104 Value = &Info.CurrentCall->Temporaries[E]; 4105 Result.set(E, Info.CurrentCall->Index); 4106 } 4107 4108 QualType Type = Inner->getType(); 4109 4110 // Materialize the temporary itself. 4111 if (!EvaluateInPlace(*Value, Info, Result, Inner) || 4112 (E->getStorageDuration() == SD_Static && 4113 !CheckConstantExpression(Info, E->getExprLoc(), Type, *Value))) { 4114 *Value = APValue(); 4115 return false; 4116 } 4117 4118 // Adjust our lvalue to refer to the desired subobject. 4119 for (unsigned I = Adjustments.size(); I != 0; /**/) { 4120 --I; 4121 switch (Adjustments[I].Kind) { 4122 case SubobjectAdjustment::DerivedToBaseAdjustment: 4123 if (!HandleLValueBasePath(Info, Adjustments[I].DerivedToBase.BasePath, 4124 Type, Result)) 4125 return false; 4126 Type = Adjustments[I].DerivedToBase.BasePath->getType(); 4127 break; 4128 4129 case SubobjectAdjustment::FieldAdjustment: 4130 if (!HandleLValueMember(Info, E, Result, Adjustments[I].Field)) 4131 return false; 4132 Type = Adjustments[I].Field->getType(); 4133 break; 4134 4135 case SubobjectAdjustment::MemberPointerAdjustment: 4136 if (!HandleMemberPointerAccess(this->Info, Type, Result, 4137 Adjustments[I].Ptr.RHS)) 4138 return false; 4139 Type = Adjustments[I].Ptr.MPT->getPointeeType(); 4140 break; 4141 } 4142 } 4143 4144 return true; 4145} 4146 4147bool 4148LValueExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) { 4149 assert(!Info.getLangOpts().CPlusPlus && "lvalue compound literal in c++?"); 4150 // Defer visiting the literal until the lvalue-to-rvalue conversion. We can 4151 // only see this when folding in C, so there's no standard to follow here. 4152 return Success(E); 4153} 4154 4155bool LValueExprEvaluator::VisitCXXTypeidExpr(const CXXTypeidExpr *E) { 4156 if (!E->isPotentiallyEvaluated()) 4157 return Success(E); 4158 4159 Info.Diag(E, diag::note_constexpr_typeid_polymorphic) 4160 << E->getExprOperand()->getType() 4161 << E->getExprOperand()->getSourceRange(); 4162 return false; 4163} 4164 4165bool LValueExprEvaluator::VisitCXXUuidofExpr(const CXXUuidofExpr *E) { 4166 return Success(E); 4167} 4168 4169bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) { 4170 // Handle static data members. 4171 if (const VarDecl *VD = dyn_cast<VarDecl>(E->getMemberDecl())) { 4172 VisitIgnoredValue(E->getBase()); 4173 return VisitVarDecl(E, VD); 4174 } 4175 4176 // Handle static member functions. 4177 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) { 4178 if (MD->isStatic()) { 4179 VisitIgnoredValue(E->getBase()); 4180 return Success(MD); 4181 } 4182 } 4183 4184 // Handle non-static data members. 4185 return LValueExprEvaluatorBaseTy::VisitMemberExpr(E); 4186} 4187 4188bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) { 4189 // FIXME: Deal with vectors as array subscript bases. 4190 if (E->getBase()->getType()->isVectorType()) 4191 return Error(E); 4192 4193 if (!EvaluatePointer(E->getBase(), Result, Info)) 4194 return false; 4195 4196 APSInt Index; 4197 if (!EvaluateInteger(E->getIdx(), Index, Info)) 4198 return false; 4199 4200 return HandleLValueArrayAdjustment(Info, E, Result, E->getType(), 4201 getExtValue(Index)); 4202} 4203 4204bool LValueExprEvaluator::VisitUnaryDeref(const UnaryOperator *E) { 4205 return EvaluatePointer(E->getSubExpr(), Result, Info); 4206} 4207 4208bool LValueExprEvaluator::VisitUnaryReal(const UnaryOperator *E) { 4209 if (!Visit(E->getSubExpr())) 4210 return false; 4211 // __real is a no-op on scalar lvalues. 4212 if (E->getSubExpr()->getType()->isAnyComplexType()) 4213 HandleLValueComplexElement(Info, E, Result, E->getType(), false); 4214 return true; 4215} 4216 4217bool LValueExprEvaluator::VisitUnaryImag(const UnaryOperator *E) { 4218 assert(E->getSubExpr()->getType()->isAnyComplexType() && 4219 "lvalue __imag__ on scalar?"); 4220 if (!Visit(E->getSubExpr())) 4221 return false; 4222 HandleLValueComplexElement(Info, E, Result, E->getType(), true); 4223 return true; 4224} 4225 4226bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) { 4227 if (!Info.getLangOpts().CPlusPlus1y && !Info.keepEvaluatingAfterFailure()) 4228 return Error(UO); 4229 4230 if (!this->Visit(UO->getSubExpr())) 4231 return false; 4232 4233 return handleIncDec( 4234 this->Info, UO, Result, UO->getSubExpr()->getType(), 4235 UO->isIncrementOp(), 0); 4236} 4237 4238bool LValueExprEvaluator::VisitCompoundAssignOperator( 4239 const CompoundAssignOperator *CAO) { 4240 if (!Info.getLangOpts().CPlusPlus1y && !Info.keepEvaluatingAfterFailure()) 4241 return Error(CAO); 4242 4243 APValue RHS; 4244 4245 // The overall lvalue result is the result of evaluating the LHS. 4246 if (!this->Visit(CAO->getLHS())) { 4247 if (Info.keepEvaluatingAfterFailure()) 4248 Evaluate(RHS, this->Info, CAO->getRHS()); 4249 return false; 4250 } 4251 4252 if (!Evaluate(RHS, this->Info, CAO->getRHS())) 4253 return false; 4254 4255 return handleCompoundAssignment( 4256 this->Info, CAO, 4257 Result, CAO->getLHS()->getType(), CAO->getComputationLHSType(), 4258 CAO->getOpForCompoundAssignment(CAO->getOpcode()), RHS); 4259} 4260 4261bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) { 4262 if (!Info.getLangOpts().CPlusPlus1y && !Info.keepEvaluatingAfterFailure()) 4263 return Error(E); 4264 4265 APValue NewVal; 4266 4267 if (!this->Visit(E->getLHS())) { 4268 if (Info.keepEvaluatingAfterFailure()) 4269 Evaluate(NewVal, this->Info, E->getRHS()); 4270 return false; 4271 } 4272 4273 if (!Evaluate(NewVal, this->Info, E->getRHS())) 4274 return false; 4275 4276 return handleAssignment(this->Info, E, Result, E->getLHS()->getType(), 4277 NewVal); 4278} 4279 4280//===----------------------------------------------------------------------===// 4281// Pointer Evaluation 4282//===----------------------------------------------------------------------===// 4283 4284namespace { 4285class PointerExprEvaluator 4286 : public ExprEvaluatorBase<PointerExprEvaluator, bool> { 4287 LValue &Result; 4288 4289 bool Success(const Expr *E) { 4290 Result.set(E); 4291 return true; 4292 } 4293public: 4294 4295 PointerExprEvaluator(EvalInfo &info, LValue &Result) 4296 : ExprEvaluatorBaseTy(info), Result(Result) {} 4297 4298 bool Success(const APValue &V, const Expr *E) { 4299 Result.setFrom(Info.Ctx, V); 4300 return true; 4301 } 4302 bool ZeroInitialization(const Expr *E) { 4303 return Success((Expr*)0); 4304 } 4305 4306 bool VisitBinaryOperator(const BinaryOperator *E); 4307 bool VisitCastExpr(const CastExpr* E); 4308 bool VisitUnaryAddrOf(const UnaryOperator *E); 4309 bool VisitObjCStringLiteral(const ObjCStringLiteral *E) 4310 { return Success(E); } 4311 bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E) 4312 { return Success(E); } 4313 bool VisitAddrLabelExpr(const AddrLabelExpr *E) 4314 { return Success(E); } 4315 bool VisitCallExpr(const CallExpr *E); 4316 bool VisitBlockExpr(const BlockExpr *E) { 4317 if (!E->getBlockDecl()->hasCaptures()) 4318 return Success(E); 4319 return Error(E); 4320 } 4321 bool VisitCXXThisExpr(const CXXThisExpr *E) { 4322 // Can't look at 'this' when checking a potential constant expression. 4323 if (Info.CheckingPotentialConstantExpression) 4324 return false; 4325 if (!Info.CurrentCall->This) 4326 return Error(E); 4327 Result = *Info.CurrentCall->This; 4328 return true; 4329 } 4330 4331 // FIXME: Missing: @protocol, @selector 4332}; 4333} // end anonymous namespace 4334 4335static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info) { 4336 assert(E->isRValue() && E->getType()->hasPointerRepresentation()); 4337 return PointerExprEvaluator(Info, Result).Visit(E); 4338} 4339 4340bool PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { 4341 if (E->getOpcode() != BO_Add && 4342 E->getOpcode() != BO_Sub) 4343 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 4344 4345 const Expr *PExp = E->getLHS(); 4346 const Expr *IExp = E->getRHS(); 4347 if (IExp->getType()->isPointerType()) 4348 std::swap(PExp, IExp); 4349 4350 bool EvalPtrOK = EvaluatePointer(PExp, Result, Info); 4351 if (!EvalPtrOK && !Info.keepEvaluatingAfterFailure()) 4352 return false; 4353 4354 llvm::APSInt Offset; 4355 if (!EvaluateInteger(IExp, Offset, Info) || !EvalPtrOK) 4356 return false; 4357 4358 int64_t AdditionalOffset = getExtValue(Offset); 4359 if (E->getOpcode() == BO_Sub) 4360 AdditionalOffset = -AdditionalOffset; 4361 4362 QualType Pointee = PExp->getType()->castAs<PointerType>()->getPointeeType(); 4363 return HandleLValueArrayAdjustment(Info, E, Result, Pointee, 4364 AdditionalOffset); 4365} 4366 4367bool PointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) { 4368 return EvaluateLValue(E->getSubExpr(), Result, Info); 4369} 4370 4371bool PointerExprEvaluator::VisitCastExpr(const CastExpr* E) { 4372 const Expr* SubExpr = E->getSubExpr(); 4373 4374 switch (E->getCastKind()) { 4375 default: 4376 break; 4377 4378 case CK_BitCast: 4379 case CK_CPointerToObjCPointerCast: 4380 case CK_BlockPointerToObjCPointerCast: 4381 case CK_AnyPointerToBlockPointerCast: 4382 if (!Visit(SubExpr)) 4383 return false; 4384 // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are 4385 // permitted in constant expressions in C++11. Bitcasts from cv void* are 4386 // also static_casts, but we disallow them as a resolution to DR1312. 4387 if (!E->getType()->isVoidPointerType()) { 4388 Result.Designator.setInvalid(); 4389 if (SubExpr->getType()->isVoidPointerType()) 4390 CCEDiag(E, diag::note_constexpr_invalid_cast) 4391 << 3 << SubExpr->getType(); 4392 else 4393 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2; 4394 } 4395 return true; 4396 4397 case CK_DerivedToBase: 4398 case CK_UncheckedDerivedToBase: 4399 if (!EvaluatePointer(E->getSubExpr(), Result, Info)) 4400 return false; 4401 if (!Result.Base && Result.Offset.isZero()) 4402 return true; 4403 4404 // Now figure out the necessary offset to add to the base LV to get from 4405 // the derived class to the base class. 4406 return HandleLValueBasePath(Info, E, E->getSubExpr()->getType()-> 4407 castAs<PointerType>()->getPointeeType(), 4408 Result); 4409 4410 case CK_BaseToDerived: 4411 if (!Visit(E->getSubExpr())) 4412 return false; 4413 if (!Result.Base && Result.Offset.isZero()) 4414 return true; 4415 return HandleBaseToDerivedCast(Info, E, Result); 4416 4417 case CK_NullToPointer: 4418 VisitIgnoredValue(E->getSubExpr()); 4419 return ZeroInitialization(E); 4420 4421 case CK_IntegralToPointer: { 4422 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2; 4423 4424 APValue Value; 4425 if (!EvaluateIntegerOrLValue(SubExpr, Value, Info)) 4426 break; 4427 4428 if (Value.isInt()) { 4429 unsigned Size = Info.Ctx.getTypeSize(E->getType()); 4430 uint64_t N = Value.getInt().extOrTrunc(Size).getZExtValue(); 4431 Result.Base = (Expr*)0; 4432 Result.Offset = CharUnits::fromQuantity(N); 4433 Result.CallIndex = 0; 4434 Result.Designator.setInvalid(); 4435 return true; 4436 } else { 4437 // Cast is of an lvalue, no need to change value. 4438 Result.setFrom(Info.Ctx, Value); 4439 return true; 4440 } 4441 } 4442 case CK_ArrayToPointerDecay: 4443 if (SubExpr->isGLValue()) { 4444 if (!EvaluateLValue(SubExpr, Result, Info)) 4445 return false; 4446 } else { 4447 Result.set(SubExpr, Info.CurrentCall->Index); 4448 if (!EvaluateInPlace(Info.CurrentCall->Temporaries[SubExpr], 4449 Info, Result, SubExpr)) 4450 return false; 4451 } 4452 // The result is a pointer to the first element of the array. 4453 if (const ConstantArrayType *CAT 4454 = Info.Ctx.getAsConstantArrayType(SubExpr->getType())) 4455 Result.addArray(Info, E, CAT); 4456 else 4457 Result.Designator.setInvalid(); 4458 return true; 4459 4460 case CK_FunctionToPointerDecay: 4461 return EvaluateLValue(SubExpr, Result, Info); 4462 } 4463 4464 return ExprEvaluatorBaseTy::VisitCastExpr(E); 4465} 4466 4467bool PointerExprEvaluator::VisitCallExpr(const CallExpr *E) { 4468 if (IsStringLiteralCall(E)) 4469 return Success(E); 4470 4471 return ExprEvaluatorBaseTy::VisitCallExpr(E); 4472} 4473 4474//===----------------------------------------------------------------------===// 4475// Member Pointer Evaluation 4476//===----------------------------------------------------------------------===// 4477 4478namespace { 4479class MemberPointerExprEvaluator 4480 : public ExprEvaluatorBase<MemberPointerExprEvaluator, bool> { 4481 MemberPtr &Result; 4482 4483 bool Success(const ValueDecl *D) { 4484 Result = MemberPtr(D); 4485 return true; 4486 } 4487public: 4488 4489 MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result) 4490 : ExprEvaluatorBaseTy(Info), Result(Result) {} 4491 4492 bool Success(const APValue &V, const Expr *E) { 4493 Result.setFrom(V); 4494 return true; 4495 } 4496 bool ZeroInitialization(const Expr *E) { 4497 return Success((const ValueDecl*)0); 4498 } 4499 4500 bool VisitCastExpr(const CastExpr *E); 4501 bool VisitUnaryAddrOf(const UnaryOperator *E); 4502}; 4503} // end anonymous namespace 4504 4505static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result, 4506 EvalInfo &Info) { 4507 assert(E->isRValue() && E->getType()->isMemberPointerType()); 4508 return MemberPointerExprEvaluator(Info, Result).Visit(E); 4509} 4510 4511bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) { 4512 switch (E->getCastKind()) { 4513 default: 4514 return ExprEvaluatorBaseTy::VisitCastExpr(E); 4515 4516 case CK_NullToMemberPointer: 4517 VisitIgnoredValue(E->getSubExpr()); 4518 return ZeroInitialization(E); 4519 4520 case CK_BaseToDerivedMemberPointer: { 4521 if (!Visit(E->getSubExpr())) 4522 return false; 4523 if (E->path_empty()) 4524 return true; 4525 // Base-to-derived member pointer casts store the path in derived-to-base 4526 // order, so iterate backwards. The CXXBaseSpecifier also provides us with 4527 // the wrong end of the derived->base arc, so stagger the path by one class. 4528 typedef std::reverse_iterator<CastExpr::path_const_iterator> ReverseIter; 4529 for (ReverseIter PathI(E->path_end() - 1), PathE(E->path_begin()); 4530 PathI != PathE; ++PathI) { 4531 assert(!(*PathI)->isVirtual() && "memptr cast through vbase"); 4532 const CXXRecordDecl *Derived = (*PathI)->getType()->getAsCXXRecordDecl(); 4533 if (!Result.castToDerived(Derived)) 4534 return Error(E); 4535 } 4536 const Type *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass(); 4537 if (!Result.castToDerived(FinalTy->getAsCXXRecordDecl())) 4538 return Error(E); 4539 return true; 4540 } 4541 4542 case CK_DerivedToBaseMemberPointer: 4543 if (!Visit(E->getSubExpr())) 4544 return false; 4545 for (CastExpr::path_const_iterator PathI = E->path_begin(), 4546 PathE = E->path_end(); PathI != PathE; ++PathI) { 4547 assert(!(*PathI)->isVirtual() && "memptr cast through vbase"); 4548 const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl(); 4549 if (!Result.castToBase(Base)) 4550 return Error(E); 4551 } 4552 return true; 4553 } 4554} 4555 4556bool MemberPointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) { 4557 // C++11 [expr.unary.op]p3 has very strict rules on how the address of a 4558 // member can be formed. 4559 return Success(cast<DeclRefExpr>(E->getSubExpr())->getDecl()); 4560} 4561 4562//===----------------------------------------------------------------------===// 4563// Record Evaluation 4564//===----------------------------------------------------------------------===// 4565 4566namespace { 4567 class RecordExprEvaluator 4568 : public ExprEvaluatorBase<RecordExprEvaluator, bool> { 4569 const LValue &This; 4570 APValue &Result; 4571 public: 4572 4573 RecordExprEvaluator(EvalInfo &info, const LValue &This, APValue &Result) 4574 : ExprEvaluatorBaseTy(info), This(This), Result(Result) {} 4575 4576 bool Success(const APValue &V, const Expr *E) { 4577 Result = V; 4578 return true; 4579 } 4580 bool ZeroInitialization(const Expr *E); 4581 4582 bool VisitCastExpr(const CastExpr *E); 4583 bool VisitInitListExpr(const InitListExpr *E); 4584 bool VisitCXXConstructExpr(const CXXConstructExpr *E); 4585 bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E); 4586 }; 4587} 4588 4589/// Perform zero-initialization on an object of non-union class type. 4590/// C++11 [dcl.init]p5: 4591/// To zero-initialize an object or reference of type T means: 4592/// [...] 4593/// -- if T is a (possibly cv-qualified) non-union class type, 4594/// each non-static data member and each base-class subobject is 4595/// zero-initialized 4596static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E, 4597 const RecordDecl *RD, 4598 const LValue &This, APValue &Result) { 4599 assert(!RD->isUnion() && "Expected non-union class type"); 4600 const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD); 4601 Result = APValue(APValue::UninitStruct(), CD ? CD->getNumBases() : 0, 4602 std::distance(RD->field_begin(), RD->field_end())); 4603 4604 if (RD->isInvalidDecl()) return false; 4605 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 4606 4607 if (CD) { 4608 unsigned Index = 0; 4609 for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(), 4610 End = CD->bases_end(); I != End; ++I, ++Index) { 4611 const CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl(); 4612 LValue Subobject = This; 4613 if (!HandleLValueDirectBase(Info, E, Subobject, CD, Base, &Layout)) 4614 return false; 4615 if (!HandleClassZeroInitialization(Info, E, Base, Subobject, 4616 Result.getStructBase(Index))) 4617 return false; 4618 } 4619 } 4620 4621 for (RecordDecl::field_iterator I = RD->field_begin(), End = RD->field_end(); 4622 I != End; ++I) { 4623 // -- if T is a reference type, no initialization is performed. 4624 if (I->getType()->isReferenceType()) 4625 continue; 4626 4627 LValue Subobject = This; 4628 if (!HandleLValueMember(Info, E, Subobject, *I, &Layout)) 4629 return false; 4630 4631 ImplicitValueInitExpr VIE(I->getType()); 4632 if (!EvaluateInPlace( 4633 Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE)) 4634 return false; 4635 } 4636 4637 return true; 4638} 4639 4640bool RecordExprEvaluator::ZeroInitialization(const Expr *E) { 4641 const RecordDecl *RD = E->getType()->castAs<RecordType>()->getDecl(); 4642 if (RD->isInvalidDecl()) return false; 4643 if (RD->isUnion()) { 4644 // C++11 [dcl.init]p5: If T is a (possibly cv-qualified) union type, the 4645 // object's first non-static named data member is zero-initialized 4646 RecordDecl::field_iterator I = RD->field_begin(); 4647 if (I == RD->field_end()) { 4648 Result = APValue((const FieldDecl*)0); 4649 return true; 4650 } 4651 4652 LValue Subobject = This; 4653 if (!HandleLValueMember(Info, E, Subobject, *I)) 4654 return false; 4655 Result = APValue(*I); 4656 ImplicitValueInitExpr VIE(I->getType()); 4657 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, &VIE); 4658 } 4659 4660 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->getNumVBases()) { 4661 Info.Diag(E, diag::note_constexpr_virtual_base) << RD; 4662 return false; 4663 } 4664 4665 return HandleClassZeroInitialization(Info, E, RD, This, Result); 4666} 4667 4668bool RecordExprEvaluator::VisitCastExpr(const CastExpr *E) { 4669 switch (E->getCastKind()) { 4670 default: 4671 return ExprEvaluatorBaseTy::VisitCastExpr(E); 4672 4673 case CK_ConstructorConversion: 4674 return Visit(E->getSubExpr()); 4675 4676 case CK_DerivedToBase: 4677 case CK_UncheckedDerivedToBase: { 4678 APValue DerivedObject; 4679 if (!Evaluate(DerivedObject, Info, E->getSubExpr())) 4680 return false; 4681 if (!DerivedObject.isStruct()) 4682 return Error(E->getSubExpr()); 4683 4684 // Derived-to-base rvalue conversion: just slice off the derived part. 4685 APValue *Value = &DerivedObject; 4686 const CXXRecordDecl *RD = E->getSubExpr()->getType()->getAsCXXRecordDecl(); 4687 for (CastExpr::path_const_iterator PathI = E->path_begin(), 4688 PathE = E->path_end(); PathI != PathE; ++PathI) { 4689 assert(!(*PathI)->isVirtual() && "record rvalue with virtual base"); 4690 const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl(); 4691 Value = &Value->getStructBase(getBaseIndex(RD, Base)); 4692 RD = Base; 4693 } 4694 Result = *Value; 4695 return true; 4696 } 4697 } 4698} 4699 4700bool RecordExprEvaluator::VisitInitListExpr(const InitListExpr *E) { 4701 const RecordDecl *RD = E->getType()->castAs<RecordType>()->getDecl(); 4702 if (RD->isInvalidDecl()) return false; 4703 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 4704 4705 if (RD->isUnion()) { 4706 const FieldDecl *Field = E->getInitializedFieldInUnion(); 4707 Result = APValue(Field); 4708 if (!Field) 4709 return true; 4710 4711 // If the initializer list for a union does not contain any elements, the 4712 // first element of the union is value-initialized. 4713 // FIXME: The element should be initialized from an initializer list. 4714 // Is this difference ever observable for initializer lists which 4715 // we don't build? 4716 ImplicitValueInitExpr VIE(Field->getType()); 4717 const Expr *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE; 4718 4719 LValue Subobject = This; 4720 if (!HandleLValueMember(Info, InitExpr, Subobject, Field, &Layout)) 4721 return false; 4722 4723 // Temporarily override This, in case there's a CXXDefaultInitExpr in here. 4724 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This, 4725 isa<CXXDefaultInitExpr>(InitExpr)); 4726 4727 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, InitExpr); 4728 } 4729 4730 assert((!isa<CXXRecordDecl>(RD) || !cast<CXXRecordDecl>(RD)->getNumBases()) && 4731 "initializer list for class with base classes"); 4732 Result = APValue(APValue::UninitStruct(), 0, 4733 std::distance(RD->field_begin(), RD->field_end())); 4734 unsigned ElementNo = 0; 4735 bool Success = true; 4736 for (RecordDecl::field_iterator Field = RD->field_begin(), 4737 FieldEnd = RD->field_end(); Field != FieldEnd; ++Field) { 4738 // Anonymous bit-fields are not considered members of the class for 4739 // purposes of aggregate initialization. 4740 if (Field->isUnnamedBitfield()) 4741 continue; 4742 4743 LValue Subobject = This; 4744 4745 bool HaveInit = ElementNo < E->getNumInits(); 4746 4747 // FIXME: Diagnostics here should point to the end of the initializer 4748 // list, not the start. 4749 if (!HandleLValueMember(Info, HaveInit ? E->getInit(ElementNo) : E, 4750 Subobject, *Field, &Layout)) 4751 return false; 4752 4753 // Perform an implicit value-initialization for members beyond the end of 4754 // the initializer list. 4755 ImplicitValueInitExpr VIE(HaveInit ? Info.Ctx.IntTy : Field->getType()); 4756 const Expr *Init = HaveInit ? E->getInit(ElementNo++) : &VIE; 4757 4758 // Temporarily override This, in case there's a CXXDefaultInitExpr in here. 4759 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This, 4760 isa<CXXDefaultInitExpr>(Init)); 4761 4762 if (!EvaluateInPlace(Result.getStructField(Field->getFieldIndex()), Info, 4763 Subobject, Init)) { 4764 if (!Info.keepEvaluatingAfterFailure()) 4765 return false; 4766 Success = false; 4767 } 4768 } 4769 4770 return Success; 4771} 4772 4773bool RecordExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E) { 4774 const CXXConstructorDecl *FD = E->getConstructor(); 4775 if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl()) return false; 4776 4777 bool ZeroInit = E->requiresZeroInitialization(); 4778 if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) { 4779 // If we've already performed zero-initialization, we're already done. 4780 if (!Result.isUninit()) 4781 return true; 4782 4783 if (ZeroInit) 4784 return ZeroInitialization(E); 4785 4786 const CXXRecordDecl *RD = FD->getParent(); 4787 if (RD->isUnion()) 4788 Result = APValue((FieldDecl*)0); 4789 else 4790 Result = APValue(APValue::UninitStruct(), RD->getNumBases(), 4791 std::distance(RD->field_begin(), RD->field_end())); 4792 return true; 4793 } 4794 4795 const FunctionDecl *Definition = 0; 4796 FD->getBody(Definition); 4797 4798 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition)) 4799 return false; 4800 4801 // Avoid materializing a temporary for an elidable copy/move constructor. 4802 if (E->isElidable() && !ZeroInit) 4803 if (const MaterializeTemporaryExpr *ME 4804 = dyn_cast<MaterializeTemporaryExpr>(E->getArg(0))) 4805 return Visit(ME->GetTemporaryExpr()); 4806 4807 if (ZeroInit && !ZeroInitialization(E)) 4808 return false; 4809 4810 ArrayRef<const Expr *> Args(E->getArgs(), E->getNumArgs()); 4811 return HandleConstructorCall(E->getExprLoc(), This, Args, 4812 cast<CXXConstructorDecl>(Definition), Info, 4813 Result); 4814} 4815 4816bool RecordExprEvaluator::VisitCXXStdInitializerListExpr( 4817 const CXXStdInitializerListExpr *E) { 4818 const ConstantArrayType *ArrayType = 4819 Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType()); 4820 4821 LValue Array; 4822 if (!EvaluateLValue(E->getSubExpr(), Array, Info)) 4823 return false; 4824 4825 // Get a pointer to the first element of the array. 4826 Array.addArray(Info, E, ArrayType); 4827 4828 // FIXME: Perform the checks on the field types in SemaInit. 4829 RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl(); 4830 RecordDecl::field_iterator Field = Record->field_begin(); 4831 if (Field == Record->field_end()) 4832 return Error(E); 4833 4834 // Start pointer. 4835 if (!Field->getType()->isPointerType() || 4836 !Info.Ctx.hasSameType(Field->getType()->getPointeeType(), 4837 ArrayType->getElementType())) 4838 return Error(E); 4839 4840 // FIXME: What if the initializer_list type has base classes, etc? 4841 Result = APValue(APValue::UninitStruct(), 0, 2); 4842 Array.moveInto(Result.getStructField(0)); 4843 4844 if (++Field == Record->field_end()) 4845 return Error(E); 4846 4847 if (Field->getType()->isPointerType() && 4848 Info.Ctx.hasSameType(Field->getType()->getPointeeType(), 4849 ArrayType->getElementType())) { 4850 // End pointer. 4851 if (!HandleLValueArrayAdjustment(Info, E, Array, 4852 ArrayType->getElementType(), 4853 ArrayType->getSize().getZExtValue())) 4854 return false; 4855 Array.moveInto(Result.getStructField(1)); 4856 } else if (Info.Ctx.hasSameType(Field->getType(), Info.Ctx.getSizeType())) 4857 // Length. 4858 Result.getStructField(1) = APValue(APSInt(ArrayType->getSize())); 4859 else 4860 return Error(E); 4861 4862 if (++Field != Record->field_end()) 4863 return Error(E); 4864 4865 return true; 4866} 4867 4868static bool EvaluateRecord(const Expr *E, const LValue &This, 4869 APValue &Result, EvalInfo &Info) { 4870 assert(E->isRValue() && E->getType()->isRecordType() && 4871 "can't evaluate expression as a record rvalue"); 4872 return RecordExprEvaluator(Info, This, Result).Visit(E); 4873} 4874 4875//===----------------------------------------------------------------------===// 4876// Temporary Evaluation 4877// 4878// Temporaries are represented in the AST as rvalues, but generally behave like 4879// lvalues. The full-object of which the temporary is a subobject is implicitly 4880// materialized so that a reference can bind to it. 4881//===----------------------------------------------------------------------===// 4882namespace { 4883class TemporaryExprEvaluator 4884 : public LValueExprEvaluatorBase<TemporaryExprEvaluator> { 4885public: 4886 TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) : 4887 LValueExprEvaluatorBaseTy(Info, Result) {} 4888 4889 /// Visit an expression which constructs the value of this temporary. 4890 bool VisitConstructExpr(const Expr *E) { 4891 Result.set(E, Info.CurrentCall->Index); 4892 return EvaluateInPlace(Info.CurrentCall->Temporaries[E], Info, Result, E); 4893 } 4894 4895 bool VisitCastExpr(const CastExpr *E) { 4896 switch (E->getCastKind()) { 4897 default: 4898 return LValueExprEvaluatorBaseTy::VisitCastExpr(E); 4899 4900 case CK_ConstructorConversion: 4901 return VisitConstructExpr(E->getSubExpr()); 4902 } 4903 } 4904 bool VisitInitListExpr(const InitListExpr *E) { 4905 return VisitConstructExpr(E); 4906 } 4907 bool VisitCXXConstructExpr(const CXXConstructExpr *E) { 4908 return VisitConstructExpr(E); 4909 } 4910 bool VisitCallExpr(const CallExpr *E) { 4911 return VisitConstructExpr(E); 4912 } 4913}; 4914} // end anonymous namespace 4915 4916/// Evaluate an expression of record type as a temporary. 4917static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) { 4918 assert(E->isRValue() && E->getType()->isRecordType()); 4919 return TemporaryExprEvaluator(Info, Result).Visit(E); 4920} 4921 4922//===----------------------------------------------------------------------===// 4923// Vector Evaluation 4924//===----------------------------------------------------------------------===// 4925 4926namespace { 4927 class VectorExprEvaluator 4928 : public ExprEvaluatorBase<VectorExprEvaluator, bool> { 4929 APValue &Result; 4930 public: 4931 4932 VectorExprEvaluator(EvalInfo &info, APValue &Result) 4933 : ExprEvaluatorBaseTy(info), Result(Result) {} 4934 4935 bool Success(const ArrayRef<APValue> &V, const Expr *E) { 4936 assert(V.size() == E->getType()->castAs<VectorType>()->getNumElements()); 4937 // FIXME: remove this APValue copy. 4938 Result = APValue(V.data(), V.size()); 4939 return true; 4940 } 4941 bool Success(const APValue &V, const Expr *E) { 4942 assert(V.isVector()); 4943 Result = V; 4944 return true; 4945 } 4946 bool ZeroInitialization(const Expr *E); 4947 4948 bool VisitUnaryReal(const UnaryOperator *E) 4949 { return Visit(E->getSubExpr()); } 4950 bool VisitCastExpr(const CastExpr* E); 4951 bool VisitInitListExpr(const InitListExpr *E); 4952 bool VisitUnaryImag(const UnaryOperator *E); 4953 // FIXME: Missing: unary -, unary ~, binary add/sub/mul/div, 4954 // binary comparisons, binary and/or/xor, 4955 // shufflevector, ExtVectorElementExpr 4956 }; 4957} // end anonymous namespace 4958 4959static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) { 4960 assert(E->isRValue() && E->getType()->isVectorType() &&"not a vector rvalue"); 4961 return VectorExprEvaluator(Info, Result).Visit(E); 4962} 4963 4964bool VectorExprEvaluator::VisitCastExpr(const CastExpr* E) { 4965 const VectorType *VTy = E->getType()->castAs<VectorType>(); 4966 unsigned NElts = VTy->getNumElements(); 4967 4968 const Expr *SE = E->getSubExpr(); 4969 QualType SETy = SE->getType(); 4970 4971 switch (E->getCastKind()) { 4972 case CK_VectorSplat: { 4973 APValue Val = APValue(); 4974 if (SETy->isIntegerType()) { 4975 APSInt IntResult; 4976 if (!EvaluateInteger(SE, IntResult, Info)) 4977 return false; 4978 Val = APValue(IntResult); 4979 } else if (SETy->isRealFloatingType()) { 4980 APFloat F(0.0); 4981 if (!EvaluateFloat(SE, F, Info)) 4982 return false; 4983 Val = APValue(F); 4984 } else { 4985 return Error(E); 4986 } 4987 4988 // Splat and create vector APValue. 4989 SmallVector<APValue, 4> Elts(NElts, Val); 4990 return Success(Elts, E); 4991 } 4992 case CK_BitCast: { 4993 // Evaluate the operand into an APInt we can extract from. 4994 llvm::APInt SValInt; 4995 if (!EvalAndBitcastToAPInt(Info, SE, SValInt)) 4996 return false; 4997 // Extract the elements 4998 QualType EltTy = VTy->getElementType(); 4999 unsigned EltSize = Info.Ctx.getTypeSize(EltTy); 5000 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian(); 5001 SmallVector<APValue, 4> Elts; 5002 if (EltTy->isRealFloatingType()) { 5003 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(EltTy); 5004 unsigned FloatEltSize = EltSize; 5005 if (&Sem == &APFloat::x87DoubleExtended) 5006 FloatEltSize = 80; 5007 for (unsigned i = 0; i < NElts; i++) { 5008 llvm::APInt Elt; 5009 if (BigEndian) 5010 Elt = SValInt.rotl(i*EltSize+FloatEltSize).trunc(FloatEltSize); 5011 else 5012 Elt = SValInt.rotr(i*EltSize).trunc(FloatEltSize); 5013 Elts.push_back(APValue(APFloat(Sem, Elt))); 5014 } 5015 } else if (EltTy->isIntegerType()) { 5016 for (unsigned i = 0; i < NElts; i++) { 5017 llvm::APInt Elt; 5018 if (BigEndian) 5019 Elt = SValInt.rotl(i*EltSize+EltSize).zextOrTrunc(EltSize); 5020 else 5021 Elt = SValInt.rotr(i*EltSize).zextOrTrunc(EltSize); 5022 Elts.push_back(APValue(APSInt(Elt, EltTy->isSignedIntegerType()))); 5023 } 5024 } else { 5025 return Error(E); 5026 } 5027 return Success(Elts, E); 5028 } 5029 default: 5030 return ExprEvaluatorBaseTy::VisitCastExpr(E); 5031 } 5032} 5033 5034bool 5035VectorExprEvaluator::VisitInitListExpr(const InitListExpr *E) { 5036 const VectorType *VT = E->getType()->castAs<VectorType>(); 5037 unsigned NumInits = E->getNumInits(); 5038 unsigned NumElements = VT->getNumElements(); 5039 5040 QualType EltTy = VT->getElementType(); 5041 SmallVector<APValue, 4> Elements; 5042 5043 // The number of initializers can be less than the number of 5044 // vector elements. For OpenCL, this can be due to nested vector 5045 // initialization. For GCC compatibility, missing trailing elements 5046 // should be initialized with zeroes. 5047 unsigned CountInits = 0, CountElts = 0; 5048 while (CountElts < NumElements) { 5049 // Handle nested vector initialization. 5050 if (CountInits < NumInits 5051 && E->getInit(CountInits)->getType()->isExtVectorType()) { 5052 APValue v; 5053 if (!EvaluateVector(E->getInit(CountInits), v, Info)) 5054 return Error(E); 5055 unsigned vlen = v.getVectorLength(); 5056 for (unsigned j = 0; j < vlen; j++) 5057 Elements.push_back(v.getVectorElt(j)); 5058 CountElts += vlen; 5059 } else if (EltTy->isIntegerType()) { 5060 llvm::APSInt sInt(32); 5061 if (CountInits < NumInits) { 5062 if (!EvaluateInteger(E->getInit(CountInits), sInt, Info)) 5063 return false; 5064 } else // trailing integer zero. 5065 sInt = Info.Ctx.MakeIntValue(0, EltTy); 5066 Elements.push_back(APValue(sInt)); 5067 CountElts++; 5068 } else { 5069 llvm::APFloat f(0.0); 5070 if (CountInits < NumInits) { 5071 if (!EvaluateFloat(E->getInit(CountInits), f, Info)) 5072 return false; 5073 } else // trailing float zero. 5074 f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)); 5075 Elements.push_back(APValue(f)); 5076 CountElts++; 5077 } 5078 CountInits++; 5079 } 5080 return Success(Elements, E); 5081} 5082 5083bool 5084VectorExprEvaluator::ZeroInitialization(const Expr *E) { 5085 const VectorType *VT = E->getType()->getAs<VectorType>(); 5086 QualType EltTy = VT->getElementType(); 5087 APValue ZeroElement; 5088 if (EltTy->isIntegerType()) 5089 ZeroElement = APValue(Info.Ctx.MakeIntValue(0, EltTy)); 5090 else 5091 ZeroElement = 5092 APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy))); 5093 5094 SmallVector<APValue, 4> Elements(VT->getNumElements(), ZeroElement); 5095 return Success(Elements, E); 5096} 5097 5098bool VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) { 5099 VisitIgnoredValue(E->getSubExpr()); 5100 return ZeroInitialization(E); 5101} 5102 5103//===----------------------------------------------------------------------===// 5104// Array Evaluation 5105//===----------------------------------------------------------------------===// 5106 5107namespace { 5108 class ArrayExprEvaluator 5109 : public ExprEvaluatorBase<ArrayExprEvaluator, bool> { 5110 const LValue &This; 5111 APValue &Result; 5112 public: 5113 5114 ArrayExprEvaluator(EvalInfo &Info, const LValue &This, APValue &Result) 5115 : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {} 5116 5117 bool Success(const APValue &V, const Expr *E) { 5118 assert((V.isArray() || V.isLValue()) && 5119 "expected array or string literal"); 5120 Result = V; 5121 return true; 5122 } 5123 5124 bool ZeroInitialization(const Expr *E) { 5125 const ConstantArrayType *CAT = 5126 Info.Ctx.getAsConstantArrayType(E->getType()); 5127 if (!CAT) 5128 return Error(E); 5129 5130 Result = APValue(APValue::UninitArray(), 0, 5131 CAT->getSize().getZExtValue()); 5132 if (!Result.hasArrayFiller()) return true; 5133 5134 // Zero-initialize all elements. 5135 LValue Subobject = This; 5136 Subobject.addArray(Info, E, CAT); 5137 ImplicitValueInitExpr VIE(CAT->getElementType()); 5138 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE); 5139 } 5140 5141 bool VisitInitListExpr(const InitListExpr *E); 5142 bool VisitCXXConstructExpr(const CXXConstructExpr *E); 5143 bool VisitCXXConstructExpr(const CXXConstructExpr *E, 5144 const LValue &Subobject, 5145 APValue *Value, QualType Type); 5146 }; 5147} // end anonymous namespace 5148 5149static bool EvaluateArray(const Expr *E, const LValue &This, 5150 APValue &Result, EvalInfo &Info) { 5151 assert(E->isRValue() && E->getType()->isArrayType() && "not an array rvalue"); 5152 return ArrayExprEvaluator(Info, This, Result).Visit(E); 5153} 5154 5155bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E) { 5156 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(E->getType()); 5157 if (!CAT) 5158 return Error(E); 5159 5160 // C++11 [dcl.init.string]p1: A char array [...] can be initialized by [...] 5161 // an appropriately-typed string literal enclosed in braces. 5162 if (E->isStringLiteralInit()) { 5163 LValue LV; 5164 if (!EvaluateLValue(E->getInit(0), LV, Info)) 5165 return false; 5166 APValue Val; 5167 LV.moveInto(Val); 5168 return Success(Val, E); 5169 } 5170 5171 bool Success = true; 5172 5173 assert((!Result.isArray() || Result.getArrayInitializedElts() == 0) && 5174 "zero-initialized array shouldn't have any initialized elts"); 5175 APValue Filler; 5176 if (Result.isArray() && Result.hasArrayFiller()) 5177 Filler = Result.getArrayFiller(); 5178 5179 unsigned NumEltsToInit = E->getNumInits(); 5180 unsigned NumElts = CAT->getSize().getZExtValue(); 5181 const Expr *FillerExpr = E->hasArrayFiller() ? E->getArrayFiller() : 0; 5182 5183 // If the initializer might depend on the array index, run it for each 5184 // array element. For now, just whitelist non-class value-initialization. 5185 if (NumEltsToInit != NumElts && !isa<ImplicitValueInitExpr>(FillerExpr)) 5186 NumEltsToInit = NumElts; 5187 5188 Result = APValue(APValue::UninitArray(), NumEltsToInit, NumElts); 5189 5190 // If the array was previously zero-initialized, preserve the 5191 // zero-initialized values. 5192 if (!Filler.isUninit()) { 5193 for (unsigned I = 0, E = Result.getArrayInitializedElts(); I != E; ++I) 5194 Result.getArrayInitializedElt(I) = Filler; 5195 if (Result.hasArrayFiller()) 5196 Result.getArrayFiller() = Filler; 5197 } 5198 5199 LValue Subobject = This; 5200 Subobject.addArray(Info, E, CAT); 5201 for (unsigned Index = 0; Index != NumEltsToInit; ++Index) { 5202 const Expr *Init = 5203 Index < E->getNumInits() ? E->getInit(Index) : FillerExpr; 5204 if (!EvaluateInPlace(Result.getArrayInitializedElt(Index), 5205 Info, Subobject, Init) || 5206 !HandleLValueArrayAdjustment(Info, Init, Subobject, 5207 CAT->getElementType(), 1)) { 5208 if (!Info.keepEvaluatingAfterFailure()) 5209 return false; 5210 Success = false; 5211 } 5212 } 5213 5214 if (!Result.hasArrayFiller()) 5215 return Success; 5216 5217 // If we get here, we have a trivial filler, which we can just evaluate 5218 // once and splat over the rest of the array elements. 5219 assert(FillerExpr && "no array filler for incomplete init list"); 5220 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, 5221 FillerExpr) && Success; 5222} 5223 5224bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E) { 5225 return VisitCXXConstructExpr(E, This, &Result, E->getType()); 5226} 5227 5228bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E, 5229 const LValue &Subobject, 5230 APValue *Value, 5231 QualType Type) { 5232 bool HadZeroInit = !Value->isUninit(); 5233 5234 if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(Type)) { 5235 unsigned N = CAT->getSize().getZExtValue(); 5236 5237 // Preserve the array filler if we had prior zero-initialization. 5238 APValue Filler = 5239 HadZeroInit && Value->hasArrayFiller() ? Value->getArrayFiller() 5240 : APValue(); 5241 5242 *Value = APValue(APValue::UninitArray(), N, N); 5243 5244 if (HadZeroInit) 5245 for (unsigned I = 0; I != N; ++I) 5246 Value->getArrayInitializedElt(I) = Filler; 5247 5248 // Initialize the elements. 5249 LValue ArrayElt = Subobject; 5250 ArrayElt.addArray(Info, E, CAT); 5251 for (unsigned I = 0; I != N; ++I) 5252 if (!VisitCXXConstructExpr(E, ArrayElt, &Value->getArrayInitializedElt(I), 5253 CAT->getElementType()) || 5254 !HandleLValueArrayAdjustment(Info, E, ArrayElt, 5255 CAT->getElementType(), 1)) 5256 return false; 5257 5258 return true; 5259 } 5260 5261 if (!Type->isRecordType()) 5262 return Error(E); 5263 5264 const CXXConstructorDecl *FD = E->getConstructor(); 5265 5266 bool ZeroInit = E->requiresZeroInitialization(); 5267 if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) { 5268 if (HadZeroInit) 5269 return true; 5270 5271 if (ZeroInit) { 5272 ImplicitValueInitExpr VIE(Type); 5273 return EvaluateInPlace(*Value, Info, Subobject, &VIE); 5274 } 5275 5276 const CXXRecordDecl *RD = FD->getParent(); 5277 if (RD->isUnion()) 5278 *Value = APValue((FieldDecl*)0); 5279 else 5280 *Value = 5281 APValue(APValue::UninitStruct(), RD->getNumBases(), 5282 std::distance(RD->field_begin(), RD->field_end())); 5283 return true; 5284 } 5285 5286 const FunctionDecl *Definition = 0; 5287 FD->getBody(Definition); 5288 5289 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition)) 5290 return false; 5291 5292 if (ZeroInit && !HadZeroInit) { 5293 ImplicitValueInitExpr VIE(Type); 5294 if (!EvaluateInPlace(*Value, Info, Subobject, &VIE)) 5295 return false; 5296 } 5297 5298 ArrayRef<const Expr *> Args(E->getArgs(), E->getNumArgs()); 5299 return HandleConstructorCall(E->getExprLoc(), Subobject, Args, 5300 cast<CXXConstructorDecl>(Definition), 5301 Info, *Value); 5302} 5303 5304//===----------------------------------------------------------------------===// 5305// Integer Evaluation 5306// 5307// As a GNU extension, we support casting pointers to sufficiently-wide integer 5308// types and back in constant folding. Integer values are thus represented 5309// either as an integer-valued APValue, or as an lvalue-valued APValue. 5310//===----------------------------------------------------------------------===// 5311 5312namespace { 5313class IntExprEvaluator 5314 : public ExprEvaluatorBase<IntExprEvaluator, bool> { 5315 APValue &Result; 5316public: 5317 IntExprEvaluator(EvalInfo &info, APValue &result) 5318 : ExprEvaluatorBaseTy(info), Result(result) {} 5319 5320 bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) { 5321 assert(E->getType()->isIntegralOrEnumerationType() && 5322 "Invalid evaluation result."); 5323 assert(SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType() && 5324 "Invalid evaluation result."); 5325 assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) && 5326 "Invalid evaluation result."); 5327 Result = APValue(SI); 5328 return true; 5329 } 5330 bool Success(const llvm::APSInt &SI, const Expr *E) { 5331 return Success(SI, E, Result); 5332 } 5333 5334 bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) { 5335 assert(E->getType()->isIntegralOrEnumerationType() && 5336 "Invalid evaluation result."); 5337 assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) && 5338 "Invalid evaluation result."); 5339 Result = APValue(APSInt(I)); 5340 Result.getInt().setIsUnsigned( 5341 E->getType()->isUnsignedIntegerOrEnumerationType()); 5342 return true; 5343 } 5344 bool Success(const llvm::APInt &I, const Expr *E) { 5345 return Success(I, E, Result); 5346 } 5347 5348 bool Success(uint64_t Value, const Expr *E, APValue &Result) { 5349 assert(E->getType()->isIntegralOrEnumerationType() && 5350 "Invalid evaluation result."); 5351 Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType())); 5352 return true; 5353 } 5354 bool Success(uint64_t Value, const Expr *E) { 5355 return Success(Value, E, Result); 5356 } 5357 5358 bool Success(CharUnits Size, const Expr *E) { 5359 return Success(Size.getQuantity(), E); 5360 } 5361 5362 bool Success(const APValue &V, const Expr *E) { 5363 if (V.isLValue() || V.isAddrLabelDiff()) { 5364 Result = V; 5365 return true; 5366 } 5367 return Success(V.getInt(), E); 5368 } 5369 5370 bool ZeroInitialization(const Expr *E) { return Success(0, E); } 5371 5372 //===--------------------------------------------------------------------===// 5373 // Visitor Methods 5374 //===--------------------------------------------------------------------===// 5375 5376 bool VisitIntegerLiteral(const IntegerLiteral *E) { 5377 return Success(E->getValue(), E); 5378 } 5379 bool VisitCharacterLiteral(const CharacterLiteral *E) { 5380 return Success(E->getValue(), E); 5381 } 5382 5383 bool CheckReferencedDecl(const Expr *E, const Decl *D); 5384 bool VisitDeclRefExpr(const DeclRefExpr *E) { 5385 if (CheckReferencedDecl(E, E->getDecl())) 5386 return true; 5387 5388 return ExprEvaluatorBaseTy::VisitDeclRefExpr(E); 5389 } 5390 bool VisitMemberExpr(const MemberExpr *E) { 5391 if (CheckReferencedDecl(E, E->getMemberDecl())) { 5392 VisitIgnoredValue(E->getBase()); 5393 return true; 5394 } 5395 5396 return ExprEvaluatorBaseTy::VisitMemberExpr(E); 5397 } 5398 5399 bool VisitCallExpr(const CallExpr *E); 5400 bool VisitBinaryOperator(const BinaryOperator *E); 5401 bool VisitOffsetOfExpr(const OffsetOfExpr *E); 5402 bool VisitUnaryOperator(const UnaryOperator *E); 5403 5404 bool VisitCastExpr(const CastExpr* E); 5405 bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E); 5406 5407 bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 5408 return Success(E->getValue(), E); 5409 } 5410 5411 bool VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) { 5412 return Success(E->getValue(), E); 5413 } 5414 5415 // Note, GNU defines __null as an integer, not a pointer. 5416 bool VisitGNUNullExpr(const GNUNullExpr *E) { 5417 return ZeroInitialization(E); 5418 } 5419 5420 bool VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 5421 return Success(E->getValue(), E); 5422 } 5423 5424 bool VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *E) { 5425 return Success(E->getValue(), E); 5426 } 5427 5428 bool VisitTypeTraitExpr(const TypeTraitExpr *E) { 5429 return Success(E->getValue(), E); 5430 } 5431 5432 bool VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) { 5433 return Success(E->getValue(), E); 5434 } 5435 5436 bool VisitExpressionTraitExpr(const ExpressionTraitExpr *E) { 5437 return Success(E->getValue(), E); 5438 } 5439 5440 bool VisitUnaryReal(const UnaryOperator *E); 5441 bool VisitUnaryImag(const UnaryOperator *E); 5442 5443 bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E); 5444 bool VisitSizeOfPackExpr(const SizeOfPackExpr *E); 5445 5446private: 5447 CharUnits GetAlignOfExpr(const Expr *E); 5448 CharUnits GetAlignOfType(QualType T); 5449 static QualType GetObjectType(APValue::LValueBase B); 5450 bool TryEvaluateBuiltinObjectSize(const CallExpr *E); 5451 // FIXME: Missing: array subscript of vector, member of vector 5452}; 5453} // end anonymous namespace 5454 5455/// EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and 5456/// produce either the integer value or a pointer. 5457/// 5458/// GCC has a heinous extension which folds casts between pointer types and 5459/// pointer-sized integral types. We support this by allowing the evaluation of 5460/// an integer rvalue to produce a pointer (represented as an lvalue) instead. 5461/// Some simple arithmetic on such values is supported (they are treated much 5462/// like char*). 5463static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result, 5464 EvalInfo &Info) { 5465 assert(E->isRValue() && E->getType()->isIntegralOrEnumerationType()); 5466 return IntExprEvaluator(Info, Result).Visit(E); 5467} 5468 5469static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) { 5470 APValue Val; 5471 if (!EvaluateIntegerOrLValue(E, Val, Info)) 5472 return false; 5473 if (!Val.isInt()) { 5474 // FIXME: It would be better to produce the diagnostic for casting 5475 // a pointer to an integer. 5476 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr); 5477 return false; 5478 } 5479 Result = Val.getInt(); 5480 return true; 5481} 5482 5483/// Check whether the given declaration can be directly converted to an integral 5484/// rvalue. If not, no diagnostic is produced; there are other things we can 5485/// try. 5486bool IntExprEvaluator::CheckReferencedDecl(const Expr* E, const Decl* D) { 5487 // Enums are integer constant exprs. 5488 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) { 5489 // Check for signedness/width mismatches between E type and ECD value. 5490 bool SameSign = (ECD->getInitVal().isSigned() 5491 == E->getType()->isSignedIntegerOrEnumerationType()); 5492 bool SameWidth = (ECD->getInitVal().getBitWidth() 5493 == Info.Ctx.getIntWidth(E->getType())); 5494 if (SameSign && SameWidth) 5495 return Success(ECD->getInitVal(), E); 5496 else { 5497 // Get rid of mismatch (otherwise Success assertions will fail) 5498 // by computing a new value matching the type of E. 5499 llvm::APSInt Val = ECD->getInitVal(); 5500 if (!SameSign) 5501 Val.setIsSigned(!ECD->getInitVal().isSigned()); 5502 if (!SameWidth) 5503 Val = Val.extOrTrunc(Info.Ctx.getIntWidth(E->getType())); 5504 return Success(Val, E); 5505 } 5506 } 5507 return false; 5508} 5509 5510/// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way 5511/// as GCC. 5512static int EvaluateBuiltinClassifyType(const CallExpr *E) { 5513 // The following enum mimics the values returned by GCC. 5514 // FIXME: Does GCC differ between lvalue and rvalue references here? 5515 enum gcc_type_class { 5516 no_type_class = -1, 5517 void_type_class, integer_type_class, char_type_class, 5518 enumeral_type_class, boolean_type_class, 5519 pointer_type_class, reference_type_class, offset_type_class, 5520 real_type_class, complex_type_class, 5521 function_type_class, method_type_class, 5522 record_type_class, union_type_class, 5523 array_type_class, string_type_class, 5524 lang_type_class 5525 }; 5526 5527 // If no argument was supplied, default to "no_type_class". This isn't 5528 // ideal, however it is what gcc does. 5529 if (E->getNumArgs() == 0) 5530 return no_type_class; 5531 5532 QualType ArgTy = E->getArg(0)->getType(); 5533 if (ArgTy->isVoidType()) 5534 return void_type_class; 5535 else if (ArgTy->isEnumeralType()) 5536 return enumeral_type_class; 5537 else if (ArgTy->isBooleanType()) 5538 return boolean_type_class; 5539 else if (ArgTy->isCharType()) 5540 return string_type_class; // gcc doesn't appear to use char_type_class 5541 else if (ArgTy->isIntegerType()) 5542 return integer_type_class; 5543 else if (ArgTy->isPointerType()) 5544 return pointer_type_class; 5545 else if (ArgTy->isReferenceType()) 5546 return reference_type_class; 5547 else if (ArgTy->isRealType()) 5548 return real_type_class; 5549 else if (ArgTy->isComplexType()) 5550 return complex_type_class; 5551 else if (ArgTy->isFunctionType()) 5552 return function_type_class; 5553 else if (ArgTy->isStructureOrClassType()) 5554 return record_type_class; 5555 else if (ArgTy->isUnionType()) 5556 return union_type_class; 5557 else if (ArgTy->isArrayType()) 5558 return array_type_class; 5559 else if (ArgTy->isUnionType()) 5560 return union_type_class; 5561 else // FIXME: offset_type_class, method_type_class, & lang_type_class? 5562 llvm_unreachable("CallExpr::isBuiltinClassifyType(): unimplemented type"); 5563} 5564 5565/// EvaluateBuiltinConstantPForLValue - Determine the result of 5566/// __builtin_constant_p when applied to the given lvalue. 5567/// 5568/// An lvalue is only "constant" if it is a pointer or reference to the first 5569/// character of a string literal. 5570template<typename LValue> 5571static bool EvaluateBuiltinConstantPForLValue(const LValue &LV) { 5572 const Expr *E = LV.getLValueBase().template dyn_cast<const Expr*>(); 5573 return E && isa<StringLiteral>(E) && LV.getLValueOffset().isZero(); 5574} 5575 5576/// EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to 5577/// GCC as we can manage. 5578static bool EvaluateBuiltinConstantP(ASTContext &Ctx, const Expr *Arg) { 5579 QualType ArgType = Arg->getType(); 5580 5581 // __builtin_constant_p always has one operand. The rules which gcc follows 5582 // are not precisely documented, but are as follows: 5583 // 5584 // - If the operand is of integral, floating, complex or enumeration type, 5585 // and can be folded to a known value of that type, it returns 1. 5586 // - If the operand and can be folded to a pointer to the first character 5587 // of a string literal (or such a pointer cast to an integral type), it 5588 // returns 1. 5589 // 5590 // Otherwise, it returns 0. 5591 // 5592 // FIXME: GCC also intends to return 1 for literals of aggregate types, but 5593 // its support for this does not currently work. 5594 if (ArgType->isIntegralOrEnumerationType()) { 5595 Expr::EvalResult Result; 5596 if (!Arg->EvaluateAsRValue(Result, Ctx) || Result.HasSideEffects) 5597 return false; 5598 5599 APValue &V = Result.Val; 5600 if (V.getKind() == APValue::Int) 5601 return true; 5602 5603 return EvaluateBuiltinConstantPForLValue(V); 5604 } else if (ArgType->isFloatingType() || ArgType->isAnyComplexType()) { 5605 return Arg->isEvaluatable(Ctx); 5606 } else if (ArgType->isPointerType() || Arg->isGLValue()) { 5607 LValue LV; 5608 Expr::EvalStatus Status; 5609 EvalInfo Info(Ctx, Status); 5610 if ((Arg->isGLValue() ? EvaluateLValue(Arg, LV, Info) 5611 : EvaluatePointer(Arg, LV, Info)) && 5612 !Status.HasSideEffects) 5613 return EvaluateBuiltinConstantPForLValue(LV); 5614 } 5615 5616 // Anything else isn't considered to be sufficiently constant. 5617 return false; 5618} 5619 5620/// Retrieves the "underlying object type" of the given expression, 5621/// as used by __builtin_object_size. 5622QualType IntExprEvaluator::GetObjectType(APValue::LValueBase B) { 5623 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) { 5624 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 5625 return VD->getType(); 5626 } else if (const Expr *E = B.get<const Expr*>()) { 5627 if (isa<CompoundLiteralExpr>(E)) 5628 return E->getType(); 5629 } 5630 5631 return QualType(); 5632} 5633 5634bool IntExprEvaluator::TryEvaluateBuiltinObjectSize(const CallExpr *E) { 5635 LValue Base; 5636 5637 { 5638 // The operand of __builtin_object_size is never evaluated for side-effects. 5639 // If there are any, but we can determine the pointed-to object anyway, then 5640 // ignore the side-effects. 5641 SpeculativeEvaluationRAII SpeculativeEval(Info); 5642 if (!EvaluatePointer(E->getArg(0), Base, Info)) 5643 return false; 5644 } 5645 5646 // If we can prove the base is null, lower to zero now. 5647 if (!Base.getLValueBase()) return Success(0, E); 5648 5649 QualType T = GetObjectType(Base.getLValueBase()); 5650 if (T.isNull() || 5651 T->isIncompleteType() || 5652 T->isFunctionType() || 5653 T->isVariablyModifiedType() || 5654 T->isDependentType()) 5655 return Error(E); 5656 5657 CharUnits Size = Info.Ctx.getTypeSizeInChars(T); 5658 CharUnits Offset = Base.getLValueOffset(); 5659 5660 if (!Offset.isNegative() && Offset <= Size) 5661 Size -= Offset; 5662 else 5663 Size = CharUnits::Zero(); 5664 return Success(Size, E); 5665} 5666 5667bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) { 5668 switch (unsigned BuiltinOp = E->isBuiltinCall()) { 5669 default: 5670 return ExprEvaluatorBaseTy::VisitCallExpr(E); 5671 5672 case Builtin::BI__builtin_object_size: { 5673 if (TryEvaluateBuiltinObjectSize(E)) 5674 return true; 5675 5676 // If evaluating the argument has side-effects, we can't determine the size 5677 // of the object, and so we lower it to unknown now. CodeGen relies on us to 5678 // handle all cases where the expression has side-effects. 5679 if (E->getArg(0)->HasSideEffects(Info.Ctx)) { 5680 if (E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue() <= 1) 5681 return Success(-1ULL, E); 5682 return Success(0, E); 5683 } 5684 5685 // Expression had no side effects, but we couldn't statically determine the 5686 // size of the referenced object. 5687 return Error(E); 5688 } 5689 5690 case Builtin::BI__builtin_bswap16: 5691 case Builtin::BI__builtin_bswap32: 5692 case Builtin::BI__builtin_bswap64: { 5693 APSInt Val; 5694 if (!EvaluateInteger(E->getArg(0), Val, Info)) 5695 return false; 5696 5697 return Success(Val.byteSwap(), E); 5698 } 5699 5700 case Builtin::BI__builtin_classify_type: 5701 return Success(EvaluateBuiltinClassifyType(E), E); 5702 5703 // FIXME: BI__builtin_clrsb 5704 // FIXME: BI__builtin_clrsbl 5705 // FIXME: BI__builtin_clrsbll 5706 5707 case Builtin::BI__builtin_clz: 5708 case Builtin::BI__builtin_clzl: 5709 case Builtin::BI__builtin_clzll: { 5710 APSInt Val; 5711 if (!EvaluateInteger(E->getArg(0), Val, Info)) 5712 return false; 5713 if (!Val) 5714 return Error(E); 5715 5716 return Success(Val.countLeadingZeros(), E); 5717 } 5718 5719 case Builtin::BI__builtin_constant_p: 5720 return Success(EvaluateBuiltinConstantP(Info.Ctx, E->getArg(0)), E); 5721 5722 case Builtin::BI__builtin_ctz: 5723 case Builtin::BI__builtin_ctzl: 5724 case Builtin::BI__builtin_ctzll: { 5725 APSInt Val; 5726 if (!EvaluateInteger(E->getArg(0), Val, Info)) 5727 return false; 5728 if (!Val) 5729 return Error(E); 5730 5731 return Success(Val.countTrailingZeros(), E); 5732 } 5733 5734 case Builtin::BI__builtin_eh_return_data_regno: { 5735 int Operand = E->getArg(0)->EvaluateKnownConstInt(Info.Ctx).getZExtValue(); 5736 Operand = Info.Ctx.getTargetInfo().getEHDataRegisterNumber(Operand); 5737 return Success(Operand, E); 5738 } 5739 5740 case Builtin::BI__builtin_expect: 5741 return Visit(E->getArg(0)); 5742 5743 case Builtin::BI__builtin_ffs: 5744 case Builtin::BI__builtin_ffsl: 5745 case Builtin::BI__builtin_ffsll: { 5746 APSInt Val; 5747 if (!EvaluateInteger(E->getArg(0), Val, Info)) 5748 return false; 5749 5750 unsigned N = Val.countTrailingZeros(); 5751 return Success(N == Val.getBitWidth() ? 0 : N + 1, E); 5752 } 5753 5754 case Builtin::BI__builtin_fpclassify: { 5755 APFloat Val(0.0); 5756 if (!EvaluateFloat(E->getArg(5), Val, Info)) 5757 return false; 5758 unsigned Arg; 5759 switch (Val.getCategory()) { 5760 case APFloat::fcNaN: Arg = 0; break; 5761 case APFloat::fcInfinity: Arg = 1; break; 5762 case APFloat::fcNormal: Arg = Val.isDenormal() ? 3 : 2; break; 5763 case APFloat::fcZero: Arg = 4; break; 5764 } 5765 return Visit(E->getArg(Arg)); 5766 } 5767 5768 case Builtin::BI__builtin_isinf_sign: { 5769 APFloat Val(0.0); 5770 return EvaluateFloat(E->getArg(0), Val, Info) && 5771 Success(Val.isInfinity() ? (Val.isNegative() ? -1 : 1) : 0, E); 5772 } 5773 5774 case Builtin::BI__builtin_parity: 5775 case Builtin::BI__builtin_parityl: 5776 case Builtin::BI__builtin_parityll: { 5777 APSInt Val; 5778 if (!EvaluateInteger(E->getArg(0), Val, Info)) 5779 return false; 5780 5781 return Success(Val.countPopulation() % 2, E); 5782 } 5783 5784 case Builtin::BI__builtin_popcount: 5785 case Builtin::BI__builtin_popcountl: 5786 case Builtin::BI__builtin_popcountll: { 5787 APSInt Val; 5788 if (!EvaluateInteger(E->getArg(0), Val, Info)) 5789 return false; 5790 5791 return Success(Val.countPopulation(), E); 5792 } 5793 5794 case Builtin::BIstrlen: 5795 // A call to strlen is not a constant expression. 5796 if (Info.getLangOpts().CPlusPlus11) 5797 Info.CCEDiag(E, diag::note_constexpr_invalid_function) 5798 << /*isConstexpr*/0 << /*isConstructor*/0 << "'strlen'"; 5799 else 5800 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr); 5801 // Fall through. 5802 case Builtin::BI__builtin_strlen: 5803 // As an extension, we support strlen() and __builtin_strlen() as constant 5804 // expressions when the argument is a string literal. 5805 if (const StringLiteral *S 5806 = dyn_cast<StringLiteral>(E->getArg(0)->IgnoreParenImpCasts())) { 5807 // The string literal may have embedded null characters. Find the first 5808 // one and truncate there. 5809 StringRef Str = S->getString(); 5810 StringRef::size_type Pos = Str.find(0); 5811 if (Pos != StringRef::npos) 5812 Str = Str.substr(0, Pos); 5813 5814 return Success(Str.size(), E); 5815 } 5816 5817 return Error(E); 5818 5819 case Builtin::BI__atomic_always_lock_free: 5820 case Builtin::BI__atomic_is_lock_free: 5821 case Builtin::BI__c11_atomic_is_lock_free: { 5822 APSInt SizeVal; 5823 if (!EvaluateInteger(E->getArg(0), SizeVal, Info)) 5824 return false; 5825 5826 // For __atomic_is_lock_free(sizeof(_Atomic(T))), if the size is a power 5827 // of two less than the maximum inline atomic width, we know it is 5828 // lock-free. If the size isn't a power of two, or greater than the 5829 // maximum alignment where we promote atomics, we know it is not lock-free 5830 // (at least not in the sense of atomic_is_lock_free). Otherwise, 5831 // the answer can only be determined at runtime; for example, 16-byte 5832 // atomics have lock-free implementations on some, but not all, 5833 // x86-64 processors. 5834 5835 // Check power-of-two. 5836 CharUnits Size = CharUnits::fromQuantity(SizeVal.getZExtValue()); 5837 if (Size.isPowerOfTwo()) { 5838 // Check against inlining width. 5839 unsigned InlineWidthBits = 5840 Info.Ctx.getTargetInfo().getMaxAtomicInlineWidth(); 5841 if (Size <= Info.Ctx.toCharUnitsFromBits(InlineWidthBits)) { 5842 if (BuiltinOp == Builtin::BI__c11_atomic_is_lock_free || 5843 Size == CharUnits::One() || 5844 E->getArg(1)->isNullPointerConstant(Info.Ctx, 5845 Expr::NPC_NeverValueDependent)) 5846 // OK, we will inline appropriately-aligned operations of this size, 5847 // and _Atomic(T) is appropriately-aligned. 5848 return Success(1, E); 5849 5850 QualType PointeeType = E->getArg(1)->IgnoreImpCasts()->getType()-> 5851 castAs<PointerType>()->getPointeeType(); 5852 if (!PointeeType->isIncompleteType() && 5853 Info.Ctx.getTypeAlignInChars(PointeeType) >= Size) { 5854 // OK, we will inline operations on this object. 5855 return Success(1, E); 5856 } 5857 } 5858 } 5859 5860 return BuiltinOp == Builtin::BI__atomic_always_lock_free ? 5861 Success(0, E) : Error(E); 5862 } 5863 } 5864} 5865 5866static bool HasSameBase(const LValue &A, const LValue &B) { 5867 if (!A.getLValueBase()) 5868 return !B.getLValueBase(); 5869 if (!B.getLValueBase()) 5870 return false; 5871 5872 if (A.getLValueBase().getOpaqueValue() != 5873 B.getLValueBase().getOpaqueValue()) { 5874 const Decl *ADecl = GetLValueBaseDecl(A); 5875 if (!ADecl) 5876 return false; 5877 const Decl *BDecl = GetLValueBaseDecl(B); 5878 if (!BDecl || ADecl->getCanonicalDecl() != BDecl->getCanonicalDecl()) 5879 return false; 5880 } 5881 5882 return IsGlobalLValue(A.getLValueBase()) || 5883 A.getLValueCallIndex() == B.getLValueCallIndex(); 5884} 5885 5886namespace { 5887 5888/// \brief Data recursive integer evaluator of certain binary operators. 5889/// 5890/// We use a data recursive algorithm for binary operators so that we are able 5891/// to handle extreme cases of chained binary operators without causing stack 5892/// overflow. 5893class DataRecursiveIntBinOpEvaluator { 5894 struct EvalResult { 5895 APValue Val; 5896 bool Failed; 5897 5898 EvalResult() : Failed(false) { } 5899 5900 void swap(EvalResult &RHS) { 5901 Val.swap(RHS.Val); 5902 Failed = RHS.Failed; 5903 RHS.Failed = false; 5904 } 5905 }; 5906 5907 struct Job { 5908 const Expr *E; 5909 EvalResult LHSResult; // meaningful only for binary operator expression. 5910 enum { AnyExprKind, BinOpKind, BinOpVisitedLHSKind } Kind; 5911 5912 Job() : StoredInfo(0) { } 5913 void startSpeculativeEval(EvalInfo &Info) { 5914 OldEvalStatus = Info.EvalStatus; 5915 Info.EvalStatus.Diag = 0; 5916 StoredInfo = &Info; 5917 } 5918 ~Job() { 5919 if (StoredInfo) { 5920 StoredInfo->EvalStatus = OldEvalStatus; 5921 } 5922 } 5923 private: 5924 EvalInfo *StoredInfo; // non-null if status changed. 5925 Expr::EvalStatus OldEvalStatus; 5926 }; 5927 5928 SmallVector<Job, 16> Queue; 5929 5930 IntExprEvaluator &IntEval; 5931 EvalInfo &Info; 5932 APValue &FinalResult; 5933 5934public: 5935 DataRecursiveIntBinOpEvaluator(IntExprEvaluator &IntEval, APValue &Result) 5936 : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) { } 5937 5938 /// \brief True if \param E is a binary operator that we are going to handle 5939 /// data recursively. 5940 /// We handle binary operators that are comma, logical, or that have operands 5941 /// with integral or enumeration type. 5942 static bool shouldEnqueue(const BinaryOperator *E) { 5943 return E->getOpcode() == BO_Comma || 5944 E->isLogicalOp() || 5945 (E->getLHS()->getType()->isIntegralOrEnumerationType() && 5946 E->getRHS()->getType()->isIntegralOrEnumerationType()); 5947 } 5948 5949 bool Traverse(const BinaryOperator *E) { 5950 enqueue(E); 5951 EvalResult PrevResult; 5952 while (!Queue.empty()) 5953 process(PrevResult); 5954 5955 if (PrevResult.Failed) return false; 5956 5957 FinalResult.swap(PrevResult.Val); 5958 return true; 5959 } 5960 5961private: 5962 bool Success(uint64_t Value, const Expr *E, APValue &Result) { 5963 return IntEval.Success(Value, E, Result); 5964 } 5965 bool Success(const APSInt &Value, const Expr *E, APValue &Result) { 5966 return IntEval.Success(Value, E, Result); 5967 } 5968 bool Error(const Expr *E) { 5969 return IntEval.Error(E); 5970 } 5971 bool Error(const Expr *E, diag::kind D) { 5972 return IntEval.Error(E, D); 5973 } 5974 5975 OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) { 5976 return Info.CCEDiag(E, D); 5977 } 5978 5979 // \brief Returns true if visiting the RHS is necessary, false otherwise. 5980 bool VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E, 5981 bool &SuppressRHSDiags); 5982 5983 bool VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult, 5984 const BinaryOperator *E, APValue &Result); 5985 5986 void EvaluateExpr(const Expr *E, EvalResult &Result) { 5987 Result.Failed = !Evaluate(Result.Val, Info, E); 5988 if (Result.Failed) 5989 Result.Val = APValue(); 5990 } 5991 5992 void process(EvalResult &Result); 5993 5994 void enqueue(const Expr *E) { 5995 E = E->IgnoreParens(); 5996 Queue.resize(Queue.size()+1); 5997 Queue.back().E = E; 5998 Queue.back().Kind = Job::AnyExprKind; 5999 } 6000}; 6001 6002} 6003 6004bool DataRecursiveIntBinOpEvaluator:: 6005 VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E, 6006 bool &SuppressRHSDiags) { 6007 if (E->getOpcode() == BO_Comma) { 6008 // Ignore LHS but note if we could not evaluate it. 6009 if (LHSResult.Failed) 6010 Info.EvalStatus.HasSideEffects = true; 6011 return true; 6012 } 6013 6014 if (E->isLogicalOp()) { 6015 bool lhsResult; 6016 if (HandleConversionToBool(LHSResult.Val, lhsResult)) { 6017 // We were able to evaluate the LHS, see if we can get away with not 6018 // evaluating the RHS: 0 && X -> 0, 1 || X -> 1 6019 if (lhsResult == (E->getOpcode() == BO_LOr)) { 6020 Success(lhsResult, E, LHSResult.Val); 6021 return false; // Ignore RHS 6022 } 6023 } else { 6024 // Since we weren't able to evaluate the left hand side, it 6025 // must have had side effects. 6026 Info.EvalStatus.HasSideEffects = true; 6027 6028 // We can't evaluate the LHS; however, sometimes the result 6029 // is determined by the RHS: X && 0 -> 0, X || 1 -> 1. 6030 // Don't ignore RHS and suppress diagnostics from this arm. 6031 SuppressRHSDiags = true; 6032 } 6033 6034 return true; 6035 } 6036 6037 assert(E->getLHS()->getType()->isIntegralOrEnumerationType() && 6038 E->getRHS()->getType()->isIntegralOrEnumerationType()); 6039 6040 if (LHSResult.Failed && !Info.keepEvaluatingAfterFailure()) 6041 return false; // Ignore RHS; 6042 6043 return true; 6044} 6045 6046bool DataRecursiveIntBinOpEvaluator:: 6047 VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult, 6048 const BinaryOperator *E, APValue &Result) { 6049 if (E->getOpcode() == BO_Comma) { 6050 if (RHSResult.Failed) 6051 return false; 6052 Result = RHSResult.Val; 6053 return true; 6054 } 6055 6056 if (E->isLogicalOp()) { 6057 bool lhsResult, rhsResult; 6058 bool LHSIsOK = HandleConversionToBool(LHSResult.Val, lhsResult); 6059 bool RHSIsOK = HandleConversionToBool(RHSResult.Val, rhsResult); 6060 6061 if (LHSIsOK) { 6062 if (RHSIsOK) { 6063 if (E->getOpcode() == BO_LOr) 6064 return Success(lhsResult || rhsResult, E, Result); 6065 else 6066 return Success(lhsResult && rhsResult, E, Result); 6067 } 6068 } else { 6069 if (RHSIsOK) { 6070 // We can't evaluate the LHS; however, sometimes the result 6071 // is determined by the RHS: X && 0 -> 0, X || 1 -> 1. 6072 if (rhsResult == (E->getOpcode() == BO_LOr)) 6073 return Success(rhsResult, E, Result); 6074 } 6075 } 6076 6077 return false; 6078 } 6079 6080 assert(E->getLHS()->getType()->isIntegralOrEnumerationType() && 6081 E->getRHS()->getType()->isIntegralOrEnumerationType()); 6082 6083 if (LHSResult.Failed || RHSResult.Failed) 6084 return false; 6085 6086 const APValue &LHSVal = LHSResult.Val; 6087 const APValue &RHSVal = RHSResult.Val; 6088 6089 // Handle cases like (unsigned long)&a + 4. 6090 if (E->isAdditiveOp() && LHSVal.isLValue() && RHSVal.isInt()) { 6091 Result = LHSVal; 6092 CharUnits AdditionalOffset = CharUnits::fromQuantity( 6093 RHSVal.getInt().getZExtValue()); 6094 if (E->getOpcode() == BO_Add) 6095 Result.getLValueOffset() += AdditionalOffset; 6096 else 6097 Result.getLValueOffset() -= AdditionalOffset; 6098 return true; 6099 } 6100 6101 // Handle cases like 4 + (unsigned long)&a 6102 if (E->getOpcode() == BO_Add && 6103 RHSVal.isLValue() && LHSVal.isInt()) { 6104 Result = RHSVal; 6105 Result.getLValueOffset() += CharUnits::fromQuantity( 6106 LHSVal.getInt().getZExtValue()); 6107 return true; 6108 } 6109 6110 if (E->getOpcode() == BO_Sub && LHSVal.isLValue() && RHSVal.isLValue()) { 6111 // Handle (intptr_t)&&A - (intptr_t)&&B. 6112 if (!LHSVal.getLValueOffset().isZero() || 6113 !RHSVal.getLValueOffset().isZero()) 6114 return false; 6115 const Expr *LHSExpr = LHSVal.getLValueBase().dyn_cast<const Expr*>(); 6116 const Expr *RHSExpr = RHSVal.getLValueBase().dyn_cast<const Expr*>(); 6117 if (!LHSExpr || !RHSExpr) 6118 return false; 6119 const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr); 6120 const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr); 6121 if (!LHSAddrExpr || !RHSAddrExpr) 6122 return false; 6123 // Make sure both labels come from the same function. 6124 if (LHSAddrExpr->getLabel()->getDeclContext() != 6125 RHSAddrExpr->getLabel()->getDeclContext()) 6126 return false; 6127 Result = APValue(LHSAddrExpr, RHSAddrExpr); 6128 return true; 6129 } 6130 6131 // All the remaining cases expect both operands to be an integer 6132 if (!LHSVal.isInt() || !RHSVal.isInt()) 6133 return Error(E); 6134 6135 // Set up the width and signedness manually, in case it can't be deduced 6136 // from the operation we're performing. 6137 // FIXME: Don't do this in the cases where we can deduce it. 6138 APSInt Value(Info.Ctx.getIntWidth(E->getType()), 6139 E->getType()->isUnsignedIntegerOrEnumerationType()); 6140 if (!handleIntIntBinOp(Info, E, LHSVal.getInt(), E->getOpcode(), 6141 RHSVal.getInt(), Value)) 6142 return false; 6143 return Success(Value, E, Result); 6144} 6145 6146void DataRecursiveIntBinOpEvaluator::process(EvalResult &Result) { 6147 Job &job = Queue.back(); 6148 6149 switch (job.Kind) { 6150 case Job::AnyExprKind: { 6151 if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(job.E)) { 6152 if (shouldEnqueue(Bop)) { 6153 job.Kind = Job::BinOpKind; 6154 enqueue(Bop->getLHS()); 6155 return; 6156 } 6157 } 6158 6159 EvaluateExpr(job.E, Result); 6160 Queue.pop_back(); 6161 return; 6162 } 6163 6164 case Job::BinOpKind: { 6165 const BinaryOperator *Bop = cast<BinaryOperator>(job.E); 6166 bool SuppressRHSDiags = false; 6167 if (!VisitBinOpLHSOnly(Result, Bop, SuppressRHSDiags)) { 6168 Queue.pop_back(); 6169 return; 6170 } 6171 if (SuppressRHSDiags) 6172 job.startSpeculativeEval(Info); 6173 job.LHSResult.swap(Result); 6174 job.Kind = Job::BinOpVisitedLHSKind; 6175 enqueue(Bop->getRHS()); 6176 return; 6177 } 6178 6179 case Job::BinOpVisitedLHSKind: { 6180 const BinaryOperator *Bop = cast<BinaryOperator>(job.E); 6181 EvalResult RHS; 6182 RHS.swap(Result); 6183 Result.Failed = !VisitBinOp(job.LHSResult, RHS, Bop, Result.Val); 6184 Queue.pop_back(); 6185 return; 6186 } 6187 } 6188 6189 llvm_unreachable("Invalid Job::Kind!"); 6190} 6191 6192bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { 6193 if (E->isAssignmentOp()) 6194 return Error(E); 6195 6196 if (DataRecursiveIntBinOpEvaluator::shouldEnqueue(E)) 6197 return DataRecursiveIntBinOpEvaluator(*this, Result).Traverse(E); 6198 6199 QualType LHSTy = E->getLHS()->getType(); 6200 QualType RHSTy = E->getRHS()->getType(); 6201 6202 if (LHSTy->isAnyComplexType()) { 6203 assert(RHSTy->isAnyComplexType() && "Invalid comparison"); 6204 ComplexValue LHS, RHS; 6205 6206 bool LHSOK = EvaluateComplex(E->getLHS(), LHS, Info); 6207 if (!LHSOK && !Info.keepEvaluatingAfterFailure()) 6208 return false; 6209 6210 if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK) 6211 return false; 6212 6213 if (LHS.isComplexFloat()) { 6214 APFloat::cmpResult CR_r = 6215 LHS.getComplexFloatReal().compare(RHS.getComplexFloatReal()); 6216 APFloat::cmpResult CR_i = 6217 LHS.getComplexFloatImag().compare(RHS.getComplexFloatImag()); 6218 6219 if (E->getOpcode() == BO_EQ) 6220 return Success((CR_r == APFloat::cmpEqual && 6221 CR_i == APFloat::cmpEqual), E); 6222 else { 6223 assert(E->getOpcode() == BO_NE && 6224 "Invalid complex comparison."); 6225 return Success(((CR_r == APFloat::cmpGreaterThan || 6226 CR_r == APFloat::cmpLessThan || 6227 CR_r == APFloat::cmpUnordered) || 6228 (CR_i == APFloat::cmpGreaterThan || 6229 CR_i == APFloat::cmpLessThan || 6230 CR_i == APFloat::cmpUnordered)), E); 6231 } 6232 } else { 6233 if (E->getOpcode() == BO_EQ) 6234 return Success((LHS.getComplexIntReal() == RHS.getComplexIntReal() && 6235 LHS.getComplexIntImag() == RHS.getComplexIntImag()), E); 6236 else { 6237 assert(E->getOpcode() == BO_NE && 6238 "Invalid compex comparison."); 6239 return Success((LHS.getComplexIntReal() != RHS.getComplexIntReal() || 6240 LHS.getComplexIntImag() != RHS.getComplexIntImag()), E); 6241 } 6242 } 6243 } 6244 6245 if (LHSTy->isRealFloatingType() && 6246 RHSTy->isRealFloatingType()) { 6247 APFloat RHS(0.0), LHS(0.0); 6248 6249 bool LHSOK = EvaluateFloat(E->getRHS(), RHS, Info); 6250 if (!LHSOK && !Info.keepEvaluatingAfterFailure()) 6251 return false; 6252 6253 if (!EvaluateFloat(E->getLHS(), LHS, Info) || !LHSOK) 6254 return false; 6255 6256 APFloat::cmpResult CR = LHS.compare(RHS); 6257 6258 switch (E->getOpcode()) { 6259 default: 6260 llvm_unreachable("Invalid binary operator!"); 6261 case BO_LT: 6262 return Success(CR == APFloat::cmpLessThan, E); 6263 case BO_GT: 6264 return Success(CR == APFloat::cmpGreaterThan, E); 6265 case BO_LE: 6266 return Success(CR == APFloat::cmpLessThan || CR == APFloat::cmpEqual, E); 6267 case BO_GE: 6268 return Success(CR == APFloat::cmpGreaterThan || CR == APFloat::cmpEqual, 6269 E); 6270 case BO_EQ: 6271 return Success(CR == APFloat::cmpEqual, E); 6272 case BO_NE: 6273 return Success(CR == APFloat::cmpGreaterThan 6274 || CR == APFloat::cmpLessThan 6275 || CR == APFloat::cmpUnordered, E); 6276 } 6277 } 6278 6279 if (LHSTy->isPointerType() && RHSTy->isPointerType()) { 6280 if (E->getOpcode() == BO_Sub || E->isComparisonOp()) { 6281 LValue LHSValue, RHSValue; 6282 6283 bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info); 6284 if (!LHSOK && Info.keepEvaluatingAfterFailure()) 6285 return false; 6286 6287 if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK) 6288 return false; 6289 6290 // Reject differing bases from the normal codepath; we special-case 6291 // comparisons to null. 6292 if (!HasSameBase(LHSValue, RHSValue)) { 6293 if (E->getOpcode() == BO_Sub) { 6294 // Handle &&A - &&B. 6295 if (!LHSValue.Offset.isZero() || !RHSValue.Offset.isZero()) 6296 return false; 6297 const Expr *LHSExpr = LHSValue.Base.dyn_cast<const Expr*>(); 6298 const Expr *RHSExpr = RHSValue.Base.dyn_cast<const Expr*>(); 6299 if (!LHSExpr || !RHSExpr) 6300 return false; 6301 const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr); 6302 const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr); 6303 if (!LHSAddrExpr || !RHSAddrExpr) 6304 return false; 6305 // Make sure both labels come from the same function. 6306 if (LHSAddrExpr->getLabel()->getDeclContext() != 6307 RHSAddrExpr->getLabel()->getDeclContext()) 6308 return false; 6309 Result = APValue(LHSAddrExpr, RHSAddrExpr); 6310 return true; 6311 } 6312 // Inequalities and subtractions between unrelated pointers have 6313 // unspecified or undefined behavior. 6314 if (!E->isEqualityOp()) 6315 return Error(E); 6316 // A constant address may compare equal to the address of a symbol. 6317 // The one exception is that address of an object cannot compare equal 6318 // to a null pointer constant. 6319 if ((!LHSValue.Base && !LHSValue.Offset.isZero()) || 6320 (!RHSValue.Base && !RHSValue.Offset.isZero())) 6321 return Error(E); 6322 // It's implementation-defined whether distinct literals will have 6323 // distinct addresses. In clang, the result of such a comparison is 6324 // unspecified, so it is not a constant expression. However, we do know 6325 // that the address of a literal will be non-null. 6326 if ((IsLiteralLValue(LHSValue) || IsLiteralLValue(RHSValue)) && 6327 LHSValue.Base && RHSValue.Base) 6328 return Error(E); 6329 // We can't tell whether weak symbols will end up pointing to the same 6330 // object. 6331 if (IsWeakLValue(LHSValue) || IsWeakLValue(RHSValue)) 6332 return Error(E); 6333 // Pointers with different bases cannot represent the same object. 6334 // (Note that clang defaults to -fmerge-all-constants, which can 6335 // lead to inconsistent results for comparisons involving the address 6336 // of a constant; this generally doesn't matter in practice.) 6337 return Success(E->getOpcode() == BO_NE, E); 6338 } 6339 6340 const CharUnits &LHSOffset = LHSValue.getLValueOffset(); 6341 const CharUnits &RHSOffset = RHSValue.getLValueOffset(); 6342 6343 SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator(); 6344 SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator(); 6345 6346 if (E->getOpcode() == BO_Sub) { 6347 // C++11 [expr.add]p6: 6348 // Unless both pointers point to elements of the same array object, or 6349 // one past the last element of the array object, the behavior is 6350 // undefined. 6351 if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && 6352 !AreElementsOfSameArray(getType(LHSValue.Base), 6353 LHSDesignator, RHSDesignator)) 6354 CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array); 6355 6356 QualType Type = E->getLHS()->getType(); 6357 QualType ElementType = Type->getAs<PointerType>()->getPointeeType(); 6358 6359 CharUnits ElementSize; 6360 if (!HandleSizeof(Info, E->getExprLoc(), ElementType, ElementSize)) 6361 return false; 6362 6363 // FIXME: LLVM and GCC both compute LHSOffset - RHSOffset at runtime, 6364 // and produce incorrect results when it overflows. Such behavior 6365 // appears to be non-conforming, but is common, so perhaps we should 6366 // assume the standard intended for such cases to be undefined behavior 6367 // and check for them. 6368 6369 // Compute (LHSOffset - RHSOffset) / Size carefully, checking for 6370 // overflow in the final conversion to ptrdiff_t. 6371 APSInt LHS( 6372 llvm::APInt(65, (int64_t)LHSOffset.getQuantity(), true), false); 6373 APSInt RHS( 6374 llvm::APInt(65, (int64_t)RHSOffset.getQuantity(), true), false); 6375 APSInt ElemSize( 6376 llvm::APInt(65, (int64_t)ElementSize.getQuantity(), true), false); 6377 APSInt TrueResult = (LHS - RHS) / ElemSize; 6378 APSInt Result = TrueResult.trunc(Info.Ctx.getIntWidth(E->getType())); 6379 6380 if (Result.extend(65) != TrueResult) 6381 HandleOverflow(Info, E, TrueResult, E->getType()); 6382 return Success(Result, E); 6383 } 6384 6385 // C++11 [expr.rel]p3: 6386 // Pointers to void (after pointer conversions) can be compared, with a 6387 // result defined as follows: If both pointers represent the same 6388 // address or are both the null pointer value, the result is true if the 6389 // operator is <= or >= and false otherwise; otherwise the result is 6390 // unspecified. 6391 // We interpret this as applying to pointers to *cv* void. 6392 if (LHSTy->isVoidPointerType() && LHSOffset != RHSOffset && 6393 E->isRelationalOp()) 6394 CCEDiag(E, diag::note_constexpr_void_comparison); 6395 6396 // C++11 [expr.rel]p2: 6397 // - If two pointers point to non-static data members of the same object, 6398 // or to subobjects or array elements fo such members, recursively, the 6399 // pointer to the later declared member compares greater provided the 6400 // two members have the same access control and provided their class is 6401 // not a union. 6402 // [...] 6403 // - Otherwise pointer comparisons are unspecified. 6404 if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && 6405 E->isRelationalOp()) { 6406 bool WasArrayIndex; 6407 unsigned Mismatch = 6408 FindDesignatorMismatch(getType(LHSValue.Base), LHSDesignator, 6409 RHSDesignator, WasArrayIndex); 6410 // At the point where the designators diverge, the comparison has a 6411 // specified value if: 6412 // - we are comparing array indices 6413 // - we are comparing fields of a union, or fields with the same access 6414 // Otherwise, the result is unspecified and thus the comparison is not a 6415 // constant expression. 6416 if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() && 6417 Mismatch < RHSDesignator.Entries.size()) { 6418 const FieldDecl *LF = getAsField(LHSDesignator.Entries[Mismatch]); 6419 const FieldDecl *RF = getAsField(RHSDesignator.Entries[Mismatch]); 6420 if (!LF && !RF) 6421 CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes); 6422 else if (!LF) 6423 CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field) 6424 << getAsBaseClass(LHSDesignator.Entries[Mismatch]) 6425 << RF->getParent() << RF; 6426 else if (!RF) 6427 CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field) 6428 << getAsBaseClass(RHSDesignator.Entries[Mismatch]) 6429 << LF->getParent() << LF; 6430 else if (!LF->getParent()->isUnion() && 6431 LF->getAccess() != RF->getAccess()) 6432 CCEDiag(E, diag::note_constexpr_pointer_comparison_differing_access) 6433 << LF << LF->getAccess() << RF << RF->getAccess() 6434 << LF->getParent(); 6435 } 6436 } 6437 6438 // The comparison here must be unsigned, and performed with the same 6439 // width as the pointer. 6440 unsigned PtrSize = Info.Ctx.getTypeSize(LHSTy); 6441 uint64_t CompareLHS = LHSOffset.getQuantity(); 6442 uint64_t CompareRHS = RHSOffset.getQuantity(); 6443 assert(PtrSize <= 64 && "Unexpected pointer width"); 6444 uint64_t Mask = ~0ULL >> (64 - PtrSize); 6445 CompareLHS &= Mask; 6446 CompareRHS &= Mask; 6447 6448 // If there is a base and this is a relational operator, we can only 6449 // compare pointers within the object in question; otherwise, the result 6450 // depends on where the object is located in memory. 6451 if (!LHSValue.Base.isNull() && E->isRelationalOp()) { 6452 QualType BaseTy = getType(LHSValue.Base); 6453 if (BaseTy->isIncompleteType()) 6454 return Error(E); 6455 CharUnits Size = Info.Ctx.getTypeSizeInChars(BaseTy); 6456 uint64_t OffsetLimit = Size.getQuantity(); 6457 if (CompareLHS > OffsetLimit || CompareRHS > OffsetLimit) 6458 return Error(E); 6459 } 6460 6461 switch (E->getOpcode()) { 6462 default: llvm_unreachable("missing comparison operator"); 6463 case BO_LT: return Success(CompareLHS < CompareRHS, E); 6464 case BO_GT: return Success(CompareLHS > CompareRHS, E); 6465 case BO_LE: return Success(CompareLHS <= CompareRHS, E); 6466 case BO_GE: return Success(CompareLHS >= CompareRHS, E); 6467 case BO_EQ: return Success(CompareLHS == CompareRHS, E); 6468 case BO_NE: return Success(CompareLHS != CompareRHS, E); 6469 } 6470 } 6471 } 6472 6473 if (LHSTy->isMemberPointerType()) { 6474 assert(E->isEqualityOp() && "unexpected member pointer operation"); 6475 assert(RHSTy->isMemberPointerType() && "invalid comparison"); 6476 6477 MemberPtr LHSValue, RHSValue; 6478 6479 bool LHSOK = EvaluateMemberPointer(E->getLHS(), LHSValue, Info); 6480 if (!LHSOK && Info.keepEvaluatingAfterFailure()) 6481 return false; 6482 6483 if (!EvaluateMemberPointer(E->getRHS(), RHSValue, Info) || !LHSOK) 6484 return false; 6485 6486 // C++11 [expr.eq]p2: 6487 // If both operands are null, they compare equal. Otherwise if only one is 6488 // null, they compare unequal. 6489 if (!LHSValue.getDecl() || !RHSValue.getDecl()) { 6490 bool Equal = !LHSValue.getDecl() && !RHSValue.getDecl(); 6491 return Success(E->getOpcode() == BO_EQ ? Equal : !Equal, E); 6492 } 6493 6494 // Otherwise if either is a pointer to a virtual member function, the 6495 // result is unspecified. 6496 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl())) 6497 if (MD->isVirtual()) 6498 CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD; 6499 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl())) 6500 if (MD->isVirtual()) 6501 CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD; 6502 6503 // Otherwise they compare equal if and only if they would refer to the 6504 // same member of the same most derived object or the same subobject if 6505 // they were dereferenced with a hypothetical object of the associated 6506 // class type. 6507 bool Equal = LHSValue == RHSValue; 6508 return Success(E->getOpcode() == BO_EQ ? Equal : !Equal, E); 6509 } 6510 6511 if (LHSTy->isNullPtrType()) { 6512 assert(E->isComparisonOp() && "unexpected nullptr operation"); 6513 assert(RHSTy->isNullPtrType() && "missing pointer conversion"); 6514 // C++11 [expr.rel]p4, [expr.eq]p3: If two operands of type std::nullptr_t 6515 // are compared, the result is true of the operator is <=, >= or ==, and 6516 // false otherwise. 6517 BinaryOperator::Opcode Opcode = E->getOpcode(); 6518 return Success(Opcode == BO_EQ || Opcode == BO_LE || Opcode == BO_GE, E); 6519 } 6520 6521 assert((!LHSTy->isIntegralOrEnumerationType() || 6522 !RHSTy->isIntegralOrEnumerationType()) && 6523 "DataRecursiveIntBinOpEvaluator should have handled integral types"); 6524 // We can't continue from here for non-integral types. 6525 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 6526} 6527 6528CharUnits IntExprEvaluator::GetAlignOfType(QualType T) { 6529 // C++ [expr.alignof]p3: "When alignof is applied to a reference type, the 6530 // result shall be the alignment of the referenced type." 6531 if (const ReferenceType *Ref = T->getAs<ReferenceType>()) 6532 T = Ref->getPointeeType(); 6533 6534 // __alignof is defined to return the preferred alignment. 6535 return Info.Ctx.toCharUnitsFromBits( 6536 Info.Ctx.getPreferredTypeAlign(T.getTypePtr())); 6537} 6538 6539CharUnits IntExprEvaluator::GetAlignOfExpr(const Expr *E) { 6540 E = E->IgnoreParens(); 6541 6542 // The kinds of expressions that we have special-case logic here for 6543 // should be kept up to date with the special checks for those 6544 // expressions in Sema. 6545 6546 // alignof decl is always accepted, even if it doesn't make sense: we default 6547 // to 1 in those cases. 6548 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 6549 return Info.Ctx.getDeclAlign(DRE->getDecl(), 6550 /*RefAsPointee*/true); 6551 6552 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) 6553 return Info.Ctx.getDeclAlign(ME->getMemberDecl(), 6554 /*RefAsPointee*/true); 6555 6556 return GetAlignOfType(E->getType()); 6557} 6558 6559 6560/// VisitUnaryExprOrTypeTraitExpr - Evaluate a sizeof, alignof or vec_step with 6561/// a result as the expression's type. 6562bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr( 6563 const UnaryExprOrTypeTraitExpr *E) { 6564 switch(E->getKind()) { 6565 case UETT_AlignOf: { 6566 if (E->isArgumentType()) 6567 return Success(GetAlignOfType(E->getArgumentType()), E); 6568 else 6569 return Success(GetAlignOfExpr(E->getArgumentExpr()), E); 6570 } 6571 6572 case UETT_VecStep: { 6573 QualType Ty = E->getTypeOfArgument(); 6574 6575 if (Ty->isVectorType()) { 6576 unsigned n = Ty->castAs<VectorType>()->getNumElements(); 6577 6578 // The vec_step built-in functions that take a 3-component 6579 // vector return 4. (OpenCL 1.1 spec 6.11.12) 6580 if (n == 3) 6581 n = 4; 6582 6583 return Success(n, E); 6584 } else 6585 return Success(1, E); 6586 } 6587 6588 case UETT_SizeOf: { 6589 QualType SrcTy = E->getTypeOfArgument(); 6590 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 6591 // the result is the size of the referenced type." 6592 if (const ReferenceType *Ref = SrcTy->getAs<ReferenceType>()) 6593 SrcTy = Ref->getPointeeType(); 6594 6595 CharUnits Sizeof; 6596 if (!HandleSizeof(Info, E->getExprLoc(), SrcTy, Sizeof)) 6597 return false; 6598 return Success(Sizeof, E); 6599 } 6600 } 6601 6602 llvm_unreachable("unknown expr/type trait"); 6603} 6604 6605bool IntExprEvaluator::VisitOffsetOfExpr(const OffsetOfExpr *OOE) { 6606 CharUnits Result; 6607 unsigned n = OOE->getNumComponents(); 6608 if (n == 0) 6609 return Error(OOE); 6610 QualType CurrentType = OOE->getTypeSourceInfo()->getType(); 6611 for (unsigned i = 0; i != n; ++i) { 6612 OffsetOfExpr::OffsetOfNode ON = OOE->getComponent(i); 6613 switch (ON.getKind()) { 6614 case OffsetOfExpr::OffsetOfNode::Array: { 6615 const Expr *Idx = OOE->getIndexExpr(ON.getArrayExprIndex()); 6616 APSInt IdxResult; 6617 if (!EvaluateInteger(Idx, IdxResult, Info)) 6618 return false; 6619 const ArrayType *AT = Info.Ctx.getAsArrayType(CurrentType); 6620 if (!AT) 6621 return Error(OOE); 6622 CurrentType = AT->getElementType(); 6623 CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(CurrentType); 6624 Result += IdxResult.getSExtValue() * ElementSize; 6625 break; 6626 } 6627 6628 case OffsetOfExpr::OffsetOfNode::Field: { 6629 FieldDecl *MemberDecl = ON.getField(); 6630 const RecordType *RT = CurrentType->getAs<RecordType>(); 6631 if (!RT) 6632 return Error(OOE); 6633 RecordDecl *RD = RT->getDecl(); 6634 if (RD->isInvalidDecl()) return false; 6635 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD); 6636 unsigned i = MemberDecl->getFieldIndex(); 6637 assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 6638 Result += Info.Ctx.toCharUnitsFromBits(RL.getFieldOffset(i)); 6639 CurrentType = MemberDecl->getType().getNonReferenceType(); 6640 break; 6641 } 6642 6643 case OffsetOfExpr::OffsetOfNode::Identifier: 6644 llvm_unreachable("dependent __builtin_offsetof"); 6645 6646 case OffsetOfExpr::OffsetOfNode::Base: { 6647 CXXBaseSpecifier *BaseSpec = ON.getBase(); 6648 if (BaseSpec->isVirtual()) 6649 return Error(OOE); 6650 6651 // Find the layout of the class whose base we are looking into. 6652 const RecordType *RT = CurrentType->getAs<RecordType>(); 6653 if (!RT) 6654 return Error(OOE); 6655 RecordDecl *RD = RT->getDecl(); 6656 if (RD->isInvalidDecl()) return false; 6657 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD); 6658 6659 // Find the base class itself. 6660 CurrentType = BaseSpec->getType(); 6661 const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 6662 if (!BaseRT) 6663 return Error(OOE); 6664 6665 // Add the offset to the base. 6666 Result += RL.getBaseClassOffset(cast<CXXRecordDecl>(BaseRT->getDecl())); 6667 break; 6668 } 6669 } 6670 } 6671 return Success(Result, OOE); 6672} 6673 6674bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) { 6675 switch (E->getOpcode()) { 6676 default: 6677 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 6678 // See C99 6.6p3. 6679 return Error(E); 6680 case UO_Extension: 6681 // FIXME: Should extension allow i-c-e extension expressions in its scope? 6682 // If so, we could clear the diagnostic ID. 6683 return Visit(E->getSubExpr()); 6684 case UO_Plus: 6685 // The result is just the value. 6686 return Visit(E->getSubExpr()); 6687 case UO_Minus: { 6688 if (!Visit(E->getSubExpr())) 6689 return false; 6690 if (!Result.isInt()) return Error(E); 6691 const APSInt &Value = Result.getInt(); 6692 if (Value.isSigned() && Value.isMinSignedValue()) 6693 HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1), 6694 E->getType()); 6695 return Success(-Value, E); 6696 } 6697 case UO_Not: { 6698 if (!Visit(E->getSubExpr())) 6699 return false; 6700 if (!Result.isInt()) return Error(E); 6701 return Success(~Result.getInt(), E); 6702 } 6703 case UO_LNot: { 6704 bool bres; 6705 if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info)) 6706 return false; 6707 return Success(!bres, E); 6708 } 6709 } 6710} 6711 6712/// HandleCast - This is used to evaluate implicit or explicit casts where the 6713/// result type is integer. 6714bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) { 6715 const Expr *SubExpr = E->getSubExpr(); 6716 QualType DestType = E->getType(); 6717 QualType SrcType = SubExpr->getType(); 6718 6719 switch (E->getCastKind()) { 6720 case CK_BaseToDerived: 6721 case CK_DerivedToBase: 6722 case CK_UncheckedDerivedToBase: 6723 case CK_Dynamic: 6724 case CK_ToUnion: 6725 case CK_ArrayToPointerDecay: 6726 case CK_FunctionToPointerDecay: 6727 case CK_NullToPointer: 6728 case CK_NullToMemberPointer: 6729 case CK_BaseToDerivedMemberPointer: 6730 case CK_DerivedToBaseMemberPointer: 6731 case CK_ReinterpretMemberPointer: 6732 case CK_ConstructorConversion: 6733 case CK_IntegralToPointer: 6734 case CK_ToVoid: 6735 case CK_VectorSplat: 6736 case CK_IntegralToFloating: 6737 case CK_FloatingCast: 6738 case CK_CPointerToObjCPointerCast: 6739 case CK_BlockPointerToObjCPointerCast: 6740 case CK_AnyPointerToBlockPointerCast: 6741 case CK_ObjCObjectLValueCast: 6742 case CK_FloatingRealToComplex: 6743 case CK_FloatingComplexToReal: 6744 case CK_FloatingComplexCast: 6745 case CK_FloatingComplexToIntegralComplex: 6746 case CK_IntegralRealToComplex: 6747 case CK_IntegralComplexCast: 6748 case CK_IntegralComplexToFloatingComplex: 6749 case CK_BuiltinFnToFnPtr: 6750 case CK_ZeroToOCLEvent: 6751 case CK_NonAtomicToAtomic: 6752 llvm_unreachable("invalid cast kind for integral value"); 6753 6754 case CK_BitCast: 6755 case CK_Dependent: 6756 case CK_LValueBitCast: 6757 case CK_ARCProduceObject: 6758 case CK_ARCConsumeObject: 6759 case CK_ARCReclaimReturnedObject: 6760 case CK_ARCExtendBlockObject: 6761 case CK_CopyAndAutoreleaseBlockObject: 6762 return Error(E); 6763 6764 case CK_UserDefinedConversion: 6765 case CK_LValueToRValue: 6766 case CK_AtomicToNonAtomic: 6767 case CK_NoOp: 6768 return ExprEvaluatorBaseTy::VisitCastExpr(E); 6769 6770 case CK_MemberPointerToBoolean: 6771 case CK_PointerToBoolean: 6772 case CK_IntegralToBoolean: 6773 case CK_FloatingToBoolean: 6774 case CK_FloatingComplexToBoolean: 6775 case CK_IntegralComplexToBoolean: { 6776 bool BoolResult; 6777 if (!EvaluateAsBooleanCondition(SubExpr, BoolResult, Info)) 6778 return false; 6779 return Success(BoolResult, E); 6780 } 6781 6782 case CK_IntegralCast: { 6783 if (!Visit(SubExpr)) 6784 return false; 6785 6786 if (!Result.isInt()) { 6787 // Allow casts of address-of-label differences if they are no-ops 6788 // or narrowing. (The narrowing case isn't actually guaranteed to 6789 // be constant-evaluatable except in some narrow cases which are hard 6790 // to detect here. We let it through on the assumption the user knows 6791 // what they are doing.) 6792 if (Result.isAddrLabelDiff()) 6793 return Info.Ctx.getTypeSize(DestType) <= Info.Ctx.getTypeSize(SrcType); 6794 // Only allow casts of lvalues if they are lossless. 6795 return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType); 6796 } 6797 6798 return Success(HandleIntToIntCast(Info, E, DestType, SrcType, 6799 Result.getInt()), E); 6800 } 6801 6802 case CK_PointerToIntegral: { 6803 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2; 6804 6805 LValue LV; 6806 if (!EvaluatePointer(SubExpr, LV, Info)) 6807 return false; 6808 6809 if (LV.getLValueBase()) { 6810 // Only allow based lvalue casts if they are lossless. 6811 // FIXME: Allow a larger integer size than the pointer size, and allow 6812 // narrowing back down to pointer width in subsequent integral casts. 6813 // FIXME: Check integer type's active bits, not its type size. 6814 if (Info.Ctx.getTypeSize(DestType) != Info.Ctx.getTypeSize(SrcType)) 6815 return Error(E); 6816 6817 LV.Designator.setInvalid(); 6818 LV.moveInto(Result); 6819 return true; 6820 } 6821 6822 APSInt AsInt = Info.Ctx.MakeIntValue(LV.getLValueOffset().getQuantity(), 6823 SrcType); 6824 return Success(HandleIntToIntCast(Info, E, DestType, SrcType, AsInt), E); 6825 } 6826 6827 case CK_IntegralComplexToReal: { 6828 ComplexValue C; 6829 if (!EvaluateComplex(SubExpr, C, Info)) 6830 return false; 6831 return Success(C.getComplexIntReal(), E); 6832 } 6833 6834 case CK_FloatingToIntegral: { 6835 APFloat F(0.0); 6836 if (!EvaluateFloat(SubExpr, F, Info)) 6837 return false; 6838 6839 APSInt Value; 6840 if (!HandleFloatToIntCast(Info, E, SrcType, F, DestType, Value)) 6841 return false; 6842 return Success(Value, E); 6843 } 6844 } 6845 6846 llvm_unreachable("unknown cast resulting in integral value"); 6847} 6848 6849bool IntExprEvaluator::VisitUnaryReal(const UnaryOperator *E) { 6850 if (E->getSubExpr()->getType()->isAnyComplexType()) { 6851 ComplexValue LV; 6852 if (!EvaluateComplex(E->getSubExpr(), LV, Info)) 6853 return false; 6854 if (!LV.isComplexInt()) 6855 return Error(E); 6856 return Success(LV.getComplexIntReal(), E); 6857 } 6858 6859 return Visit(E->getSubExpr()); 6860} 6861 6862bool IntExprEvaluator::VisitUnaryImag(const UnaryOperator *E) { 6863 if (E->getSubExpr()->getType()->isComplexIntegerType()) { 6864 ComplexValue LV; 6865 if (!EvaluateComplex(E->getSubExpr(), LV, Info)) 6866 return false; 6867 if (!LV.isComplexInt()) 6868 return Error(E); 6869 return Success(LV.getComplexIntImag(), E); 6870 } 6871 6872 VisitIgnoredValue(E->getSubExpr()); 6873 return Success(0, E); 6874} 6875 6876bool IntExprEvaluator::VisitSizeOfPackExpr(const SizeOfPackExpr *E) { 6877 return Success(E->getPackLength(), E); 6878} 6879 6880bool IntExprEvaluator::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) { 6881 return Success(E->getValue(), E); 6882} 6883 6884//===----------------------------------------------------------------------===// 6885// Float Evaluation 6886//===----------------------------------------------------------------------===// 6887 6888namespace { 6889class FloatExprEvaluator 6890 : public ExprEvaluatorBase<FloatExprEvaluator, bool> { 6891 APFloat &Result; 6892public: 6893 FloatExprEvaluator(EvalInfo &info, APFloat &result) 6894 : ExprEvaluatorBaseTy(info), Result(result) {} 6895 6896 bool Success(const APValue &V, const Expr *e) { 6897 Result = V.getFloat(); 6898 return true; 6899 } 6900 6901 bool ZeroInitialization(const Expr *E) { 6902 Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType())); 6903 return true; 6904 } 6905 6906 bool VisitCallExpr(const CallExpr *E); 6907 6908 bool VisitUnaryOperator(const UnaryOperator *E); 6909 bool VisitBinaryOperator(const BinaryOperator *E); 6910 bool VisitFloatingLiteral(const FloatingLiteral *E); 6911 bool VisitCastExpr(const CastExpr *E); 6912 6913 bool VisitUnaryReal(const UnaryOperator *E); 6914 bool VisitUnaryImag(const UnaryOperator *E); 6915 6916 // FIXME: Missing: array subscript of vector, member of vector 6917}; 6918} // end anonymous namespace 6919 6920static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) { 6921 assert(E->isRValue() && E->getType()->isRealFloatingType()); 6922 return FloatExprEvaluator(Info, Result).Visit(E); 6923} 6924 6925static bool TryEvaluateBuiltinNaN(const ASTContext &Context, 6926 QualType ResultTy, 6927 const Expr *Arg, 6928 bool SNaN, 6929 llvm::APFloat &Result) { 6930 const StringLiteral *S = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts()); 6931 if (!S) return false; 6932 6933 const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(ResultTy); 6934 6935 llvm::APInt fill; 6936 6937 // Treat empty strings as if they were zero. 6938 if (S->getString().empty()) 6939 fill = llvm::APInt(32, 0); 6940 else if (S->getString().getAsInteger(0, fill)) 6941 return false; 6942 6943 if (SNaN) 6944 Result = llvm::APFloat::getSNaN(Sem, false, &fill); 6945 else 6946 Result = llvm::APFloat::getQNaN(Sem, false, &fill); 6947 return true; 6948} 6949 6950bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) { 6951 switch (E->isBuiltinCall()) { 6952 default: 6953 return ExprEvaluatorBaseTy::VisitCallExpr(E); 6954 6955 case Builtin::BI__builtin_huge_val: 6956 case Builtin::BI__builtin_huge_valf: 6957 case Builtin::BI__builtin_huge_vall: 6958 case Builtin::BI__builtin_inf: 6959 case Builtin::BI__builtin_inff: 6960 case Builtin::BI__builtin_infl: { 6961 const llvm::fltSemantics &Sem = 6962 Info.Ctx.getFloatTypeSemantics(E->getType()); 6963 Result = llvm::APFloat::getInf(Sem); 6964 return true; 6965 } 6966 6967 case Builtin::BI__builtin_nans: 6968 case Builtin::BI__builtin_nansf: 6969 case Builtin::BI__builtin_nansl: 6970 if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0), 6971 true, Result)) 6972 return Error(E); 6973 return true; 6974 6975 case Builtin::BI__builtin_nan: 6976 case Builtin::BI__builtin_nanf: 6977 case Builtin::BI__builtin_nanl: 6978 // If this is __builtin_nan() turn this into a nan, otherwise we 6979 // can't constant fold it. 6980 if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0), 6981 false, Result)) 6982 return Error(E); 6983 return true; 6984 6985 case Builtin::BI__builtin_fabs: 6986 case Builtin::BI__builtin_fabsf: 6987 case Builtin::BI__builtin_fabsl: 6988 if (!EvaluateFloat(E->getArg(0), Result, Info)) 6989 return false; 6990 6991 if (Result.isNegative()) 6992 Result.changeSign(); 6993 return true; 6994 6995 // FIXME: Builtin::BI__builtin_powi 6996 // FIXME: Builtin::BI__builtin_powif 6997 // FIXME: Builtin::BI__builtin_powil 6998 6999 case Builtin::BI__builtin_copysign: 7000 case Builtin::BI__builtin_copysignf: 7001 case Builtin::BI__builtin_copysignl: { 7002 APFloat RHS(0.); 7003 if (!EvaluateFloat(E->getArg(0), Result, Info) || 7004 !EvaluateFloat(E->getArg(1), RHS, Info)) 7005 return false; 7006 Result.copySign(RHS); 7007 return true; 7008 } 7009 } 7010} 7011 7012bool FloatExprEvaluator::VisitUnaryReal(const UnaryOperator *E) { 7013 if (E->getSubExpr()->getType()->isAnyComplexType()) { 7014 ComplexValue CV; 7015 if (!EvaluateComplex(E->getSubExpr(), CV, Info)) 7016 return false; 7017 Result = CV.FloatReal; 7018 return true; 7019 } 7020 7021 return Visit(E->getSubExpr()); 7022} 7023 7024bool FloatExprEvaluator::VisitUnaryImag(const UnaryOperator *E) { 7025 if (E->getSubExpr()->getType()->isAnyComplexType()) { 7026 ComplexValue CV; 7027 if (!EvaluateComplex(E->getSubExpr(), CV, Info)) 7028 return false; 7029 Result = CV.FloatImag; 7030 return true; 7031 } 7032 7033 VisitIgnoredValue(E->getSubExpr()); 7034 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->getType()); 7035 Result = llvm::APFloat::getZero(Sem); 7036 return true; 7037} 7038 7039bool FloatExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) { 7040 switch (E->getOpcode()) { 7041 default: return Error(E); 7042 case UO_Plus: 7043 return EvaluateFloat(E->getSubExpr(), Result, Info); 7044 case UO_Minus: 7045 if (!EvaluateFloat(E->getSubExpr(), Result, Info)) 7046 return false; 7047 Result.changeSign(); 7048 return true; 7049 } 7050} 7051 7052bool FloatExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { 7053 if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma) 7054 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 7055 7056 APFloat RHS(0.0); 7057 bool LHSOK = EvaluateFloat(E->getLHS(), Result, Info); 7058 if (!LHSOK && !Info.keepEvaluatingAfterFailure()) 7059 return false; 7060 return EvaluateFloat(E->getRHS(), RHS, Info) && LHSOK && 7061 handleFloatFloatBinOp(Info, E, Result, E->getOpcode(), RHS); 7062} 7063 7064bool FloatExprEvaluator::VisitFloatingLiteral(const FloatingLiteral *E) { 7065 Result = E->getValue(); 7066 return true; 7067} 7068 7069bool FloatExprEvaluator::VisitCastExpr(const CastExpr *E) { 7070 const Expr* SubExpr = E->getSubExpr(); 7071 7072 switch (E->getCastKind()) { 7073 default: 7074 return ExprEvaluatorBaseTy::VisitCastExpr(E); 7075 7076 case CK_IntegralToFloating: { 7077 APSInt IntResult; 7078 return EvaluateInteger(SubExpr, IntResult, Info) && 7079 HandleIntToFloatCast(Info, E, SubExpr->getType(), IntResult, 7080 E->getType(), Result); 7081 } 7082 7083 case CK_FloatingCast: { 7084 if (!Visit(SubExpr)) 7085 return false; 7086 return HandleFloatToFloatCast(Info, E, SubExpr->getType(), E->getType(), 7087 Result); 7088 } 7089 7090 case CK_FloatingComplexToReal: { 7091 ComplexValue V; 7092 if (!EvaluateComplex(SubExpr, V, Info)) 7093 return false; 7094 Result = V.getComplexFloatReal(); 7095 return true; 7096 } 7097 } 7098} 7099 7100//===----------------------------------------------------------------------===// 7101// Complex Evaluation (for float and integer) 7102//===----------------------------------------------------------------------===// 7103 7104namespace { 7105class ComplexExprEvaluator 7106 : public ExprEvaluatorBase<ComplexExprEvaluator, bool> { 7107 ComplexValue &Result; 7108 7109public: 7110 ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result) 7111 : ExprEvaluatorBaseTy(info), Result(Result) {} 7112 7113 bool Success(const APValue &V, const Expr *e) { 7114 Result.setFrom(V); 7115 return true; 7116 } 7117 7118 bool ZeroInitialization(const Expr *E); 7119 7120 //===--------------------------------------------------------------------===// 7121 // Visitor Methods 7122 //===--------------------------------------------------------------------===// 7123 7124 bool VisitImaginaryLiteral(const ImaginaryLiteral *E); 7125 bool VisitCastExpr(const CastExpr *E); 7126 bool VisitBinaryOperator(const BinaryOperator *E); 7127 bool VisitUnaryOperator(const UnaryOperator *E); 7128 bool VisitInitListExpr(const InitListExpr *E); 7129}; 7130} // end anonymous namespace 7131 7132static bool EvaluateComplex(const Expr *E, ComplexValue &Result, 7133 EvalInfo &Info) { 7134 assert(E->isRValue() && E->getType()->isAnyComplexType()); 7135 return ComplexExprEvaluator(Info, Result).Visit(E); 7136} 7137 7138bool ComplexExprEvaluator::ZeroInitialization(const Expr *E) { 7139 QualType ElemTy = E->getType()->castAs<ComplexType>()->getElementType(); 7140 if (ElemTy->isRealFloatingType()) { 7141 Result.makeComplexFloat(); 7142 APFloat Zero = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(ElemTy)); 7143 Result.FloatReal = Zero; 7144 Result.FloatImag = Zero; 7145 } else { 7146 Result.makeComplexInt(); 7147 APSInt Zero = Info.Ctx.MakeIntValue(0, ElemTy); 7148 Result.IntReal = Zero; 7149 Result.IntImag = Zero; 7150 } 7151 return true; 7152} 7153 7154bool ComplexExprEvaluator::VisitImaginaryLiteral(const ImaginaryLiteral *E) { 7155 const Expr* SubExpr = E->getSubExpr(); 7156 7157 if (SubExpr->getType()->isRealFloatingType()) { 7158 Result.makeComplexFloat(); 7159 APFloat &Imag = Result.FloatImag; 7160 if (!EvaluateFloat(SubExpr, Imag, Info)) 7161 return false; 7162 7163 Result.FloatReal = APFloat(Imag.getSemantics()); 7164 return true; 7165 } else { 7166 assert(SubExpr->getType()->isIntegerType() && 7167 "Unexpected imaginary literal."); 7168 7169 Result.makeComplexInt(); 7170 APSInt &Imag = Result.IntImag; 7171 if (!EvaluateInteger(SubExpr, Imag, Info)) 7172 return false; 7173 7174 Result.IntReal = APSInt(Imag.getBitWidth(), !Imag.isSigned()); 7175 return true; 7176 } 7177} 7178 7179bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) { 7180 7181 switch (E->getCastKind()) { 7182 case CK_BitCast: 7183 case CK_BaseToDerived: 7184 case CK_DerivedToBase: 7185 case CK_UncheckedDerivedToBase: 7186 case CK_Dynamic: 7187 case CK_ToUnion: 7188 case CK_ArrayToPointerDecay: 7189 case CK_FunctionToPointerDecay: 7190 case CK_NullToPointer: 7191 case CK_NullToMemberPointer: 7192 case CK_BaseToDerivedMemberPointer: 7193 case CK_DerivedToBaseMemberPointer: 7194 case CK_MemberPointerToBoolean: 7195 case CK_ReinterpretMemberPointer: 7196 case CK_ConstructorConversion: 7197 case CK_IntegralToPointer: 7198 case CK_PointerToIntegral: 7199 case CK_PointerToBoolean: 7200 case CK_ToVoid: 7201 case CK_VectorSplat: 7202 case CK_IntegralCast: 7203 case CK_IntegralToBoolean: 7204 case CK_IntegralToFloating: 7205 case CK_FloatingToIntegral: 7206 case CK_FloatingToBoolean: 7207 case CK_FloatingCast: 7208 case CK_CPointerToObjCPointerCast: 7209 case CK_BlockPointerToObjCPointerCast: 7210 case CK_AnyPointerToBlockPointerCast: 7211 case CK_ObjCObjectLValueCast: 7212 case CK_FloatingComplexToReal: 7213 case CK_FloatingComplexToBoolean: 7214 case CK_IntegralComplexToReal: 7215 case CK_IntegralComplexToBoolean: 7216 case CK_ARCProduceObject: 7217 case CK_ARCConsumeObject: 7218 case CK_ARCReclaimReturnedObject: 7219 case CK_ARCExtendBlockObject: 7220 case CK_CopyAndAutoreleaseBlockObject: 7221 case CK_BuiltinFnToFnPtr: 7222 case CK_ZeroToOCLEvent: 7223 case CK_NonAtomicToAtomic: 7224 llvm_unreachable("invalid cast kind for complex value"); 7225 7226 case CK_LValueToRValue: 7227 case CK_AtomicToNonAtomic: 7228 case CK_NoOp: 7229 return ExprEvaluatorBaseTy::VisitCastExpr(E); 7230 7231 case CK_Dependent: 7232 case CK_LValueBitCast: 7233 case CK_UserDefinedConversion: 7234 return Error(E); 7235 7236 case CK_FloatingRealToComplex: { 7237 APFloat &Real = Result.FloatReal; 7238 if (!EvaluateFloat(E->getSubExpr(), Real, Info)) 7239 return false; 7240 7241 Result.makeComplexFloat(); 7242 Result.FloatImag = APFloat(Real.getSemantics()); 7243 return true; 7244 } 7245 7246 case CK_FloatingComplexCast: { 7247 if (!Visit(E->getSubExpr())) 7248 return false; 7249 7250 QualType To = E->getType()->getAs<ComplexType>()->getElementType(); 7251 QualType From 7252 = E->getSubExpr()->getType()->getAs<ComplexType>()->getElementType(); 7253 7254 return HandleFloatToFloatCast(Info, E, From, To, Result.FloatReal) && 7255 HandleFloatToFloatCast(Info, E, From, To, Result.FloatImag); 7256 } 7257 7258 case CK_FloatingComplexToIntegralComplex: { 7259 if (!Visit(E->getSubExpr())) 7260 return false; 7261 7262 QualType To = E->getType()->getAs<ComplexType>()->getElementType(); 7263 QualType From 7264 = E->getSubExpr()->getType()->getAs<ComplexType>()->getElementType(); 7265 Result.makeComplexInt(); 7266 return HandleFloatToIntCast(Info, E, From, Result.FloatReal, 7267 To, Result.IntReal) && 7268 HandleFloatToIntCast(Info, E, From, Result.FloatImag, 7269 To, Result.IntImag); 7270 } 7271 7272 case CK_IntegralRealToComplex: { 7273 APSInt &Real = Result.IntReal; 7274 if (!EvaluateInteger(E->getSubExpr(), Real, Info)) 7275 return false; 7276 7277 Result.makeComplexInt(); 7278 Result.IntImag = APSInt(Real.getBitWidth(), !Real.isSigned()); 7279 return true; 7280 } 7281 7282 case CK_IntegralComplexCast: { 7283 if (!Visit(E->getSubExpr())) 7284 return false; 7285 7286 QualType To = E->getType()->getAs<ComplexType>()->getElementType(); 7287 QualType From 7288 = E->getSubExpr()->getType()->getAs<ComplexType>()->getElementType(); 7289 7290 Result.IntReal = HandleIntToIntCast(Info, E, To, From, Result.IntReal); 7291 Result.IntImag = HandleIntToIntCast(Info, E, To, From, Result.IntImag); 7292 return true; 7293 } 7294 7295 case CK_IntegralComplexToFloatingComplex: { 7296 if (!Visit(E->getSubExpr())) 7297 return false; 7298 7299 QualType To = E->getType()->castAs<ComplexType>()->getElementType(); 7300 QualType From 7301 = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType(); 7302 Result.makeComplexFloat(); 7303 return HandleIntToFloatCast(Info, E, From, Result.IntReal, 7304 To, Result.FloatReal) && 7305 HandleIntToFloatCast(Info, E, From, Result.IntImag, 7306 To, Result.FloatImag); 7307 } 7308 } 7309 7310 llvm_unreachable("unknown cast resulting in complex value"); 7311} 7312 7313bool ComplexExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { 7314 if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma) 7315 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 7316 7317 bool LHSOK = Visit(E->getLHS()); 7318 if (!LHSOK && !Info.keepEvaluatingAfterFailure()) 7319 return false; 7320 7321 ComplexValue RHS; 7322 if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK) 7323 return false; 7324 7325 assert(Result.isComplexFloat() == RHS.isComplexFloat() && 7326 "Invalid operands to binary operator."); 7327 switch (E->getOpcode()) { 7328 default: return Error(E); 7329 case BO_Add: 7330 if (Result.isComplexFloat()) { 7331 Result.getComplexFloatReal().add(RHS.getComplexFloatReal(), 7332 APFloat::rmNearestTiesToEven); 7333 Result.getComplexFloatImag().add(RHS.getComplexFloatImag(), 7334 APFloat::rmNearestTiesToEven); 7335 } else { 7336 Result.getComplexIntReal() += RHS.getComplexIntReal(); 7337 Result.getComplexIntImag() += RHS.getComplexIntImag(); 7338 } 7339 break; 7340 case BO_Sub: 7341 if (Result.isComplexFloat()) { 7342 Result.getComplexFloatReal().subtract(RHS.getComplexFloatReal(), 7343 APFloat::rmNearestTiesToEven); 7344 Result.getComplexFloatImag().subtract(RHS.getComplexFloatImag(), 7345 APFloat::rmNearestTiesToEven); 7346 } else { 7347 Result.getComplexIntReal() -= RHS.getComplexIntReal(); 7348 Result.getComplexIntImag() -= RHS.getComplexIntImag(); 7349 } 7350 break; 7351 case BO_Mul: 7352 if (Result.isComplexFloat()) { 7353 ComplexValue LHS = Result; 7354 APFloat &LHS_r = LHS.getComplexFloatReal(); 7355 APFloat &LHS_i = LHS.getComplexFloatImag(); 7356 APFloat &RHS_r = RHS.getComplexFloatReal(); 7357 APFloat &RHS_i = RHS.getComplexFloatImag(); 7358 7359 APFloat Tmp = LHS_r; 7360 Tmp.multiply(RHS_r, APFloat::rmNearestTiesToEven); 7361 Result.getComplexFloatReal() = Tmp; 7362 Tmp = LHS_i; 7363 Tmp.multiply(RHS_i, APFloat::rmNearestTiesToEven); 7364 Result.getComplexFloatReal().subtract(Tmp, APFloat::rmNearestTiesToEven); 7365 7366 Tmp = LHS_r; 7367 Tmp.multiply(RHS_i, APFloat::rmNearestTiesToEven); 7368 Result.getComplexFloatImag() = Tmp; 7369 Tmp = LHS_i; 7370 Tmp.multiply(RHS_r, APFloat::rmNearestTiesToEven); 7371 Result.getComplexFloatImag().add(Tmp, APFloat::rmNearestTiesToEven); 7372 } else { 7373 ComplexValue LHS = Result; 7374 Result.getComplexIntReal() = 7375 (LHS.getComplexIntReal() * RHS.getComplexIntReal() - 7376 LHS.getComplexIntImag() * RHS.getComplexIntImag()); 7377 Result.getComplexIntImag() = 7378 (LHS.getComplexIntReal() * RHS.getComplexIntImag() + 7379 LHS.getComplexIntImag() * RHS.getComplexIntReal()); 7380 } 7381 break; 7382 case BO_Div: 7383 if (Result.isComplexFloat()) { 7384 ComplexValue LHS = Result; 7385 APFloat &LHS_r = LHS.getComplexFloatReal(); 7386 APFloat &LHS_i = LHS.getComplexFloatImag(); 7387 APFloat &RHS_r = RHS.getComplexFloatReal(); 7388 APFloat &RHS_i = RHS.getComplexFloatImag(); 7389 APFloat &Res_r = Result.getComplexFloatReal(); 7390 APFloat &Res_i = Result.getComplexFloatImag(); 7391 7392 APFloat Den = RHS_r; 7393 Den.multiply(RHS_r, APFloat::rmNearestTiesToEven); 7394 APFloat Tmp = RHS_i; 7395 Tmp.multiply(RHS_i, APFloat::rmNearestTiesToEven); 7396 Den.add(Tmp, APFloat::rmNearestTiesToEven); 7397 7398 Res_r = LHS_r; 7399 Res_r.multiply(RHS_r, APFloat::rmNearestTiesToEven); 7400 Tmp = LHS_i; 7401 Tmp.multiply(RHS_i, APFloat::rmNearestTiesToEven); 7402 Res_r.add(Tmp, APFloat::rmNearestTiesToEven); 7403 Res_r.divide(Den, APFloat::rmNearestTiesToEven); 7404 7405 Res_i = LHS_i; 7406 Res_i.multiply(RHS_r, APFloat::rmNearestTiesToEven); 7407 Tmp = LHS_r; 7408 Tmp.multiply(RHS_i, APFloat::rmNearestTiesToEven); 7409 Res_i.subtract(Tmp, APFloat::rmNearestTiesToEven); 7410 Res_i.divide(Den, APFloat::rmNearestTiesToEven); 7411 } else { 7412 if (RHS.getComplexIntReal() == 0 && RHS.getComplexIntImag() == 0) 7413 return Error(E, diag::note_expr_divide_by_zero); 7414 7415 ComplexValue LHS = Result; 7416 APSInt Den = RHS.getComplexIntReal() * RHS.getComplexIntReal() + 7417 RHS.getComplexIntImag() * RHS.getComplexIntImag(); 7418 Result.getComplexIntReal() = 7419 (LHS.getComplexIntReal() * RHS.getComplexIntReal() + 7420 LHS.getComplexIntImag() * RHS.getComplexIntImag()) / Den; 7421 Result.getComplexIntImag() = 7422 (LHS.getComplexIntImag() * RHS.getComplexIntReal() - 7423 LHS.getComplexIntReal() * RHS.getComplexIntImag()) / Den; 7424 } 7425 break; 7426 } 7427 7428 return true; 7429} 7430 7431bool ComplexExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) { 7432 // Get the operand value into 'Result'. 7433 if (!Visit(E->getSubExpr())) 7434 return false; 7435 7436 switch (E->getOpcode()) { 7437 default: 7438 return Error(E); 7439 case UO_Extension: 7440 return true; 7441 case UO_Plus: 7442 // The result is always just the subexpr. 7443 return true; 7444 case UO_Minus: 7445 if (Result.isComplexFloat()) { 7446 Result.getComplexFloatReal().changeSign(); 7447 Result.getComplexFloatImag().changeSign(); 7448 } 7449 else { 7450 Result.getComplexIntReal() = -Result.getComplexIntReal(); 7451 Result.getComplexIntImag() = -Result.getComplexIntImag(); 7452 } 7453 return true; 7454 case UO_Not: 7455 if (Result.isComplexFloat()) 7456 Result.getComplexFloatImag().changeSign(); 7457 else 7458 Result.getComplexIntImag() = -Result.getComplexIntImag(); 7459 return true; 7460 } 7461} 7462 7463bool ComplexExprEvaluator::VisitInitListExpr(const InitListExpr *E) { 7464 if (E->getNumInits() == 2) { 7465 if (E->getType()->isComplexType()) { 7466 Result.makeComplexFloat(); 7467 if (!EvaluateFloat(E->getInit(0), Result.FloatReal, Info)) 7468 return false; 7469 if (!EvaluateFloat(E->getInit(1), Result.FloatImag, Info)) 7470 return false; 7471 } else { 7472 Result.makeComplexInt(); 7473 if (!EvaluateInteger(E->getInit(0), Result.IntReal, Info)) 7474 return false; 7475 if (!EvaluateInteger(E->getInit(1), Result.IntImag, Info)) 7476 return false; 7477 } 7478 return true; 7479 } 7480 return ExprEvaluatorBaseTy::VisitInitListExpr(E); 7481} 7482 7483//===----------------------------------------------------------------------===// 7484// Atomic expression evaluation, essentially just handling the NonAtomicToAtomic 7485// implicit conversion. 7486//===----------------------------------------------------------------------===// 7487 7488namespace { 7489class AtomicExprEvaluator : 7490 public ExprEvaluatorBase<AtomicExprEvaluator, bool> { 7491 APValue &Result; 7492public: 7493 AtomicExprEvaluator(EvalInfo &Info, APValue &Result) 7494 : ExprEvaluatorBaseTy(Info), Result(Result) {} 7495 7496 bool Success(const APValue &V, const Expr *E) { 7497 Result = V; 7498 return true; 7499 } 7500 7501 bool ZeroInitialization(const Expr *E) { 7502 ImplicitValueInitExpr VIE( 7503 E->getType()->castAs<AtomicType>()->getValueType()); 7504 return Evaluate(Result, Info, &VIE); 7505 } 7506 7507 bool VisitCastExpr(const CastExpr *E) { 7508 switch (E->getCastKind()) { 7509 default: 7510 return ExprEvaluatorBaseTy::VisitCastExpr(E); 7511 case CK_NonAtomicToAtomic: 7512 return Evaluate(Result, Info, E->getSubExpr()); 7513 } 7514 } 7515}; 7516} // end anonymous namespace 7517 7518static bool EvaluateAtomic(const Expr *E, APValue &Result, EvalInfo &Info) { 7519 assert(E->isRValue() && E->getType()->isAtomicType()); 7520 return AtomicExprEvaluator(Info, Result).Visit(E); 7521} 7522 7523//===----------------------------------------------------------------------===// 7524// Void expression evaluation, primarily for a cast to void on the LHS of a 7525// comma operator 7526//===----------------------------------------------------------------------===// 7527 7528namespace { 7529class VoidExprEvaluator 7530 : public ExprEvaluatorBase<VoidExprEvaluator, bool> { 7531public: 7532 VoidExprEvaluator(EvalInfo &Info) : ExprEvaluatorBaseTy(Info) {} 7533 7534 bool Success(const APValue &V, const Expr *e) { return true; } 7535 7536 bool VisitCastExpr(const CastExpr *E) { 7537 switch (E->getCastKind()) { 7538 default: 7539 return ExprEvaluatorBaseTy::VisitCastExpr(E); 7540 case CK_ToVoid: 7541 VisitIgnoredValue(E->getSubExpr()); 7542 return true; 7543 } 7544 } 7545}; 7546} // end anonymous namespace 7547 7548static bool EvaluateVoid(const Expr *E, EvalInfo &Info) { 7549 assert(E->isRValue() && E->getType()->isVoidType()); 7550 return VoidExprEvaluator(Info).Visit(E); 7551} 7552 7553//===----------------------------------------------------------------------===// 7554// Top level Expr::EvaluateAsRValue method. 7555//===----------------------------------------------------------------------===// 7556 7557static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) { 7558 // In C, function designators are not lvalues, but we evaluate them as if they 7559 // are. 7560 QualType T = E->getType(); 7561 if (E->isGLValue() || T->isFunctionType()) { 7562 LValue LV; 7563 if (!EvaluateLValue(E, LV, Info)) 7564 return false; 7565 LV.moveInto(Result); 7566 } else if (T->isVectorType()) { 7567 if (!EvaluateVector(E, Result, Info)) 7568 return false; 7569 } else if (T->isIntegralOrEnumerationType()) { 7570 if (!IntExprEvaluator(Info, Result).Visit(E)) 7571 return false; 7572 } else if (T->hasPointerRepresentation()) { 7573 LValue LV; 7574 if (!EvaluatePointer(E, LV, Info)) 7575 return false; 7576 LV.moveInto(Result); 7577 } else if (T->isRealFloatingType()) { 7578 llvm::APFloat F(0.0); 7579 if (!EvaluateFloat(E, F, Info)) 7580 return false; 7581 Result = APValue(F); 7582 } else if (T->isAnyComplexType()) { 7583 ComplexValue C; 7584 if (!EvaluateComplex(E, C, Info)) 7585 return false; 7586 C.moveInto(Result); 7587 } else if (T->isMemberPointerType()) { 7588 MemberPtr P; 7589 if (!EvaluateMemberPointer(E, P, Info)) 7590 return false; 7591 P.moveInto(Result); 7592 return true; 7593 } else if (T->isArrayType()) { 7594 LValue LV; 7595 LV.set(E, Info.CurrentCall->Index); 7596 if (!EvaluateArray(E, LV, Info.CurrentCall->Temporaries[E], Info)) 7597 return false; 7598 Result = Info.CurrentCall->Temporaries[E]; 7599 } else if (T->isRecordType()) { 7600 LValue LV; 7601 LV.set(E, Info.CurrentCall->Index); 7602 if (!EvaluateRecord(E, LV, Info.CurrentCall->Temporaries[E], Info)) 7603 return false; 7604 Result = Info.CurrentCall->Temporaries[E]; 7605 } else if (T->isVoidType()) { 7606 if (!Info.getLangOpts().CPlusPlus11) 7607 Info.CCEDiag(E, diag::note_constexpr_nonliteral) 7608 << E->getType(); 7609 if (!EvaluateVoid(E, Info)) 7610 return false; 7611 } else if (T->isAtomicType()) { 7612 if (!EvaluateAtomic(E, Result, Info)) 7613 return false; 7614 } else if (Info.getLangOpts().CPlusPlus11) { 7615 Info.Diag(E, diag::note_constexpr_nonliteral) << E->getType(); 7616 return false; 7617 } else { 7618 Info.Diag(E, diag::note_invalid_subexpr_in_const_expr); 7619 return false; 7620 } 7621 7622 return true; 7623} 7624 7625/// EvaluateInPlace - Evaluate an expression in-place in an APValue. In some 7626/// cases, the in-place evaluation is essential, since later initializers for 7627/// an object can indirectly refer to subobjects which were initialized earlier. 7628static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This, 7629 const Expr *E, bool AllowNonLiteralTypes) { 7630 if (!AllowNonLiteralTypes && !CheckLiteralType(Info, E, &This)) 7631 return false; 7632 7633 if (E->isRValue()) { 7634 // Evaluate arrays and record types in-place, so that later initializers can 7635 // refer to earlier-initialized members of the object. 7636 if (E->getType()->isArrayType()) 7637 return EvaluateArray(E, This, Result, Info); 7638 else if (E->getType()->isRecordType()) 7639 return EvaluateRecord(E, This, Result, Info); 7640 } 7641 7642 // For any other type, in-place evaluation is unimportant. 7643 return Evaluate(Result, Info, E); 7644} 7645 7646/// EvaluateAsRValue - Try to evaluate this expression, performing an implicit 7647/// lvalue-to-rvalue cast if it is an lvalue. 7648static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) { 7649 if (!CheckLiteralType(Info, E)) 7650 return false; 7651 7652 if (!::Evaluate(Result, Info, E)) 7653 return false; 7654 7655 if (E->isGLValue()) { 7656 LValue LV; 7657 LV.setFrom(Info.Ctx, Result); 7658 if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result)) 7659 return false; 7660 } 7661 7662 // Check this core constant expression is a constant expression. 7663 return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result); 7664} 7665 7666static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result, 7667 const ASTContext &Ctx, bool &IsConst) { 7668 // Fast-path evaluations of integer literals, since we sometimes see files 7669 // containing vast quantities of these. 7670 if (const IntegerLiteral *L = dyn_cast<IntegerLiteral>(Exp)) { 7671 Result.Val = APValue(APSInt(L->getValue(), 7672 L->getType()->isUnsignedIntegerType())); 7673 IsConst = true; 7674 return true; 7675 } 7676 7677 // FIXME: Evaluating values of large array and record types can cause 7678 // performance problems. Only do so in C++11 for now. 7679 if (Exp->isRValue() && (Exp->getType()->isArrayType() || 7680 Exp->getType()->isRecordType()) && 7681 !Ctx.getLangOpts().CPlusPlus11) { 7682 IsConst = false; 7683 return true; 7684 } 7685 return false; 7686} 7687 7688 7689/// EvaluateAsRValue - Return true if this is a constant which we can fold using 7690/// any crazy technique (that has nothing to do with language standards) that 7691/// we want to. If this function returns true, it returns the folded constant 7692/// in Result. If this expression is a glvalue, an lvalue-to-rvalue conversion 7693/// will be applied to the result. 7694bool Expr::EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const { 7695 bool IsConst; 7696 if (FastEvaluateAsRValue(this, Result, Ctx, IsConst)) 7697 return IsConst; 7698 7699 EvalInfo Info(Ctx, Result); 7700 return ::EvaluateAsRValue(Info, this, Result.Val); 7701} 7702 7703bool Expr::EvaluateAsBooleanCondition(bool &Result, 7704 const ASTContext &Ctx) const { 7705 EvalResult Scratch; 7706 return EvaluateAsRValue(Scratch, Ctx) && 7707 HandleConversionToBool(Scratch.Val, Result); 7708} 7709 7710bool Expr::EvaluateAsInt(APSInt &Result, const ASTContext &Ctx, 7711 SideEffectsKind AllowSideEffects) const { 7712 if (!getType()->isIntegralOrEnumerationType()) 7713 return false; 7714 7715 EvalResult ExprResult; 7716 if (!EvaluateAsRValue(ExprResult, Ctx) || !ExprResult.Val.isInt() || 7717 (!AllowSideEffects && ExprResult.HasSideEffects)) 7718 return false; 7719 7720 Result = ExprResult.Val.getInt(); 7721 return true; 7722} 7723 7724bool Expr::EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const { 7725 EvalInfo Info(Ctx, Result); 7726 7727 LValue LV; 7728 if (!EvaluateLValue(this, LV, Info) || Result.HasSideEffects || 7729 !CheckLValueConstantExpression(Info, getExprLoc(), 7730 Ctx.getLValueReferenceType(getType()), LV)) 7731 return false; 7732 7733 LV.moveInto(Result.Val); 7734 return true; 7735} 7736 7737bool Expr::EvaluateAsInitializer(APValue &Value, const ASTContext &Ctx, 7738 const VarDecl *VD, 7739 SmallVectorImpl<PartialDiagnosticAt> &Notes) const { 7740 // FIXME: Evaluating initializers for large array and record types can cause 7741 // performance problems. Only do so in C++11 for now. 7742 if (isRValue() && (getType()->isArrayType() || getType()->isRecordType()) && 7743 !Ctx.getLangOpts().CPlusPlus11) 7744 return false; 7745 7746 Expr::EvalStatus EStatus; 7747 EStatus.Diag = &Notes; 7748 7749 EvalInfo InitInfo(Ctx, EStatus); 7750 InitInfo.setEvaluatingDecl(VD, Value); 7751 7752 LValue LVal; 7753 LVal.set(VD); 7754 7755 // C++11 [basic.start.init]p2: 7756 // Variables with static storage duration or thread storage duration shall be 7757 // zero-initialized before any other initialization takes place. 7758 // This behavior is not present in C. 7759 if (Ctx.getLangOpts().CPlusPlus && !VD->hasLocalStorage() && 7760 !VD->getType()->isReferenceType()) { 7761 ImplicitValueInitExpr VIE(VD->getType()); 7762 if (!EvaluateInPlace(Value, InitInfo, LVal, &VIE, 7763 /*AllowNonLiteralTypes=*/true)) 7764 return false; 7765 } 7766 7767 if (!EvaluateInPlace(Value, InitInfo, LVal, this, 7768 /*AllowNonLiteralTypes=*/true) || 7769 EStatus.HasSideEffects) 7770 return false; 7771 7772 return CheckConstantExpression(InitInfo, VD->getLocation(), VD->getType(), 7773 Value); 7774} 7775 7776/// isEvaluatable - Call EvaluateAsRValue to see if this expression can be 7777/// constant folded, but discard the result. 7778bool Expr::isEvaluatable(const ASTContext &Ctx) const { 7779 EvalResult Result; 7780 return EvaluateAsRValue(Result, Ctx) && !Result.HasSideEffects; 7781} 7782 7783APSInt Expr::EvaluateKnownConstInt(const ASTContext &Ctx, 7784 SmallVectorImpl<PartialDiagnosticAt> *Diag) const { 7785 EvalResult EvalResult; 7786 EvalResult.Diag = Diag; 7787 bool Result = EvaluateAsRValue(EvalResult, Ctx); 7788 (void)Result; 7789 assert(Result && "Could not evaluate expression"); 7790 assert(EvalResult.Val.isInt() && "Expression did not evaluate to integer"); 7791 7792 return EvalResult.Val.getInt(); 7793} 7794 7795void Expr::EvaluateForOverflow(const ASTContext &Ctx, 7796 SmallVectorImpl<PartialDiagnosticAt> *Diags) const { 7797 bool IsConst; 7798 EvalResult EvalResult; 7799 EvalResult.Diag = Diags; 7800 if (!FastEvaluateAsRValue(this, EvalResult, Ctx, IsConst)) { 7801 EvalInfo Info(Ctx, EvalResult, true); 7802 (void)::EvaluateAsRValue(Info, this, EvalResult.Val); 7803 } 7804} 7805 7806bool Expr::EvalResult::isGlobalLValue() const { 7807 assert(Val.isLValue()); 7808 return IsGlobalLValue(Val.getLValueBase()); 7809} 7810 7811 7812/// isIntegerConstantExpr - this recursive routine will test if an expression is 7813/// an integer constant expression. 7814 7815/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 7816/// comma, etc 7817 7818// CheckICE - This function does the fundamental ICE checking: the returned 7819// ICEDiag contains an ICEKind indicating whether the expression is an ICE, 7820// and a (possibly null) SourceLocation indicating the location of the problem. 7821// 7822// Note that to reduce code duplication, this helper does no evaluation 7823// itself; the caller checks whether the expression is evaluatable, and 7824// in the rare cases where CheckICE actually cares about the evaluated 7825// value, it calls into Evalute. 7826 7827namespace { 7828 7829enum ICEKind { 7830 /// This expression is an ICE. 7831 IK_ICE, 7832 /// This expression is not an ICE, but if it isn't evaluated, it's 7833 /// a legal subexpression for an ICE. This return value is used to handle 7834 /// the comma operator in C99 mode, and non-constant subexpressions. 7835 IK_ICEIfUnevaluated, 7836 /// This expression is not an ICE, and is not a legal subexpression for one. 7837 IK_NotICE 7838}; 7839 7840struct ICEDiag { 7841 ICEKind Kind; 7842 SourceLocation Loc; 7843 7844 ICEDiag(ICEKind IK, SourceLocation l) : Kind(IK), Loc(l) {} 7845}; 7846 7847} 7848 7849static ICEDiag NoDiag() { return ICEDiag(IK_ICE, SourceLocation()); } 7850 7851static ICEDiag Worst(ICEDiag A, ICEDiag B) { return A.Kind >= B.Kind ? A : B; } 7852 7853static ICEDiag CheckEvalInICE(const Expr* E, ASTContext &Ctx) { 7854 Expr::EvalResult EVResult; 7855 if (!E->EvaluateAsRValue(EVResult, Ctx) || EVResult.HasSideEffects || 7856 !EVResult.Val.isInt()) 7857 return ICEDiag(IK_NotICE, E->getLocStart()); 7858 7859 return NoDiag(); 7860} 7861 7862static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) { 7863 assert(!E->isValueDependent() && "Should not see value dependent exprs!"); 7864 if (!E->getType()->isIntegralOrEnumerationType()) 7865 return ICEDiag(IK_NotICE, E->getLocStart()); 7866 7867 switch (E->getStmtClass()) { 7868#define ABSTRACT_STMT(Node) 7869#define STMT(Node, Base) case Expr::Node##Class: 7870#define EXPR(Node, Base) 7871#include "clang/AST/StmtNodes.inc" 7872 case Expr::PredefinedExprClass: 7873 case Expr::FloatingLiteralClass: 7874 case Expr::ImaginaryLiteralClass: 7875 case Expr::StringLiteralClass: 7876 case Expr::ArraySubscriptExprClass: 7877 case Expr::MemberExprClass: 7878 case Expr::CompoundAssignOperatorClass: 7879 case Expr::CompoundLiteralExprClass: 7880 case Expr::ExtVectorElementExprClass: 7881 case Expr::DesignatedInitExprClass: 7882 case Expr::ImplicitValueInitExprClass: 7883 case Expr::ParenListExprClass: 7884 case Expr::VAArgExprClass: 7885 case Expr::AddrLabelExprClass: 7886 case Expr::StmtExprClass: 7887 case Expr::CXXMemberCallExprClass: 7888 case Expr::CUDAKernelCallExprClass: 7889 case Expr::CXXDynamicCastExprClass: 7890 case Expr::CXXTypeidExprClass: 7891 case Expr::CXXUuidofExprClass: 7892 case Expr::MSPropertyRefExprClass: 7893 case Expr::CXXNullPtrLiteralExprClass: 7894 case Expr::UserDefinedLiteralClass: 7895 case Expr::CXXThisExprClass: 7896 case Expr::CXXThrowExprClass: 7897 case Expr::CXXNewExprClass: 7898 case Expr::CXXDeleteExprClass: 7899 case Expr::CXXPseudoDestructorExprClass: 7900 case Expr::UnresolvedLookupExprClass: 7901 case Expr::DependentScopeDeclRefExprClass: 7902 case Expr::CXXConstructExprClass: 7903 case Expr::CXXStdInitializerListExprClass: 7904 case Expr::CXXBindTemporaryExprClass: 7905 case Expr::ExprWithCleanupsClass: 7906 case Expr::CXXTemporaryObjectExprClass: 7907 case Expr::CXXUnresolvedConstructExprClass: 7908 case Expr::CXXDependentScopeMemberExprClass: 7909 case Expr::UnresolvedMemberExprClass: 7910 case Expr::ObjCStringLiteralClass: 7911 case Expr::ObjCBoxedExprClass: 7912 case Expr::ObjCArrayLiteralClass: 7913 case Expr::ObjCDictionaryLiteralClass: 7914 case Expr::ObjCEncodeExprClass: 7915 case Expr::ObjCMessageExprClass: 7916 case Expr::ObjCSelectorExprClass: 7917 case Expr::ObjCProtocolExprClass: 7918 case Expr::ObjCIvarRefExprClass: 7919 case Expr::ObjCPropertyRefExprClass: 7920 case Expr::ObjCSubscriptRefExprClass: 7921 case Expr::ObjCIsaExprClass: 7922 case Expr::ShuffleVectorExprClass: 7923 case Expr::BlockExprClass: 7924 case Expr::NoStmtClass: 7925 case Expr::OpaqueValueExprClass: 7926 case Expr::PackExpansionExprClass: 7927 case Expr::SubstNonTypeTemplateParmPackExprClass: 7928 case Expr::FunctionParmPackExprClass: 7929 case Expr::AsTypeExprClass: 7930 case Expr::ObjCIndirectCopyRestoreExprClass: 7931 case Expr::MaterializeTemporaryExprClass: 7932 case Expr::PseudoObjectExprClass: 7933 case Expr::AtomicExprClass: 7934 case Expr::InitListExprClass: 7935 case Expr::LambdaExprClass: 7936 return ICEDiag(IK_NotICE, E->getLocStart()); 7937 7938 case Expr::SizeOfPackExprClass: 7939 case Expr::GNUNullExprClass: 7940 // GCC considers the GNU __null value to be an integral constant expression. 7941 return NoDiag(); 7942 7943 case Expr::SubstNonTypeTemplateParmExprClass: 7944 return 7945 CheckICE(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), Ctx); 7946 7947 case Expr::ParenExprClass: 7948 return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx); 7949 case Expr::GenericSelectionExprClass: 7950 return CheckICE(cast<GenericSelectionExpr>(E)->getResultExpr(), Ctx); 7951 case Expr::IntegerLiteralClass: 7952 case Expr::CharacterLiteralClass: 7953 case Expr::ObjCBoolLiteralExprClass: 7954 case Expr::CXXBoolLiteralExprClass: 7955 case Expr::CXXScalarValueInitExprClass: 7956 case Expr::UnaryTypeTraitExprClass: 7957 case Expr::BinaryTypeTraitExprClass: 7958 case Expr::TypeTraitExprClass: 7959 case Expr::ArrayTypeTraitExprClass: 7960 case Expr::ExpressionTraitExprClass: 7961 case Expr::CXXNoexceptExprClass: 7962 return NoDiag(); 7963 case Expr::CallExprClass: 7964 case Expr::CXXOperatorCallExprClass: { 7965 // C99 6.6/3 allows function calls within unevaluated subexpressions of 7966 // constant expressions, but they can never be ICEs because an ICE cannot 7967 // contain an operand of (pointer to) function type. 7968 const CallExpr *CE = cast<CallExpr>(E); 7969 if (CE->isBuiltinCall()) 7970 return CheckEvalInICE(E, Ctx); 7971 return ICEDiag(IK_NotICE, E->getLocStart()); 7972 } 7973 case Expr::DeclRefExprClass: { 7974 if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl())) 7975 return NoDiag(); 7976 const ValueDecl *D = dyn_cast<ValueDecl>(cast<DeclRefExpr>(E)->getDecl()); 7977 if (Ctx.getLangOpts().CPlusPlus && 7978 D && IsConstNonVolatile(D->getType())) { 7979 // Parameter variables are never constants. Without this check, 7980 // getAnyInitializer() can find a default argument, which leads 7981 // to chaos. 7982 if (isa<ParmVarDecl>(D)) 7983 return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation()); 7984 7985 // C++ 7.1.5.1p2 7986 // A variable of non-volatile const-qualified integral or enumeration 7987 // type initialized by an ICE can be used in ICEs. 7988 if (const VarDecl *Dcl = dyn_cast<VarDecl>(D)) { 7989 if (!Dcl->getType()->isIntegralOrEnumerationType()) 7990 return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation()); 7991 7992 const VarDecl *VD; 7993 // Look for a declaration of this variable that has an initializer, and 7994 // check whether it is an ICE. 7995 if (Dcl->getAnyInitializer(VD) && VD->checkInitIsICE()) 7996 return NoDiag(); 7997 else 7998 return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation()); 7999 } 8000 } 8001 return ICEDiag(IK_NotICE, E->getLocStart()); 8002 } 8003 case Expr::UnaryOperatorClass: { 8004 const UnaryOperator *Exp = cast<UnaryOperator>(E); 8005 switch (Exp->getOpcode()) { 8006 case UO_PostInc: 8007 case UO_PostDec: 8008 case UO_PreInc: 8009 case UO_PreDec: 8010 case UO_AddrOf: 8011 case UO_Deref: 8012 // C99 6.6/3 allows increment and decrement within unevaluated 8013 // subexpressions of constant expressions, but they can never be ICEs 8014 // because an ICE cannot contain an lvalue operand. 8015 return ICEDiag(IK_NotICE, E->getLocStart()); 8016 case UO_Extension: 8017 case UO_LNot: 8018 case UO_Plus: 8019 case UO_Minus: 8020 case UO_Not: 8021 case UO_Real: 8022 case UO_Imag: 8023 return CheckICE(Exp->getSubExpr(), Ctx); 8024 } 8025 8026 // OffsetOf falls through here. 8027 } 8028 case Expr::OffsetOfExprClass: { 8029 // Note that per C99, offsetof must be an ICE. And AFAIK, using 8030 // EvaluateAsRValue matches the proposed gcc behavior for cases like 8031 // "offsetof(struct s{int x[4];}, x[1.0])". This doesn't affect 8032 // compliance: we should warn earlier for offsetof expressions with 8033 // array subscripts that aren't ICEs, and if the array subscripts 8034 // are ICEs, the value of the offsetof must be an integer constant. 8035 return CheckEvalInICE(E, Ctx); 8036 } 8037 case Expr::UnaryExprOrTypeTraitExprClass: { 8038 const UnaryExprOrTypeTraitExpr *Exp = cast<UnaryExprOrTypeTraitExpr>(E); 8039 if ((Exp->getKind() == UETT_SizeOf) && 8040 Exp->getTypeOfArgument()->isVariableArrayType()) 8041 return ICEDiag(IK_NotICE, E->getLocStart()); 8042 return NoDiag(); 8043 } 8044 case Expr::BinaryOperatorClass: { 8045 const BinaryOperator *Exp = cast<BinaryOperator>(E); 8046 switch (Exp->getOpcode()) { 8047 case BO_PtrMemD: 8048 case BO_PtrMemI: 8049 case BO_Assign: 8050 case BO_MulAssign: 8051 case BO_DivAssign: 8052 case BO_RemAssign: 8053 case BO_AddAssign: 8054 case BO_SubAssign: 8055 case BO_ShlAssign: 8056 case BO_ShrAssign: 8057 case BO_AndAssign: 8058 case BO_XorAssign: 8059 case BO_OrAssign: 8060 // C99 6.6/3 allows assignments within unevaluated subexpressions of 8061 // constant expressions, but they can never be ICEs because an ICE cannot 8062 // contain an lvalue operand. 8063 return ICEDiag(IK_NotICE, E->getLocStart()); 8064 8065 case BO_Mul: 8066 case BO_Div: 8067 case BO_Rem: 8068 case BO_Add: 8069 case BO_Sub: 8070 case BO_Shl: 8071 case BO_Shr: 8072 case BO_LT: 8073 case BO_GT: 8074 case BO_LE: 8075 case BO_GE: 8076 case BO_EQ: 8077 case BO_NE: 8078 case BO_And: 8079 case BO_Xor: 8080 case BO_Or: 8081 case BO_Comma: { 8082 ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 8083 ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 8084 if (Exp->getOpcode() == BO_Div || 8085 Exp->getOpcode() == BO_Rem) { 8086 // EvaluateAsRValue gives an error for undefined Div/Rem, so make sure 8087 // we don't evaluate one. 8088 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) { 8089 llvm::APSInt REval = Exp->getRHS()->EvaluateKnownConstInt(Ctx); 8090 if (REval == 0) 8091 return ICEDiag(IK_ICEIfUnevaluated, E->getLocStart()); 8092 if (REval.isSigned() && REval.isAllOnesValue()) { 8093 llvm::APSInt LEval = Exp->getLHS()->EvaluateKnownConstInt(Ctx); 8094 if (LEval.isMinSignedValue()) 8095 return ICEDiag(IK_ICEIfUnevaluated, E->getLocStart()); 8096 } 8097 } 8098 } 8099 if (Exp->getOpcode() == BO_Comma) { 8100 if (Ctx.getLangOpts().C99) { 8101 // C99 6.6p3 introduces a strange edge case: comma can be in an ICE 8102 // if it isn't evaluated. 8103 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) 8104 return ICEDiag(IK_ICEIfUnevaluated, E->getLocStart()); 8105 } else { 8106 // In both C89 and C++, commas in ICEs are illegal. 8107 return ICEDiag(IK_NotICE, E->getLocStart()); 8108 } 8109 } 8110 return Worst(LHSResult, RHSResult); 8111 } 8112 case BO_LAnd: 8113 case BO_LOr: { 8114 ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 8115 ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 8116 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICEIfUnevaluated) { 8117 // Rare case where the RHS has a comma "side-effect"; we need 8118 // to actually check the condition to see whether the side 8119 // with the comma is evaluated. 8120 if ((Exp->getOpcode() == BO_LAnd) != 8121 (Exp->getLHS()->EvaluateKnownConstInt(Ctx) == 0)) 8122 return RHSResult; 8123 return NoDiag(); 8124 } 8125 8126 return Worst(LHSResult, RHSResult); 8127 } 8128 } 8129 } 8130 case Expr::ImplicitCastExprClass: 8131 case Expr::CStyleCastExprClass: 8132 case Expr::CXXFunctionalCastExprClass: 8133 case Expr::CXXStaticCastExprClass: 8134 case Expr::CXXReinterpretCastExprClass: 8135 case Expr::CXXConstCastExprClass: 8136 case Expr::ObjCBridgedCastExprClass: { 8137 const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr(); 8138 if (isa<ExplicitCastExpr>(E)) { 8139 if (const FloatingLiteral *FL 8140 = dyn_cast<FloatingLiteral>(SubExpr->IgnoreParenImpCasts())) { 8141 unsigned DestWidth = Ctx.getIntWidth(E->getType()); 8142 bool DestSigned = E->getType()->isSignedIntegerOrEnumerationType(); 8143 APSInt IgnoredVal(DestWidth, !DestSigned); 8144 bool Ignored; 8145 // If the value does not fit in the destination type, the behavior is 8146 // undefined, so we are not required to treat it as a constant 8147 // expression. 8148 if (FL->getValue().convertToInteger(IgnoredVal, 8149 llvm::APFloat::rmTowardZero, 8150 &Ignored) & APFloat::opInvalidOp) 8151 return ICEDiag(IK_NotICE, E->getLocStart()); 8152 return NoDiag(); 8153 } 8154 } 8155 switch (cast<CastExpr>(E)->getCastKind()) { 8156 case CK_LValueToRValue: 8157 case CK_AtomicToNonAtomic: 8158 case CK_NonAtomicToAtomic: 8159 case CK_NoOp: 8160 case CK_IntegralToBoolean: 8161 case CK_IntegralCast: 8162 return CheckICE(SubExpr, Ctx); 8163 default: 8164 return ICEDiag(IK_NotICE, E->getLocStart()); 8165 } 8166 } 8167 case Expr::BinaryConditionalOperatorClass: { 8168 const BinaryConditionalOperator *Exp = cast<BinaryConditionalOperator>(E); 8169 ICEDiag CommonResult = CheckICE(Exp->getCommon(), Ctx); 8170 if (CommonResult.Kind == IK_NotICE) return CommonResult; 8171 ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx); 8172 if (FalseResult.Kind == IK_NotICE) return FalseResult; 8173 if (CommonResult.Kind == IK_ICEIfUnevaluated) return CommonResult; 8174 if (FalseResult.Kind == IK_ICEIfUnevaluated && 8175 Exp->getCommon()->EvaluateKnownConstInt(Ctx) != 0) return NoDiag(); 8176 return FalseResult; 8177 } 8178 case Expr::ConditionalOperatorClass: { 8179 const ConditionalOperator *Exp = cast<ConditionalOperator>(E); 8180 // If the condition (ignoring parens) is a __builtin_constant_p call, 8181 // then only the true side is actually considered in an integer constant 8182 // expression, and it is fully evaluated. This is an important GNU 8183 // extension. See GCC PR38377 for discussion. 8184 if (const CallExpr *CallCE 8185 = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts())) 8186 if (CallCE->isBuiltinCall() == Builtin::BI__builtin_constant_p) 8187 return CheckEvalInICE(E, Ctx); 8188 ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx); 8189 if (CondResult.Kind == IK_NotICE) 8190 return CondResult; 8191 8192 ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx); 8193 ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx); 8194 8195 if (TrueResult.Kind == IK_NotICE) 8196 return TrueResult; 8197 if (FalseResult.Kind == IK_NotICE) 8198 return FalseResult; 8199 if (CondResult.Kind == IK_ICEIfUnevaluated) 8200 return CondResult; 8201 if (TrueResult.Kind == IK_ICE && FalseResult.Kind == IK_ICE) 8202 return NoDiag(); 8203 // Rare case where the diagnostics depend on which side is evaluated 8204 // Note that if we get here, CondResult is 0, and at least one of 8205 // TrueResult and FalseResult is non-zero. 8206 if (Exp->getCond()->EvaluateKnownConstInt(Ctx) == 0) 8207 return FalseResult; 8208 return TrueResult; 8209 } 8210 case Expr::CXXDefaultArgExprClass: 8211 return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx); 8212 case Expr::CXXDefaultInitExprClass: 8213 return CheckICE(cast<CXXDefaultInitExpr>(E)->getExpr(), Ctx); 8214 case Expr::ChooseExprClass: { 8215 return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(Ctx), Ctx); 8216 } 8217 } 8218 8219 llvm_unreachable("Invalid StmtClass!"); 8220} 8221 8222/// Evaluate an expression as a C++11 integral constant expression. 8223static bool EvaluateCPlusPlus11IntegralConstantExpr(ASTContext &Ctx, 8224 const Expr *E, 8225 llvm::APSInt *Value, 8226 SourceLocation *Loc) { 8227 if (!E->getType()->isIntegralOrEnumerationType()) { 8228 if (Loc) *Loc = E->getExprLoc(); 8229 return false; 8230 } 8231 8232 APValue Result; 8233 if (!E->isCXX11ConstantExpr(Ctx, &Result, Loc)) 8234 return false; 8235 8236 assert(Result.isInt() && "pointer cast to int is not an ICE"); 8237 if (Value) *Value = Result.getInt(); 8238 return true; 8239} 8240 8241bool Expr::isIntegerConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const { 8242 if (Ctx.getLangOpts().CPlusPlus11) 8243 return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, 0, Loc); 8244 8245 ICEDiag D = CheckICE(this, Ctx); 8246 if (D.Kind != IK_ICE) { 8247 if (Loc) *Loc = D.Loc; 8248 return false; 8249 } 8250 return true; 8251} 8252 8253bool Expr::isIntegerConstantExpr(llvm::APSInt &Value, ASTContext &Ctx, 8254 SourceLocation *Loc, bool isEvaluated) const { 8255 if (Ctx.getLangOpts().CPlusPlus11) 8256 return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value, Loc); 8257 8258 if (!isIntegerConstantExpr(Ctx, Loc)) 8259 return false; 8260 if (!EvaluateAsInt(Value, Ctx)) 8261 llvm_unreachable("ICE cannot be evaluated!"); 8262 return true; 8263} 8264 8265bool Expr::isCXX98IntegralConstantExpr(ASTContext &Ctx) const { 8266 return CheckICE(this, Ctx).Kind == IK_ICE; 8267} 8268 8269bool Expr::isCXX11ConstantExpr(ASTContext &Ctx, APValue *Result, 8270 SourceLocation *Loc) const { 8271 // We support this checking in C++98 mode in order to diagnose compatibility 8272 // issues. 8273 assert(Ctx.getLangOpts().CPlusPlus); 8274 8275 // Build evaluation settings. 8276 Expr::EvalStatus Status; 8277 SmallVector<PartialDiagnosticAt, 8> Diags; 8278 Status.Diag = &Diags; 8279 EvalInfo Info(Ctx, Status); 8280 8281 APValue Scratch; 8282 bool IsConstExpr = ::EvaluateAsRValue(Info, this, Result ? *Result : Scratch); 8283 8284 if (!Diags.empty()) { 8285 IsConstExpr = false; 8286 if (Loc) *Loc = Diags[0].first; 8287 } else if (!IsConstExpr) { 8288 // FIXME: This shouldn't happen. 8289 if (Loc) *Loc = getExprLoc(); 8290 } 8291 8292 return IsConstExpr; 8293} 8294 8295bool Expr::isPotentialConstantExpr(const FunctionDecl *FD, 8296 SmallVectorImpl< 8297 PartialDiagnosticAt> &Diags) { 8298 // FIXME: It would be useful to check constexpr function templates, but at the 8299 // moment the constant expression evaluator cannot cope with the non-rigorous 8300 // ASTs which we build for dependent expressions. 8301 if (FD->isDependentContext()) 8302 return true; 8303 8304 Expr::EvalStatus Status; 8305 Status.Diag = &Diags; 8306 8307 EvalInfo Info(FD->getASTContext(), Status); 8308 Info.CheckingPotentialConstantExpression = true; 8309 8310 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 8311 const CXXRecordDecl *RD = MD ? MD->getParent()->getCanonicalDecl() : 0; 8312 8313 // Fabricate an arbitrary expression on the stack and pretend that it 8314 // is a temporary being used as the 'this' pointer. 8315 LValue This; 8316 ImplicitValueInitExpr VIE(RD ? Info.Ctx.getRecordType(RD) : Info.Ctx.IntTy); 8317 This.set(&VIE, Info.CurrentCall->Index); 8318 8319 ArrayRef<const Expr*> Args; 8320 8321 SourceLocation Loc = FD->getLocation(); 8322 8323 APValue Scratch; 8324 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) { 8325 // Evaluate the call as a constant initializer, to allow the construction 8326 // of objects of non-literal types. 8327 Info.setEvaluatingDecl(This.getLValueBase(), Scratch); 8328 HandleConstructorCall(Loc, This, Args, CD, Info, Scratch); 8329 } else 8330 HandleFunctionCall(Loc, FD, (MD && MD->isInstance()) ? &This : 0, 8331 Args, FD->getBody(), Info, Scratch); 8332 8333 return Diags.empty(); 8334} 8335