1 //===--- ExprConstant.cpp - Expression Constant Evaluator -----------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the Expr constant evaluator. 10 // 11 // Constant expression evaluation produces four main results: 12 // 13 // * A success/failure flag indicating whether constant folding was successful. 14 // This is the 'bool' return value used by most of the code in this file. A 15 // 'false' return value indicates that constant folding has failed, and any 16 // appropriate diagnostic has already been produced. 17 // 18 // * An evaluated result, valid only if constant folding has not failed. 19 // 20 // * A flag indicating if evaluation encountered (unevaluated) side-effects. 21 // These arise in cases such as (sideEffect(), 0) and (sideEffect() || 1), 22 // where it is possible to determine the evaluated result regardless. 23 // 24 // * A set of notes indicating why the evaluation was not a constant expression 25 // (under the C++11 / C++1y rules only, at the moment), or, if folding failed 26 // too, why the expression could not be folded. 27 // 28 // If we are checking for a potential constant expression, failure to constant 29 // fold a potential constant sub-expression will be indicated by a 'false' 30 // return value (the expression could not be folded) and no diagnostic (the 31 // expression is not necessarily non-constant). 32 // 33 //===----------------------------------------------------------------------===// 34 35 #include "Interp/Context.h" 36 #include "Interp/Frame.h" 37 #include "Interp/State.h" 38 #include "clang/AST/APValue.h" 39 #include "clang/AST/ASTContext.h" 40 #include "clang/AST/ASTDiagnostic.h" 41 #include "clang/AST/ASTLambda.h" 42 #include "clang/AST/Attr.h" 43 #include "clang/AST/CXXInheritance.h" 44 #include "clang/AST/CharUnits.h" 45 #include "clang/AST/CurrentSourceLocExprScope.h" 46 #include "clang/AST/Expr.h" 47 #include "clang/AST/OSLog.h" 48 #include "clang/AST/OptionalDiagnostic.h" 49 #include "clang/AST/RecordLayout.h" 50 #include "clang/AST/StmtVisitor.h" 51 #include "clang/AST/TypeLoc.h" 52 #include "clang/Basic/Builtins.h" 53 #include "clang/Basic/FixedPoint.h" 54 #include "clang/Basic/TargetInfo.h" 55 #include "llvm/ADT/Optional.h" 56 #include "llvm/ADT/SmallBitVector.h" 57 #include "llvm/Support/SaveAndRestore.h" 58 #include "llvm/Support/raw_ostream.h" 59 #include <cstring> 60 #include <functional> 61 62 #define DEBUG_TYPE "exprconstant" 63 64 using namespace clang; 65 using llvm::APInt; 66 using llvm::APSInt; 67 using llvm::APFloat; 68 using llvm::Optional; 69 70 namespace { 71 struct LValue; 72 class CallStackFrame; 73 class EvalInfo; 74 75 using SourceLocExprScopeGuard = 76 CurrentSourceLocExprScope::SourceLocExprScopeGuard; 77 78 static QualType getType(APValue::LValueBase B) { 79 if (!B) return QualType(); 80 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) { 81 // FIXME: It's unclear where we're supposed to take the type from, and 82 // this actually matters for arrays of unknown bound. Eg: 83 // 84 // extern int arr[]; void f() { extern int arr[3]; }; 85 // constexpr int *p = &arr[1]; // valid? 86 // 87 // For now, we take the array bound from the most recent declaration. 88 for (auto *Redecl = cast<ValueDecl>(D->getMostRecentDecl()); Redecl; 89 Redecl = cast_or_null<ValueDecl>(Redecl->getPreviousDecl())) { 90 QualType T = Redecl->getType(); 91 if (!T->isIncompleteArrayType()) 92 return T; 93 } 94 return D->getType(); 95 } 96 97 if (B.is<TypeInfoLValue>()) 98 return B.getTypeInfoType(); 99 100 if (B.is<DynamicAllocLValue>()) 101 return B.getDynamicAllocType(); 102 103 const Expr *Base = B.get<const Expr*>(); 104 105 // For a materialized temporary, the type of the temporary we materialized 106 // may not be the type of the expression. 107 if (const MaterializeTemporaryExpr *MTE = 108 dyn_cast<MaterializeTemporaryExpr>(Base)) { 109 SmallVector<const Expr *, 2> CommaLHSs; 110 SmallVector<SubobjectAdjustment, 2> Adjustments; 111 const Expr *Temp = MTE->getSubExpr(); 112 const Expr *Inner = Temp->skipRValueSubobjectAdjustments(CommaLHSs, 113 Adjustments); 114 // Keep any cv-qualifiers from the reference if we generated a temporary 115 // for it directly. Otherwise use the type after adjustment. 116 if (!Adjustments.empty()) 117 return Inner->getType(); 118 } 119 120 return Base->getType(); 121 } 122 123 /// Get an LValue path entry, which is known to not be an array index, as a 124 /// field declaration. 125 static const FieldDecl *getAsField(APValue::LValuePathEntry E) { 126 return dyn_cast_or_null<FieldDecl>(E.getAsBaseOrMember().getPointer()); 127 } 128 /// Get an LValue path entry, which is known to not be an array index, as a 129 /// base class declaration. 130 static const CXXRecordDecl *getAsBaseClass(APValue::LValuePathEntry E) { 131 return dyn_cast_or_null<CXXRecordDecl>(E.getAsBaseOrMember().getPointer()); 132 } 133 /// Determine whether this LValue path entry for a base class names a virtual 134 /// base class. 135 static bool isVirtualBaseClass(APValue::LValuePathEntry E) { 136 return E.getAsBaseOrMember().getInt(); 137 } 138 139 /// Given an expression, determine the type used to store the result of 140 /// evaluating that expression. 141 static QualType getStorageType(const ASTContext &Ctx, const Expr *E) { 142 if (E->isRValue()) 143 return E->getType(); 144 return Ctx.getLValueReferenceType(E->getType()); 145 } 146 147 /// Given a CallExpr, try to get the alloc_size attribute. May return null. 148 static const AllocSizeAttr *getAllocSizeAttr(const CallExpr *CE) { 149 const FunctionDecl *Callee = CE->getDirectCallee(); 150 return Callee ? Callee->getAttr<AllocSizeAttr>() : nullptr; 151 } 152 153 /// Attempts to unwrap a CallExpr (with an alloc_size attribute) from an Expr. 154 /// This will look through a single cast. 155 /// 156 /// Returns null if we couldn't unwrap a function with alloc_size. 157 static const CallExpr *tryUnwrapAllocSizeCall(const Expr *E) { 158 if (!E->getType()->isPointerType()) 159 return nullptr; 160 161 E = E->IgnoreParens(); 162 // If we're doing a variable assignment from e.g. malloc(N), there will 163 // probably be a cast of some kind. In exotic cases, we might also see a 164 // top-level ExprWithCleanups. Ignore them either way. 165 if (const auto *FE = dyn_cast<FullExpr>(E)) 166 E = FE->getSubExpr()->IgnoreParens(); 167 168 if (const auto *Cast = dyn_cast<CastExpr>(E)) 169 E = Cast->getSubExpr()->IgnoreParens(); 170 171 if (const auto *CE = dyn_cast<CallExpr>(E)) 172 return getAllocSizeAttr(CE) ? CE : nullptr; 173 return nullptr; 174 } 175 176 /// Determines whether or not the given Base contains a call to a function 177 /// with the alloc_size attribute. 178 static bool isBaseAnAllocSizeCall(APValue::LValueBase Base) { 179 const auto *E = Base.dyn_cast<const Expr *>(); 180 return E && E->getType()->isPointerType() && tryUnwrapAllocSizeCall(E); 181 } 182 183 /// The bound to claim that an array of unknown bound has. 184 /// The value in MostDerivedArraySize is undefined in this case. So, set it 185 /// to an arbitrary value that's likely to loudly break things if it's used. 186 static const uint64_t AssumedSizeForUnsizedArray = 187 std::numeric_limits<uint64_t>::max() / 2; 188 189 /// Determines if an LValue with the given LValueBase will have an unsized 190 /// array in its designator. 191 /// Find the path length and type of the most-derived subobject in the given 192 /// path, and find the size of the containing array, if any. 193 static unsigned 194 findMostDerivedSubobject(ASTContext &Ctx, APValue::LValueBase Base, 195 ArrayRef<APValue::LValuePathEntry> Path, 196 uint64_t &ArraySize, QualType &Type, bool &IsArray, 197 bool &FirstEntryIsUnsizedArray) { 198 // This only accepts LValueBases from APValues, and APValues don't support 199 // arrays that lack size info. 200 assert(!isBaseAnAllocSizeCall(Base) && 201 "Unsized arrays shouldn't appear here"); 202 unsigned MostDerivedLength = 0; 203 Type = getType(Base); 204 205 for (unsigned I = 0, N = Path.size(); I != N; ++I) { 206 if (Type->isArrayType()) { 207 const ArrayType *AT = Ctx.getAsArrayType(Type); 208 Type = AT->getElementType(); 209 MostDerivedLength = I + 1; 210 IsArray = true; 211 212 if (auto *CAT = dyn_cast<ConstantArrayType>(AT)) { 213 ArraySize = CAT->getSize().getZExtValue(); 214 } else { 215 assert(I == 0 && "unexpected unsized array designator"); 216 FirstEntryIsUnsizedArray = true; 217 ArraySize = AssumedSizeForUnsizedArray; 218 } 219 } else if (Type->isAnyComplexType()) { 220 const ComplexType *CT = Type->castAs<ComplexType>(); 221 Type = CT->getElementType(); 222 ArraySize = 2; 223 MostDerivedLength = I + 1; 224 IsArray = true; 225 } else if (const FieldDecl *FD = getAsField(Path[I])) { 226 Type = FD->getType(); 227 ArraySize = 0; 228 MostDerivedLength = I + 1; 229 IsArray = false; 230 } else { 231 // Path[I] describes a base class. 232 ArraySize = 0; 233 IsArray = false; 234 } 235 } 236 return MostDerivedLength; 237 } 238 239 /// A path from a glvalue to a subobject of that glvalue. 240 struct SubobjectDesignator { 241 /// True if the subobject was named in a manner not supported by C++11. Such 242 /// lvalues can still be folded, but they are not core constant expressions 243 /// and we cannot perform lvalue-to-rvalue conversions on them. 244 unsigned Invalid : 1; 245 246 /// Is this a pointer one past the end of an object? 247 unsigned IsOnePastTheEnd : 1; 248 249 /// Indicator of whether the first entry is an unsized array. 250 unsigned FirstEntryIsAnUnsizedArray : 1; 251 252 /// Indicator of whether the most-derived object is an array element. 253 unsigned MostDerivedIsArrayElement : 1; 254 255 /// The length of the path to the most-derived object of which this is a 256 /// subobject. 257 unsigned MostDerivedPathLength : 28; 258 259 /// The size of the array of which the most-derived object is an element. 260 /// This will always be 0 if the most-derived object is not an array 261 /// element. 0 is not an indicator of whether or not the most-derived object 262 /// is an array, however, because 0-length arrays are allowed. 263 /// 264 /// If the current array is an unsized array, the value of this is 265 /// undefined. 266 uint64_t MostDerivedArraySize; 267 268 /// The type of the most derived object referred to by this address. 269 QualType MostDerivedType; 270 271 typedef APValue::LValuePathEntry PathEntry; 272 273 /// The entries on the path from the glvalue to the designated subobject. 274 SmallVector<PathEntry, 8> Entries; 275 276 SubobjectDesignator() : Invalid(true) {} 277 278 explicit SubobjectDesignator(QualType T) 279 : Invalid(false), IsOnePastTheEnd(false), 280 FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false), 281 MostDerivedPathLength(0), MostDerivedArraySize(0), 282 MostDerivedType(T) {} 283 284 SubobjectDesignator(ASTContext &Ctx, const APValue &V) 285 : Invalid(!V.isLValue() || !V.hasLValuePath()), IsOnePastTheEnd(false), 286 FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false), 287 MostDerivedPathLength(0), MostDerivedArraySize(0) { 288 assert(V.isLValue() && "Non-LValue used to make an LValue designator?"); 289 if (!Invalid) { 290 IsOnePastTheEnd = V.isLValueOnePastTheEnd(); 291 ArrayRef<PathEntry> VEntries = V.getLValuePath(); 292 Entries.insert(Entries.end(), VEntries.begin(), VEntries.end()); 293 if (V.getLValueBase()) { 294 bool IsArray = false; 295 bool FirstIsUnsizedArray = false; 296 MostDerivedPathLength = findMostDerivedSubobject( 297 Ctx, V.getLValueBase(), V.getLValuePath(), MostDerivedArraySize, 298 MostDerivedType, IsArray, FirstIsUnsizedArray); 299 MostDerivedIsArrayElement = IsArray; 300 FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray; 301 } 302 } 303 } 304 305 void truncate(ASTContext &Ctx, APValue::LValueBase Base, 306 unsigned NewLength) { 307 if (Invalid) 308 return; 309 310 assert(Base && "cannot truncate path for null pointer"); 311 assert(NewLength <= Entries.size() && "not a truncation"); 312 313 if (NewLength == Entries.size()) 314 return; 315 Entries.resize(NewLength); 316 317 bool IsArray = false; 318 bool FirstIsUnsizedArray = false; 319 MostDerivedPathLength = findMostDerivedSubobject( 320 Ctx, Base, Entries, MostDerivedArraySize, MostDerivedType, IsArray, 321 FirstIsUnsizedArray); 322 MostDerivedIsArrayElement = IsArray; 323 FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray; 324 } 325 326 void setInvalid() { 327 Invalid = true; 328 Entries.clear(); 329 } 330 331 /// Determine whether the most derived subobject is an array without a 332 /// known bound. 333 bool isMostDerivedAnUnsizedArray() const { 334 assert(!Invalid && "Calling this makes no sense on invalid designators"); 335 return Entries.size() == 1 && FirstEntryIsAnUnsizedArray; 336 } 337 338 /// Determine what the most derived array's size is. Results in an assertion 339 /// failure if the most derived array lacks a size. 340 uint64_t getMostDerivedArraySize() const { 341 assert(!isMostDerivedAnUnsizedArray() && "Unsized array has no size"); 342 return MostDerivedArraySize; 343 } 344 345 /// Determine whether this is a one-past-the-end pointer. 346 bool isOnePastTheEnd() const { 347 assert(!Invalid); 348 if (IsOnePastTheEnd) 349 return true; 350 if (!isMostDerivedAnUnsizedArray() && MostDerivedIsArrayElement && 351 Entries[MostDerivedPathLength - 1].getAsArrayIndex() == 352 MostDerivedArraySize) 353 return true; 354 return false; 355 } 356 357 /// Get the range of valid index adjustments in the form 358 /// {maximum value that can be subtracted from this pointer, 359 /// maximum value that can be added to this pointer} 360 std::pair<uint64_t, uint64_t> validIndexAdjustments() { 361 if (Invalid || isMostDerivedAnUnsizedArray()) 362 return {0, 0}; 363 364 // [expr.add]p4: For the purposes of these operators, a pointer to a 365 // nonarray object behaves the same as a pointer to the first element of 366 // an array of length one with the type of the object as its element type. 367 bool IsArray = MostDerivedPathLength == Entries.size() && 368 MostDerivedIsArrayElement; 369 uint64_t ArrayIndex = IsArray ? Entries.back().getAsArrayIndex() 370 : (uint64_t)IsOnePastTheEnd; 371 uint64_t ArraySize = 372 IsArray ? getMostDerivedArraySize() : (uint64_t)1; 373 return {ArrayIndex, ArraySize - ArrayIndex}; 374 } 375 376 /// Check that this refers to a valid subobject. 377 bool isValidSubobject() const { 378 if (Invalid) 379 return false; 380 return !isOnePastTheEnd(); 381 } 382 /// Check that this refers to a valid subobject, and if not, produce a 383 /// relevant diagnostic and set the designator as invalid. 384 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK); 385 386 /// Get the type of the designated object. 387 QualType getType(ASTContext &Ctx) const { 388 assert(!Invalid && "invalid designator has no subobject type"); 389 return MostDerivedPathLength == Entries.size() 390 ? MostDerivedType 391 : Ctx.getRecordType(getAsBaseClass(Entries.back())); 392 } 393 394 /// Update this designator to refer to the first element within this array. 395 void addArrayUnchecked(const ConstantArrayType *CAT) { 396 Entries.push_back(PathEntry::ArrayIndex(0)); 397 398 // This is a most-derived object. 399 MostDerivedType = CAT->getElementType(); 400 MostDerivedIsArrayElement = true; 401 MostDerivedArraySize = CAT->getSize().getZExtValue(); 402 MostDerivedPathLength = Entries.size(); 403 } 404 /// Update this designator to refer to the first element within the array of 405 /// elements of type T. This is an array of unknown size. 406 void addUnsizedArrayUnchecked(QualType ElemTy) { 407 Entries.push_back(PathEntry::ArrayIndex(0)); 408 409 MostDerivedType = ElemTy; 410 MostDerivedIsArrayElement = true; 411 // The value in MostDerivedArraySize is undefined in this case. So, set it 412 // to an arbitrary value that's likely to loudly break things if it's 413 // used. 414 MostDerivedArraySize = AssumedSizeForUnsizedArray; 415 MostDerivedPathLength = Entries.size(); 416 } 417 /// Update this designator to refer to the given base or member of this 418 /// object. 419 void addDeclUnchecked(const Decl *D, bool Virtual = false) { 420 Entries.push_back(APValue::BaseOrMemberType(D, Virtual)); 421 422 // If this isn't a base class, it's a new most-derived object. 423 if (const FieldDecl *FD = dyn_cast<FieldDecl>(D)) { 424 MostDerivedType = FD->getType(); 425 MostDerivedIsArrayElement = false; 426 MostDerivedArraySize = 0; 427 MostDerivedPathLength = Entries.size(); 428 } 429 } 430 /// Update this designator to refer to the given complex component. 431 void addComplexUnchecked(QualType EltTy, bool Imag) { 432 Entries.push_back(PathEntry::ArrayIndex(Imag)); 433 434 // This is technically a most-derived object, though in practice this 435 // is unlikely to matter. 436 MostDerivedType = EltTy; 437 MostDerivedIsArrayElement = true; 438 MostDerivedArraySize = 2; 439 MostDerivedPathLength = Entries.size(); 440 } 441 void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, const Expr *E); 442 void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E, 443 const APSInt &N); 444 /// Add N to the address of this subobject. 445 void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) { 446 if (Invalid || !N) return; 447 uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue(); 448 if (isMostDerivedAnUnsizedArray()) { 449 diagnoseUnsizedArrayPointerArithmetic(Info, E); 450 // Can't verify -- trust that the user is doing the right thing (or if 451 // not, trust that the caller will catch the bad behavior). 452 // FIXME: Should we reject if this overflows, at least? 453 Entries.back() = PathEntry::ArrayIndex( 454 Entries.back().getAsArrayIndex() + TruncatedN); 455 return; 456 } 457 458 // [expr.add]p4: For the purposes of these operators, a pointer to a 459 // nonarray object behaves the same as a pointer to the first element of 460 // an array of length one with the type of the object as its element type. 461 bool IsArray = MostDerivedPathLength == Entries.size() && 462 MostDerivedIsArrayElement; 463 uint64_t ArrayIndex = IsArray ? Entries.back().getAsArrayIndex() 464 : (uint64_t)IsOnePastTheEnd; 465 uint64_t ArraySize = 466 IsArray ? getMostDerivedArraySize() : (uint64_t)1; 467 468 if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) { 469 // Calculate the actual index in a wide enough type, so we can include 470 // it in the note. 471 N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65)); 472 (llvm::APInt&)N += ArrayIndex; 473 assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index"); 474 diagnosePointerArithmetic(Info, E, N); 475 setInvalid(); 476 return; 477 } 478 479 ArrayIndex += TruncatedN; 480 assert(ArrayIndex <= ArraySize && 481 "bounds check succeeded for out-of-bounds index"); 482 483 if (IsArray) 484 Entries.back() = PathEntry::ArrayIndex(ArrayIndex); 485 else 486 IsOnePastTheEnd = (ArrayIndex != 0); 487 } 488 }; 489 490 /// A stack frame in the constexpr call stack. 491 class CallStackFrame : public interp::Frame { 492 public: 493 EvalInfo &Info; 494 495 /// Parent - The caller of this stack frame. 496 CallStackFrame *Caller; 497 498 /// Callee - The function which was called. 499 const FunctionDecl *Callee; 500 501 /// This - The binding for the this pointer in this call, if any. 502 const LValue *This; 503 504 /// Arguments - Parameter bindings for this function call, indexed by 505 /// parameters' function scope indices. 506 APValue *Arguments; 507 508 /// Source location information about the default argument or default 509 /// initializer expression we're evaluating, if any. 510 CurrentSourceLocExprScope CurSourceLocExprScope; 511 512 // Note that we intentionally use std::map here so that references to 513 // values are stable. 514 typedef std::pair<const void *, unsigned> MapKeyTy; 515 typedef std::map<MapKeyTy, APValue> MapTy; 516 /// Temporaries - Temporary lvalues materialized within this stack frame. 517 MapTy Temporaries; 518 519 /// CallLoc - The location of the call expression for this call. 520 SourceLocation CallLoc; 521 522 /// Index - The call index of this call. 523 unsigned Index; 524 525 /// The stack of integers for tracking version numbers for temporaries. 526 SmallVector<unsigned, 2> TempVersionStack = {1}; 527 unsigned CurTempVersion = TempVersionStack.back(); 528 529 unsigned getTempVersion() const { return TempVersionStack.back(); } 530 531 void pushTempVersion() { 532 TempVersionStack.push_back(++CurTempVersion); 533 } 534 535 void popTempVersion() { 536 TempVersionStack.pop_back(); 537 } 538 539 // FIXME: Adding this to every 'CallStackFrame' may have a nontrivial impact 540 // on the overall stack usage of deeply-recursing constexpr evaluations. 541 // (We should cache this map rather than recomputing it repeatedly.) 542 // But let's try this and see how it goes; we can look into caching the map 543 // as a later change. 544 545 /// LambdaCaptureFields - Mapping from captured variables/this to 546 /// corresponding data members in the closure class. 547 llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields; 548 FieldDecl *LambdaThisCaptureField; 549 550 CallStackFrame(EvalInfo &Info, SourceLocation CallLoc, 551 const FunctionDecl *Callee, const LValue *This, 552 APValue *Arguments); 553 ~CallStackFrame(); 554 555 // Return the temporary for Key whose version number is Version. 556 APValue *getTemporary(const void *Key, unsigned Version) { 557 MapKeyTy KV(Key, Version); 558 auto LB = Temporaries.lower_bound(KV); 559 if (LB != Temporaries.end() && LB->first == KV) 560 return &LB->second; 561 // Pair (Key,Version) wasn't found in the map. Check that no elements 562 // in the map have 'Key' as their key. 563 assert((LB == Temporaries.end() || LB->first.first != Key) && 564 (LB == Temporaries.begin() || std::prev(LB)->first.first != Key) && 565 "Element with key 'Key' found in map"); 566 return nullptr; 567 } 568 569 // Return the current temporary for Key in the map. 570 APValue *getCurrentTemporary(const void *Key) { 571 auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX)); 572 if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key) 573 return &std::prev(UB)->second; 574 return nullptr; 575 } 576 577 // Return the version number of the current temporary for Key. 578 unsigned getCurrentTemporaryVersion(const void *Key) const { 579 auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX)); 580 if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key) 581 return std::prev(UB)->first.second; 582 return 0; 583 } 584 585 /// Allocate storage for an object of type T in this stack frame. 586 /// Populates LV with a handle to the created object. Key identifies 587 /// the temporary within the stack frame, and must not be reused without 588 /// bumping the temporary version number. 589 template<typename KeyT> 590 APValue &createTemporary(const KeyT *Key, QualType T, 591 bool IsLifetimeExtended, LValue &LV); 592 593 void describe(llvm::raw_ostream &OS) override; 594 595 Frame *getCaller() const override { return Caller; } 596 SourceLocation getCallLocation() const override { return CallLoc; } 597 const FunctionDecl *getCallee() const override { return Callee; } 598 599 bool isStdFunction() const { 600 for (const DeclContext *DC = Callee; DC; DC = DC->getParent()) 601 if (DC->isStdNamespace()) 602 return true; 603 return false; 604 } 605 }; 606 607 /// Temporarily override 'this'. 608 class ThisOverrideRAII { 609 public: 610 ThisOverrideRAII(CallStackFrame &Frame, const LValue *NewThis, bool Enable) 611 : Frame(Frame), OldThis(Frame.This) { 612 if (Enable) 613 Frame.This = NewThis; 614 } 615 ~ThisOverrideRAII() { 616 Frame.This = OldThis; 617 } 618 private: 619 CallStackFrame &Frame; 620 const LValue *OldThis; 621 }; 622 } 623 624 static bool HandleDestruction(EvalInfo &Info, const Expr *E, 625 const LValue &This, QualType ThisType); 626 static bool HandleDestruction(EvalInfo &Info, SourceLocation Loc, 627 APValue::LValueBase LVBase, APValue &Value, 628 QualType T); 629 630 namespace { 631 /// A cleanup, and a flag indicating whether it is lifetime-extended. 632 class Cleanup { 633 llvm::PointerIntPair<APValue*, 1, bool> Value; 634 APValue::LValueBase Base; 635 QualType T; 636 637 public: 638 Cleanup(APValue *Val, APValue::LValueBase Base, QualType T, 639 bool IsLifetimeExtended) 640 : Value(Val, IsLifetimeExtended), Base(Base), T(T) {} 641 642 bool isLifetimeExtended() const { return Value.getInt(); } 643 bool endLifetime(EvalInfo &Info, bool RunDestructors) { 644 if (RunDestructors) { 645 SourceLocation Loc; 646 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) 647 Loc = VD->getLocation(); 648 else if (const Expr *E = Base.dyn_cast<const Expr*>()) 649 Loc = E->getExprLoc(); 650 return HandleDestruction(Info, Loc, Base, *Value.getPointer(), T); 651 } 652 *Value.getPointer() = APValue(); 653 return true; 654 } 655 656 bool hasSideEffect() { 657 return T.isDestructedType(); 658 } 659 }; 660 661 /// A reference to an object whose construction we are currently evaluating. 662 struct ObjectUnderConstruction { 663 APValue::LValueBase Base; 664 ArrayRef<APValue::LValuePathEntry> Path; 665 friend bool operator==(const ObjectUnderConstruction &LHS, 666 const ObjectUnderConstruction &RHS) { 667 return LHS.Base == RHS.Base && LHS.Path == RHS.Path; 668 } 669 friend llvm::hash_code hash_value(const ObjectUnderConstruction &Obj) { 670 return llvm::hash_combine(Obj.Base, Obj.Path); 671 } 672 }; 673 enum class ConstructionPhase { 674 None, 675 Bases, 676 AfterBases, 677 Destroying, 678 DestroyingBases 679 }; 680 } 681 682 namespace llvm { 683 template<> struct DenseMapInfo<ObjectUnderConstruction> { 684 using Base = DenseMapInfo<APValue::LValueBase>; 685 static ObjectUnderConstruction getEmptyKey() { 686 return {Base::getEmptyKey(), {}}; } 687 static ObjectUnderConstruction getTombstoneKey() { 688 return {Base::getTombstoneKey(), {}}; 689 } 690 static unsigned getHashValue(const ObjectUnderConstruction &Object) { 691 return hash_value(Object); 692 } 693 static bool isEqual(const ObjectUnderConstruction &LHS, 694 const ObjectUnderConstruction &RHS) { 695 return LHS == RHS; 696 } 697 }; 698 } 699 700 namespace { 701 /// A dynamically-allocated heap object. 702 struct DynAlloc { 703 /// The value of this heap-allocated object. 704 APValue Value; 705 /// The allocating expression; used for diagnostics. Either a CXXNewExpr 706 /// or a CallExpr (the latter is for direct calls to operator new inside 707 /// std::allocator<T>::allocate). 708 const Expr *AllocExpr = nullptr; 709 710 enum Kind { 711 New, 712 ArrayNew, 713 StdAllocator 714 }; 715 716 /// Get the kind of the allocation. This must match between allocation 717 /// and deallocation. 718 Kind getKind() const { 719 if (auto *NE = dyn_cast<CXXNewExpr>(AllocExpr)) 720 return NE->isArray() ? ArrayNew : New; 721 assert(isa<CallExpr>(AllocExpr)); 722 return StdAllocator; 723 } 724 }; 725 726 struct DynAllocOrder { 727 bool operator()(DynamicAllocLValue L, DynamicAllocLValue R) const { 728 return L.getIndex() < R.getIndex(); 729 } 730 }; 731 732 /// EvalInfo - This is a private struct used by the evaluator to capture 733 /// information about a subexpression as it is folded. It retains information 734 /// about the AST context, but also maintains information about the folded 735 /// expression. 736 /// 737 /// If an expression could be evaluated, it is still possible it is not a C 738 /// "integer constant expression" or constant expression. If not, this struct 739 /// captures information about how and why not. 740 /// 741 /// One bit of information passed *into* the request for constant folding 742 /// indicates whether the subexpression is "evaluated" or not according to C 743 /// rules. For example, the RHS of (0 && foo()) is not evaluated. We can 744 /// evaluate the expression regardless of what the RHS is, but C only allows 745 /// certain things in certain situations. 746 class EvalInfo : public interp::State { 747 public: 748 ASTContext &Ctx; 749 750 /// EvalStatus - Contains information about the evaluation. 751 Expr::EvalStatus &EvalStatus; 752 753 /// CurrentCall - The top of the constexpr call stack. 754 CallStackFrame *CurrentCall; 755 756 /// CallStackDepth - The number of calls in the call stack right now. 757 unsigned CallStackDepth; 758 759 /// NextCallIndex - The next call index to assign. 760 unsigned NextCallIndex; 761 762 /// StepsLeft - The remaining number of evaluation steps we're permitted 763 /// to perform. This is essentially a limit for the number of statements 764 /// we will evaluate. 765 unsigned StepsLeft; 766 767 /// Enable the experimental new constant interpreter. If an expression is 768 /// not supported by the interpreter, an error is triggered. 769 bool EnableNewConstInterp; 770 771 /// BottomFrame - The frame in which evaluation started. This must be 772 /// initialized after CurrentCall and CallStackDepth. 773 CallStackFrame BottomFrame; 774 775 /// A stack of values whose lifetimes end at the end of some surrounding 776 /// evaluation frame. 777 llvm::SmallVector<Cleanup, 16> CleanupStack; 778 779 /// EvaluatingDecl - This is the declaration whose initializer is being 780 /// evaluated, if any. 781 APValue::LValueBase EvaluatingDecl; 782 783 enum class EvaluatingDeclKind { 784 None, 785 /// We're evaluating the construction of EvaluatingDecl. 786 Ctor, 787 /// We're evaluating the destruction of EvaluatingDecl. 788 Dtor, 789 }; 790 EvaluatingDeclKind IsEvaluatingDecl = EvaluatingDeclKind::None; 791 792 /// EvaluatingDeclValue - This is the value being constructed for the 793 /// declaration whose initializer is being evaluated, if any. 794 APValue *EvaluatingDeclValue; 795 796 /// Set of objects that are currently being constructed. 797 llvm::DenseMap<ObjectUnderConstruction, ConstructionPhase> 798 ObjectsUnderConstruction; 799 800 /// Current heap allocations, along with the location where each was 801 /// allocated. We use std::map here because we need stable addresses 802 /// for the stored APValues. 803 std::map<DynamicAllocLValue, DynAlloc, DynAllocOrder> HeapAllocs; 804 805 /// The number of heap allocations performed so far in this evaluation. 806 unsigned NumHeapAllocs = 0; 807 808 struct EvaluatingConstructorRAII { 809 EvalInfo &EI; 810 ObjectUnderConstruction Object; 811 bool DidInsert; 812 EvaluatingConstructorRAII(EvalInfo &EI, ObjectUnderConstruction Object, 813 bool HasBases) 814 : EI(EI), Object(Object) { 815 DidInsert = 816 EI.ObjectsUnderConstruction 817 .insert({Object, HasBases ? ConstructionPhase::Bases 818 : ConstructionPhase::AfterBases}) 819 .second; 820 } 821 void finishedConstructingBases() { 822 EI.ObjectsUnderConstruction[Object] = ConstructionPhase::AfterBases; 823 } 824 ~EvaluatingConstructorRAII() { 825 if (DidInsert) EI.ObjectsUnderConstruction.erase(Object); 826 } 827 }; 828 829 struct EvaluatingDestructorRAII { 830 EvalInfo &EI; 831 ObjectUnderConstruction Object; 832 bool DidInsert; 833 EvaluatingDestructorRAII(EvalInfo &EI, ObjectUnderConstruction Object) 834 : EI(EI), Object(Object) { 835 DidInsert = EI.ObjectsUnderConstruction 836 .insert({Object, ConstructionPhase::Destroying}) 837 .second; 838 } 839 void startedDestroyingBases() { 840 EI.ObjectsUnderConstruction[Object] = 841 ConstructionPhase::DestroyingBases; 842 } 843 ~EvaluatingDestructorRAII() { 844 if (DidInsert) 845 EI.ObjectsUnderConstruction.erase(Object); 846 } 847 }; 848 849 ConstructionPhase 850 isEvaluatingCtorDtor(APValue::LValueBase Base, 851 ArrayRef<APValue::LValuePathEntry> Path) { 852 return ObjectsUnderConstruction.lookup({Base, Path}); 853 } 854 855 /// If we're currently speculatively evaluating, the outermost call stack 856 /// depth at which we can mutate state, otherwise 0. 857 unsigned SpeculativeEvaluationDepth = 0; 858 859 /// The current array initialization index, if we're performing array 860 /// initialization. 861 uint64_t ArrayInitIndex = -1; 862 863 /// HasActiveDiagnostic - Was the previous diagnostic stored? If so, further 864 /// notes attached to it will also be stored, otherwise they will not be. 865 bool HasActiveDiagnostic; 866 867 /// Have we emitted a diagnostic explaining why we couldn't constant 868 /// fold (not just why it's not strictly a constant expression)? 869 bool HasFoldFailureDiagnostic; 870 871 /// Whether or not we're in a context where the front end requires a 872 /// constant value. 873 bool InConstantContext; 874 875 /// Whether we're checking that an expression is a potential constant 876 /// expression. If so, do not fail on constructs that could become constant 877 /// later on (such as a use of an undefined global). 878 bool CheckingPotentialConstantExpression = false; 879 880 /// Whether we're checking for an expression that has undefined behavior. 881 /// If so, we will produce warnings if we encounter an operation that is 882 /// always undefined. 883 bool CheckingForUndefinedBehavior = false; 884 885 enum EvaluationMode { 886 /// Evaluate as a constant expression. Stop if we find that the expression 887 /// is not a constant expression. 888 EM_ConstantExpression, 889 890 /// Evaluate as a constant expression. Stop if we find that the expression 891 /// is not a constant expression. Some expressions can be retried in the 892 /// optimizer if we don't constant fold them here, but in an unevaluated 893 /// context we try to fold them immediately since the optimizer never 894 /// gets a chance to look at it. 895 EM_ConstantExpressionUnevaluated, 896 897 /// Fold the expression to a constant. Stop if we hit a side-effect that 898 /// we can't model. 899 EM_ConstantFold, 900 901 /// Evaluate in any way we know how. Don't worry about side-effects that 902 /// can't be modeled. 903 EM_IgnoreSideEffects, 904 } EvalMode; 905 906 /// Are we checking whether the expression is a potential constant 907 /// expression? 908 bool checkingPotentialConstantExpression() const override { 909 return CheckingPotentialConstantExpression; 910 } 911 912 /// Are we checking an expression for overflow? 913 // FIXME: We should check for any kind of undefined or suspicious behavior 914 // in such constructs, not just overflow. 915 bool checkingForUndefinedBehavior() const override { 916 return CheckingForUndefinedBehavior; 917 } 918 919 EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode) 920 : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr), 921 CallStackDepth(0), NextCallIndex(1), 922 StepsLeft(C.getLangOpts().ConstexprStepLimit), 923 EnableNewConstInterp(C.getLangOpts().EnableNewConstInterp), 924 BottomFrame(*this, SourceLocation(), nullptr, nullptr, nullptr), 925 EvaluatingDecl((const ValueDecl *)nullptr), 926 EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false), 927 HasFoldFailureDiagnostic(false), InConstantContext(false), 928 EvalMode(Mode) {} 929 930 ~EvalInfo() { 931 discardCleanups(); 932 } 933 934 void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value, 935 EvaluatingDeclKind EDK = EvaluatingDeclKind::Ctor) { 936 EvaluatingDecl = Base; 937 IsEvaluatingDecl = EDK; 938 EvaluatingDeclValue = &Value; 939 } 940 941 bool CheckCallLimit(SourceLocation Loc) { 942 // Don't perform any constexpr calls (other than the call we're checking) 943 // when checking a potential constant expression. 944 if (checkingPotentialConstantExpression() && CallStackDepth > 1) 945 return false; 946 if (NextCallIndex == 0) { 947 // NextCallIndex has wrapped around. 948 FFDiag(Loc, diag::note_constexpr_call_limit_exceeded); 949 return false; 950 } 951 if (CallStackDepth <= getLangOpts().ConstexprCallDepth) 952 return true; 953 FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded) 954 << getLangOpts().ConstexprCallDepth; 955 return false; 956 } 957 958 std::pair<CallStackFrame *, unsigned> 959 getCallFrameAndDepth(unsigned CallIndex) { 960 assert(CallIndex && "no call index in getCallFrameAndDepth"); 961 // We will eventually hit BottomFrame, which has Index 1, so Frame can't 962 // be null in this loop. 963 unsigned Depth = CallStackDepth; 964 CallStackFrame *Frame = CurrentCall; 965 while (Frame->Index > CallIndex) { 966 Frame = Frame->Caller; 967 --Depth; 968 } 969 if (Frame->Index == CallIndex) 970 return {Frame, Depth}; 971 return {nullptr, 0}; 972 } 973 974 bool nextStep(const Stmt *S) { 975 if (!StepsLeft) { 976 FFDiag(S->getBeginLoc(), diag::note_constexpr_step_limit_exceeded); 977 return false; 978 } 979 --StepsLeft; 980 return true; 981 } 982 983 APValue *createHeapAlloc(const Expr *E, QualType T, LValue &LV); 984 985 Optional<DynAlloc*> lookupDynamicAlloc(DynamicAllocLValue DA) { 986 Optional<DynAlloc*> Result; 987 auto It = HeapAllocs.find(DA); 988 if (It != HeapAllocs.end()) 989 Result = &It->second; 990 return Result; 991 } 992 993 /// Information about a stack frame for std::allocator<T>::[de]allocate. 994 struct StdAllocatorCaller { 995 unsigned FrameIndex; 996 QualType ElemType; 997 explicit operator bool() const { return FrameIndex != 0; }; 998 }; 999 1000 StdAllocatorCaller getStdAllocatorCaller(StringRef FnName) const { 1001 for (const CallStackFrame *Call = CurrentCall; Call != &BottomFrame; 1002 Call = Call->Caller) { 1003 const auto *MD = dyn_cast_or_null<CXXMethodDecl>(Call->Callee); 1004 if (!MD) 1005 continue; 1006 const IdentifierInfo *FnII = MD->getIdentifier(); 1007 if (!FnII || !FnII->isStr(FnName)) 1008 continue; 1009 1010 const auto *CTSD = 1011 dyn_cast<ClassTemplateSpecializationDecl>(MD->getParent()); 1012 if (!CTSD) 1013 continue; 1014 1015 const IdentifierInfo *ClassII = CTSD->getIdentifier(); 1016 const TemplateArgumentList &TAL = CTSD->getTemplateArgs(); 1017 if (CTSD->isInStdNamespace() && ClassII && 1018 ClassII->isStr("allocator") && TAL.size() >= 1 && 1019 TAL[0].getKind() == TemplateArgument::Type) 1020 return {Call->Index, TAL[0].getAsType()}; 1021 } 1022 1023 return {}; 1024 } 1025 1026 void performLifetimeExtension() { 1027 // Disable the cleanups for lifetime-extended temporaries. 1028 CleanupStack.erase( 1029 std::remove_if(CleanupStack.begin(), CleanupStack.end(), 1030 [](Cleanup &C) { return C.isLifetimeExtended(); }), 1031 CleanupStack.end()); 1032 } 1033 1034 /// Throw away any remaining cleanups at the end of evaluation. If any 1035 /// cleanups would have had a side-effect, note that as an unmodeled 1036 /// side-effect and return false. Otherwise, return true. 1037 bool discardCleanups() { 1038 for (Cleanup &C : CleanupStack) { 1039 if (C.hasSideEffect() && !noteSideEffect()) { 1040 CleanupStack.clear(); 1041 return false; 1042 } 1043 } 1044 CleanupStack.clear(); 1045 return true; 1046 } 1047 1048 private: 1049 interp::Frame *getCurrentFrame() override { return CurrentCall; } 1050 const interp::Frame *getBottomFrame() const override { return &BottomFrame; } 1051 1052 bool hasActiveDiagnostic() override { return HasActiveDiagnostic; } 1053 void setActiveDiagnostic(bool Flag) override { HasActiveDiagnostic = Flag; } 1054 1055 void setFoldFailureDiagnostic(bool Flag) override { 1056 HasFoldFailureDiagnostic = Flag; 1057 } 1058 1059 Expr::EvalStatus &getEvalStatus() const override { return EvalStatus; } 1060 1061 ASTContext &getCtx() const override { return Ctx; } 1062 1063 // If we have a prior diagnostic, it will be noting that the expression 1064 // isn't a constant expression. This diagnostic is more important, 1065 // unless we require this evaluation to produce a constant expression. 1066 // 1067 // FIXME: We might want to show both diagnostics to the user in 1068 // EM_ConstantFold mode. 1069 bool hasPriorDiagnostic() override { 1070 if (!EvalStatus.Diag->empty()) { 1071 switch (EvalMode) { 1072 case EM_ConstantFold: 1073 case EM_IgnoreSideEffects: 1074 if (!HasFoldFailureDiagnostic) 1075 break; 1076 // We've already failed to fold something. Keep that diagnostic. 1077 LLVM_FALLTHROUGH; 1078 case EM_ConstantExpression: 1079 case EM_ConstantExpressionUnevaluated: 1080 setActiveDiagnostic(false); 1081 return true; 1082 } 1083 } 1084 return false; 1085 } 1086 1087 unsigned getCallStackDepth() override { return CallStackDepth; } 1088 1089 public: 1090 /// Should we continue evaluation after encountering a side-effect that we 1091 /// couldn't model? 1092 bool keepEvaluatingAfterSideEffect() { 1093 switch (EvalMode) { 1094 case EM_IgnoreSideEffects: 1095 return true; 1096 1097 case EM_ConstantExpression: 1098 case EM_ConstantExpressionUnevaluated: 1099 case EM_ConstantFold: 1100 // By default, assume any side effect might be valid in some other 1101 // evaluation of this expression from a different context. 1102 return checkingPotentialConstantExpression() || 1103 checkingForUndefinedBehavior(); 1104 } 1105 llvm_unreachable("Missed EvalMode case"); 1106 } 1107 1108 /// Note that we have had a side-effect, and determine whether we should 1109 /// keep evaluating. 1110 bool noteSideEffect() { 1111 EvalStatus.HasSideEffects = true; 1112 return keepEvaluatingAfterSideEffect(); 1113 } 1114 1115 /// Should we continue evaluation after encountering undefined behavior? 1116 bool keepEvaluatingAfterUndefinedBehavior() { 1117 switch (EvalMode) { 1118 case EM_IgnoreSideEffects: 1119 case EM_ConstantFold: 1120 return true; 1121 1122 case EM_ConstantExpression: 1123 case EM_ConstantExpressionUnevaluated: 1124 return checkingForUndefinedBehavior(); 1125 } 1126 llvm_unreachable("Missed EvalMode case"); 1127 } 1128 1129 /// Note that we hit something that was technically undefined behavior, but 1130 /// that we can evaluate past it (such as signed overflow or floating-point 1131 /// division by zero.) 1132 bool noteUndefinedBehavior() override { 1133 EvalStatus.HasUndefinedBehavior = true; 1134 return keepEvaluatingAfterUndefinedBehavior(); 1135 } 1136 1137 /// Should we continue evaluation as much as possible after encountering a 1138 /// construct which can't be reduced to a value? 1139 bool keepEvaluatingAfterFailure() const override { 1140 if (!StepsLeft) 1141 return false; 1142 1143 switch (EvalMode) { 1144 case EM_ConstantExpression: 1145 case EM_ConstantExpressionUnevaluated: 1146 case EM_ConstantFold: 1147 case EM_IgnoreSideEffects: 1148 return checkingPotentialConstantExpression() || 1149 checkingForUndefinedBehavior(); 1150 } 1151 llvm_unreachable("Missed EvalMode case"); 1152 } 1153 1154 /// Notes that we failed to evaluate an expression that other expressions 1155 /// directly depend on, and determine if we should keep evaluating. This 1156 /// should only be called if we actually intend to keep evaluating. 1157 /// 1158 /// Call noteSideEffect() instead if we may be able to ignore the value that 1159 /// we failed to evaluate, e.g. if we failed to evaluate Foo() in: 1160 /// 1161 /// (Foo(), 1) // use noteSideEffect 1162 /// (Foo() || true) // use noteSideEffect 1163 /// Foo() + 1 // use noteFailure 1164 LLVM_NODISCARD bool noteFailure() { 1165 // Failure when evaluating some expression often means there is some 1166 // subexpression whose evaluation was skipped. Therefore, (because we 1167 // don't track whether we skipped an expression when unwinding after an 1168 // evaluation failure) every evaluation failure that bubbles up from a 1169 // subexpression implies that a side-effect has potentially happened. We 1170 // skip setting the HasSideEffects flag to true until we decide to 1171 // continue evaluating after that point, which happens here. 1172 bool KeepGoing = keepEvaluatingAfterFailure(); 1173 EvalStatus.HasSideEffects |= KeepGoing; 1174 return KeepGoing; 1175 } 1176 1177 class ArrayInitLoopIndex { 1178 EvalInfo &Info; 1179 uint64_t OuterIndex; 1180 1181 public: 1182 ArrayInitLoopIndex(EvalInfo &Info) 1183 : Info(Info), OuterIndex(Info.ArrayInitIndex) { 1184 Info.ArrayInitIndex = 0; 1185 } 1186 ~ArrayInitLoopIndex() { Info.ArrayInitIndex = OuterIndex; } 1187 1188 operator uint64_t&() { return Info.ArrayInitIndex; } 1189 }; 1190 }; 1191 1192 /// Object used to treat all foldable expressions as constant expressions. 1193 struct FoldConstant { 1194 EvalInfo &Info; 1195 bool Enabled; 1196 bool HadNoPriorDiags; 1197 EvalInfo::EvaluationMode OldMode; 1198 1199 explicit FoldConstant(EvalInfo &Info, bool Enabled) 1200 : Info(Info), 1201 Enabled(Enabled), 1202 HadNoPriorDiags(Info.EvalStatus.Diag && 1203 Info.EvalStatus.Diag->empty() && 1204 !Info.EvalStatus.HasSideEffects), 1205 OldMode(Info.EvalMode) { 1206 if (Enabled) 1207 Info.EvalMode = EvalInfo::EM_ConstantFold; 1208 } 1209 void keepDiagnostics() { Enabled = false; } 1210 ~FoldConstant() { 1211 if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() && 1212 !Info.EvalStatus.HasSideEffects) 1213 Info.EvalStatus.Diag->clear(); 1214 Info.EvalMode = OldMode; 1215 } 1216 }; 1217 1218 /// RAII object used to set the current evaluation mode to ignore 1219 /// side-effects. 1220 struct IgnoreSideEffectsRAII { 1221 EvalInfo &Info; 1222 EvalInfo::EvaluationMode OldMode; 1223 explicit IgnoreSideEffectsRAII(EvalInfo &Info) 1224 : Info(Info), OldMode(Info.EvalMode) { 1225 Info.EvalMode = EvalInfo::EM_IgnoreSideEffects; 1226 } 1227 1228 ~IgnoreSideEffectsRAII() { Info.EvalMode = OldMode; } 1229 }; 1230 1231 /// RAII object used to optionally suppress diagnostics and side-effects from 1232 /// a speculative evaluation. 1233 class SpeculativeEvaluationRAII { 1234 EvalInfo *Info = nullptr; 1235 Expr::EvalStatus OldStatus; 1236 unsigned OldSpeculativeEvaluationDepth; 1237 1238 void moveFromAndCancel(SpeculativeEvaluationRAII &&Other) { 1239 Info = Other.Info; 1240 OldStatus = Other.OldStatus; 1241 OldSpeculativeEvaluationDepth = Other.OldSpeculativeEvaluationDepth; 1242 Other.Info = nullptr; 1243 } 1244 1245 void maybeRestoreState() { 1246 if (!Info) 1247 return; 1248 1249 Info->EvalStatus = OldStatus; 1250 Info->SpeculativeEvaluationDepth = OldSpeculativeEvaluationDepth; 1251 } 1252 1253 public: 1254 SpeculativeEvaluationRAII() = default; 1255 1256 SpeculativeEvaluationRAII( 1257 EvalInfo &Info, SmallVectorImpl<PartialDiagnosticAt> *NewDiag = nullptr) 1258 : Info(&Info), OldStatus(Info.EvalStatus), 1259 OldSpeculativeEvaluationDepth(Info.SpeculativeEvaluationDepth) { 1260 Info.EvalStatus.Diag = NewDiag; 1261 Info.SpeculativeEvaluationDepth = Info.CallStackDepth + 1; 1262 } 1263 1264 SpeculativeEvaluationRAII(const SpeculativeEvaluationRAII &Other) = delete; 1265 SpeculativeEvaluationRAII(SpeculativeEvaluationRAII &&Other) { 1266 moveFromAndCancel(std::move(Other)); 1267 } 1268 1269 SpeculativeEvaluationRAII &operator=(SpeculativeEvaluationRAII &&Other) { 1270 maybeRestoreState(); 1271 moveFromAndCancel(std::move(Other)); 1272 return *this; 1273 } 1274 1275 ~SpeculativeEvaluationRAII() { maybeRestoreState(); } 1276 }; 1277 1278 /// RAII object wrapping a full-expression or block scope, and handling 1279 /// the ending of the lifetime of temporaries created within it. 1280 template<bool IsFullExpression> 1281 class ScopeRAII { 1282 EvalInfo &Info; 1283 unsigned OldStackSize; 1284 public: 1285 ScopeRAII(EvalInfo &Info) 1286 : Info(Info), OldStackSize(Info.CleanupStack.size()) { 1287 // Push a new temporary version. This is needed to distinguish between 1288 // temporaries created in different iterations of a loop. 1289 Info.CurrentCall->pushTempVersion(); 1290 } 1291 bool destroy(bool RunDestructors = true) { 1292 bool OK = cleanup(Info, RunDestructors, OldStackSize); 1293 OldStackSize = -1U; 1294 return OK; 1295 } 1296 ~ScopeRAII() { 1297 if (OldStackSize != -1U) 1298 destroy(false); 1299 // Body moved to a static method to encourage the compiler to inline away 1300 // instances of this class. 1301 Info.CurrentCall->popTempVersion(); 1302 } 1303 private: 1304 static bool cleanup(EvalInfo &Info, bool RunDestructors, 1305 unsigned OldStackSize) { 1306 assert(OldStackSize <= Info.CleanupStack.size() && 1307 "running cleanups out of order?"); 1308 1309 // Run all cleanups for a block scope, and non-lifetime-extended cleanups 1310 // for a full-expression scope. 1311 bool Success = true; 1312 for (unsigned I = Info.CleanupStack.size(); I > OldStackSize; --I) { 1313 if (!(IsFullExpression && 1314 Info.CleanupStack[I - 1].isLifetimeExtended())) { 1315 if (!Info.CleanupStack[I - 1].endLifetime(Info, RunDestructors)) { 1316 Success = false; 1317 break; 1318 } 1319 } 1320 } 1321 1322 // Compact lifetime-extended cleanups. 1323 auto NewEnd = Info.CleanupStack.begin() + OldStackSize; 1324 if (IsFullExpression) 1325 NewEnd = 1326 std::remove_if(NewEnd, Info.CleanupStack.end(), 1327 [](Cleanup &C) { return !C.isLifetimeExtended(); }); 1328 Info.CleanupStack.erase(NewEnd, Info.CleanupStack.end()); 1329 return Success; 1330 } 1331 }; 1332 typedef ScopeRAII<false> BlockScopeRAII; 1333 typedef ScopeRAII<true> FullExpressionRAII; 1334 } 1335 1336 bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E, 1337 CheckSubobjectKind CSK) { 1338 if (Invalid) 1339 return false; 1340 if (isOnePastTheEnd()) { 1341 Info.CCEDiag(E, diag::note_constexpr_past_end_subobject) 1342 << CSK; 1343 setInvalid(); 1344 return false; 1345 } 1346 // Note, we do not diagnose if isMostDerivedAnUnsizedArray(), because there 1347 // must actually be at least one array element; even a VLA cannot have a 1348 // bound of zero. And if our index is nonzero, we already had a CCEDiag. 1349 return true; 1350 } 1351 1352 void SubobjectDesignator::diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, 1353 const Expr *E) { 1354 Info.CCEDiag(E, diag::note_constexpr_unsized_array_indexed); 1355 // Do not set the designator as invalid: we can represent this situation, 1356 // and correct handling of __builtin_object_size requires us to do so. 1357 } 1358 1359 void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info, 1360 const Expr *E, 1361 const APSInt &N) { 1362 // If we're complaining, we must be able to statically determine the size of 1363 // the most derived array. 1364 if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement) 1365 Info.CCEDiag(E, diag::note_constexpr_array_index) 1366 << N << /*array*/ 0 1367 << static_cast<unsigned>(getMostDerivedArraySize()); 1368 else 1369 Info.CCEDiag(E, diag::note_constexpr_array_index) 1370 << N << /*non-array*/ 1; 1371 setInvalid(); 1372 } 1373 1374 CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc, 1375 const FunctionDecl *Callee, const LValue *This, 1376 APValue *Arguments) 1377 : Info(Info), Caller(Info.CurrentCall), Callee(Callee), This(This), 1378 Arguments(Arguments), CallLoc(CallLoc), Index(Info.NextCallIndex++) { 1379 Info.CurrentCall = this; 1380 ++Info.CallStackDepth; 1381 } 1382 1383 CallStackFrame::~CallStackFrame() { 1384 assert(Info.CurrentCall == this && "calls retired out of order"); 1385 --Info.CallStackDepth; 1386 Info.CurrentCall = Caller; 1387 } 1388 1389 static bool isRead(AccessKinds AK) { 1390 return AK == AK_Read || AK == AK_ReadObjectRepresentation; 1391 } 1392 1393 static bool isModification(AccessKinds AK) { 1394 switch (AK) { 1395 case AK_Read: 1396 case AK_ReadObjectRepresentation: 1397 case AK_MemberCall: 1398 case AK_DynamicCast: 1399 case AK_TypeId: 1400 return false; 1401 case AK_Assign: 1402 case AK_Increment: 1403 case AK_Decrement: 1404 case AK_Construct: 1405 case AK_Destroy: 1406 return true; 1407 } 1408 llvm_unreachable("unknown access kind"); 1409 } 1410 1411 static bool isAnyAccess(AccessKinds AK) { 1412 return isRead(AK) || isModification(AK); 1413 } 1414 1415 /// Is this an access per the C++ definition? 1416 static bool isFormalAccess(AccessKinds AK) { 1417 return isAnyAccess(AK) && AK != AK_Construct && AK != AK_Destroy; 1418 } 1419 1420 namespace { 1421 struct ComplexValue { 1422 private: 1423 bool IsInt; 1424 1425 public: 1426 APSInt IntReal, IntImag; 1427 APFloat FloatReal, FloatImag; 1428 1429 ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {} 1430 1431 void makeComplexFloat() { IsInt = false; } 1432 bool isComplexFloat() const { return !IsInt; } 1433 APFloat &getComplexFloatReal() { return FloatReal; } 1434 APFloat &getComplexFloatImag() { return FloatImag; } 1435 1436 void makeComplexInt() { IsInt = true; } 1437 bool isComplexInt() const { return IsInt; } 1438 APSInt &getComplexIntReal() { return IntReal; } 1439 APSInt &getComplexIntImag() { return IntImag; } 1440 1441 void moveInto(APValue &v) const { 1442 if (isComplexFloat()) 1443 v = APValue(FloatReal, FloatImag); 1444 else 1445 v = APValue(IntReal, IntImag); 1446 } 1447 void setFrom(const APValue &v) { 1448 assert(v.isComplexFloat() || v.isComplexInt()); 1449 if (v.isComplexFloat()) { 1450 makeComplexFloat(); 1451 FloatReal = v.getComplexFloatReal(); 1452 FloatImag = v.getComplexFloatImag(); 1453 } else { 1454 makeComplexInt(); 1455 IntReal = v.getComplexIntReal(); 1456 IntImag = v.getComplexIntImag(); 1457 } 1458 } 1459 }; 1460 1461 struct LValue { 1462 APValue::LValueBase Base; 1463 CharUnits Offset; 1464 SubobjectDesignator Designator; 1465 bool IsNullPtr : 1; 1466 bool InvalidBase : 1; 1467 1468 const APValue::LValueBase getLValueBase() const { return Base; } 1469 CharUnits &getLValueOffset() { return Offset; } 1470 const CharUnits &getLValueOffset() const { return Offset; } 1471 SubobjectDesignator &getLValueDesignator() { return Designator; } 1472 const SubobjectDesignator &getLValueDesignator() const { return Designator;} 1473 bool isNullPointer() const { return IsNullPtr;} 1474 1475 unsigned getLValueCallIndex() const { return Base.getCallIndex(); } 1476 unsigned getLValueVersion() const { return Base.getVersion(); } 1477 1478 void moveInto(APValue &V) const { 1479 if (Designator.Invalid) 1480 V = APValue(Base, Offset, APValue::NoLValuePath(), IsNullPtr); 1481 else { 1482 assert(!InvalidBase && "APValues can't handle invalid LValue bases"); 1483 V = APValue(Base, Offset, Designator.Entries, 1484 Designator.IsOnePastTheEnd, IsNullPtr); 1485 } 1486 } 1487 void setFrom(ASTContext &Ctx, const APValue &V) { 1488 assert(V.isLValue() && "Setting LValue from a non-LValue?"); 1489 Base = V.getLValueBase(); 1490 Offset = V.getLValueOffset(); 1491 InvalidBase = false; 1492 Designator = SubobjectDesignator(Ctx, V); 1493 IsNullPtr = V.isNullPointer(); 1494 } 1495 1496 void set(APValue::LValueBase B, bool BInvalid = false) { 1497 #ifndef NDEBUG 1498 // We only allow a few types of invalid bases. Enforce that here. 1499 if (BInvalid) { 1500 const auto *E = B.get<const Expr *>(); 1501 assert((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) && 1502 "Unexpected type of invalid base"); 1503 } 1504 #endif 1505 1506 Base = B; 1507 Offset = CharUnits::fromQuantity(0); 1508 InvalidBase = BInvalid; 1509 Designator = SubobjectDesignator(getType(B)); 1510 IsNullPtr = false; 1511 } 1512 1513 void setNull(ASTContext &Ctx, QualType PointerTy) { 1514 Base = (Expr *)nullptr; 1515 Offset = 1516 CharUnits::fromQuantity(Ctx.getTargetNullPointerValue(PointerTy)); 1517 InvalidBase = false; 1518 Designator = SubobjectDesignator(PointerTy->getPointeeType()); 1519 IsNullPtr = true; 1520 } 1521 1522 void setInvalid(APValue::LValueBase B, unsigned I = 0) { 1523 set(B, true); 1524 } 1525 1526 std::string toString(ASTContext &Ctx, QualType T) const { 1527 APValue Printable; 1528 moveInto(Printable); 1529 return Printable.getAsString(Ctx, T); 1530 } 1531 1532 private: 1533 // Check that this LValue is not based on a null pointer. If it is, produce 1534 // a diagnostic and mark the designator as invalid. 1535 template <typename GenDiagType> 1536 bool checkNullPointerDiagnosingWith(const GenDiagType &GenDiag) { 1537 if (Designator.Invalid) 1538 return false; 1539 if (IsNullPtr) { 1540 GenDiag(); 1541 Designator.setInvalid(); 1542 return false; 1543 } 1544 return true; 1545 } 1546 1547 public: 1548 bool checkNullPointer(EvalInfo &Info, const Expr *E, 1549 CheckSubobjectKind CSK) { 1550 return checkNullPointerDiagnosingWith([&Info, E, CSK] { 1551 Info.CCEDiag(E, diag::note_constexpr_null_subobject) << CSK; 1552 }); 1553 } 1554 1555 bool checkNullPointerForFoldAccess(EvalInfo &Info, const Expr *E, 1556 AccessKinds AK) { 1557 return checkNullPointerDiagnosingWith([&Info, E, AK] { 1558 Info.FFDiag(E, diag::note_constexpr_access_null) << AK; 1559 }); 1560 } 1561 1562 // Check this LValue refers to an object. If not, set the designator to be 1563 // invalid and emit a diagnostic. 1564 bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) { 1565 return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) && 1566 Designator.checkSubobject(Info, E, CSK); 1567 } 1568 1569 void addDecl(EvalInfo &Info, const Expr *E, 1570 const Decl *D, bool Virtual = false) { 1571 if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base)) 1572 Designator.addDeclUnchecked(D, Virtual); 1573 } 1574 void addUnsizedArray(EvalInfo &Info, const Expr *E, QualType ElemTy) { 1575 if (!Designator.Entries.empty()) { 1576 Info.CCEDiag(E, diag::note_constexpr_unsupported_unsized_array); 1577 Designator.setInvalid(); 1578 return; 1579 } 1580 if (checkSubobject(Info, E, CSK_ArrayToPointer)) { 1581 assert(getType(Base)->isPointerType() || getType(Base)->isArrayType()); 1582 Designator.FirstEntryIsAnUnsizedArray = true; 1583 Designator.addUnsizedArrayUnchecked(ElemTy); 1584 } 1585 } 1586 void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) { 1587 if (checkSubobject(Info, E, CSK_ArrayToPointer)) 1588 Designator.addArrayUnchecked(CAT); 1589 } 1590 void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) { 1591 if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real)) 1592 Designator.addComplexUnchecked(EltTy, Imag); 1593 } 1594 void clearIsNullPointer() { 1595 IsNullPtr = false; 1596 } 1597 void adjustOffsetAndIndex(EvalInfo &Info, const Expr *E, 1598 const APSInt &Index, CharUnits ElementSize) { 1599 // An index of 0 has no effect. (In C, adding 0 to a null pointer is UB, 1600 // but we're not required to diagnose it and it's valid in C++.) 1601 if (!Index) 1602 return; 1603 1604 // Compute the new offset in the appropriate width, wrapping at 64 bits. 1605 // FIXME: When compiling for a 32-bit target, we should use 32-bit 1606 // offsets. 1607 uint64_t Offset64 = Offset.getQuantity(); 1608 uint64_t ElemSize64 = ElementSize.getQuantity(); 1609 uint64_t Index64 = Index.extOrTrunc(64).getZExtValue(); 1610 Offset = CharUnits::fromQuantity(Offset64 + ElemSize64 * Index64); 1611 1612 if (checkNullPointer(Info, E, CSK_ArrayIndex)) 1613 Designator.adjustIndex(Info, E, Index); 1614 clearIsNullPointer(); 1615 } 1616 void adjustOffset(CharUnits N) { 1617 Offset += N; 1618 if (N.getQuantity()) 1619 clearIsNullPointer(); 1620 } 1621 }; 1622 1623 struct MemberPtr { 1624 MemberPtr() {} 1625 explicit MemberPtr(const ValueDecl *Decl) : 1626 DeclAndIsDerivedMember(Decl, false), Path() {} 1627 1628 /// The member or (direct or indirect) field referred to by this member 1629 /// pointer, or 0 if this is a null member pointer. 1630 const ValueDecl *getDecl() const { 1631 return DeclAndIsDerivedMember.getPointer(); 1632 } 1633 /// Is this actually a member of some type derived from the relevant class? 1634 bool isDerivedMember() const { 1635 return DeclAndIsDerivedMember.getInt(); 1636 } 1637 /// Get the class which the declaration actually lives in. 1638 const CXXRecordDecl *getContainingRecord() const { 1639 return cast<CXXRecordDecl>( 1640 DeclAndIsDerivedMember.getPointer()->getDeclContext()); 1641 } 1642 1643 void moveInto(APValue &V) const { 1644 V = APValue(getDecl(), isDerivedMember(), Path); 1645 } 1646 void setFrom(const APValue &V) { 1647 assert(V.isMemberPointer()); 1648 DeclAndIsDerivedMember.setPointer(V.getMemberPointerDecl()); 1649 DeclAndIsDerivedMember.setInt(V.isMemberPointerToDerivedMember()); 1650 Path.clear(); 1651 ArrayRef<const CXXRecordDecl*> P = V.getMemberPointerPath(); 1652 Path.insert(Path.end(), P.begin(), P.end()); 1653 } 1654 1655 /// DeclAndIsDerivedMember - The member declaration, and a flag indicating 1656 /// whether the member is a member of some class derived from the class type 1657 /// of the member pointer. 1658 llvm::PointerIntPair<const ValueDecl*, 1, bool> DeclAndIsDerivedMember; 1659 /// Path - The path of base/derived classes from the member declaration's 1660 /// class (exclusive) to the class type of the member pointer (inclusive). 1661 SmallVector<const CXXRecordDecl*, 4> Path; 1662 1663 /// Perform a cast towards the class of the Decl (either up or down the 1664 /// hierarchy). 1665 bool castBack(const CXXRecordDecl *Class) { 1666 assert(!Path.empty()); 1667 const CXXRecordDecl *Expected; 1668 if (Path.size() >= 2) 1669 Expected = Path[Path.size() - 2]; 1670 else 1671 Expected = getContainingRecord(); 1672 if (Expected->getCanonicalDecl() != Class->getCanonicalDecl()) { 1673 // C++11 [expr.static.cast]p12: In a conversion from (D::*) to (B::*), 1674 // if B does not contain the original member and is not a base or 1675 // derived class of the class containing the original member, the result 1676 // of the cast is undefined. 1677 // C++11 [conv.mem]p2 does not cover this case for a cast from (B::*) to 1678 // (D::*). We consider that to be a language defect. 1679 return false; 1680 } 1681 Path.pop_back(); 1682 return true; 1683 } 1684 /// Perform a base-to-derived member pointer cast. 1685 bool castToDerived(const CXXRecordDecl *Derived) { 1686 if (!getDecl()) 1687 return true; 1688 if (!isDerivedMember()) { 1689 Path.push_back(Derived); 1690 return true; 1691 } 1692 if (!castBack(Derived)) 1693 return false; 1694 if (Path.empty()) 1695 DeclAndIsDerivedMember.setInt(false); 1696 return true; 1697 } 1698 /// Perform a derived-to-base member pointer cast. 1699 bool castToBase(const CXXRecordDecl *Base) { 1700 if (!getDecl()) 1701 return true; 1702 if (Path.empty()) 1703 DeclAndIsDerivedMember.setInt(true); 1704 if (isDerivedMember()) { 1705 Path.push_back(Base); 1706 return true; 1707 } 1708 return castBack(Base); 1709 } 1710 }; 1711 1712 /// Compare two member pointers, which are assumed to be of the same type. 1713 static bool operator==(const MemberPtr &LHS, const MemberPtr &RHS) { 1714 if (!LHS.getDecl() || !RHS.getDecl()) 1715 return !LHS.getDecl() && !RHS.getDecl(); 1716 if (LHS.getDecl()->getCanonicalDecl() != RHS.getDecl()->getCanonicalDecl()) 1717 return false; 1718 return LHS.Path == RHS.Path; 1719 } 1720 } 1721 1722 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E); 1723 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, 1724 const LValue &This, const Expr *E, 1725 bool AllowNonLiteralTypes = false); 1726 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info, 1727 bool InvalidBaseOK = false); 1728 static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info, 1729 bool InvalidBaseOK = false); 1730 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result, 1731 EvalInfo &Info); 1732 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info); 1733 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info); 1734 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result, 1735 EvalInfo &Info); 1736 static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info); 1737 static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info); 1738 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result, 1739 EvalInfo &Info); 1740 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result); 1741 1742 /// Evaluate an integer or fixed point expression into an APResult. 1743 static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result, 1744 EvalInfo &Info); 1745 1746 /// Evaluate only a fixed point expression into an APResult. 1747 static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result, 1748 EvalInfo &Info); 1749 1750 //===----------------------------------------------------------------------===// 1751 // Misc utilities 1752 //===----------------------------------------------------------------------===// 1753 1754 /// Negate an APSInt in place, converting it to a signed form if necessary, and 1755 /// preserving its value (by extending by up to one bit as needed). 1756 static void negateAsSigned(APSInt &Int) { 1757 if (Int.isUnsigned() || Int.isMinSignedValue()) { 1758 Int = Int.extend(Int.getBitWidth() + 1); 1759 Int.setIsSigned(true); 1760 } 1761 Int = -Int; 1762 } 1763 1764 template<typename KeyT> 1765 APValue &CallStackFrame::createTemporary(const KeyT *Key, QualType T, 1766 bool IsLifetimeExtended, LValue &LV) { 1767 unsigned Version = getTempVersion(); 1768 APValue::LValueBase Base(Key, Index, Version); 1769 LV.set(Base); 1770 APValue &Result = Temporaries[MapKeyTy(Key, Version)]; 1771 assert(Result.isAbsent() && "temporary created multiple times"); 1772 1773 // If we're creating a temporary immediately in the operand of a speculative 1774 // evaluation, don't register a cleanup to be run outside the speculative 1775 // evaluation context, since we won't actually be able to initialize this 1776 // object. 1777 if (Index <= Info.SpeculativeEvaluationDepth) { 1778 if (T.isDestructedType()) 1779 Info.noteSideEffect(); 1780 } else { 1781 Info.CleanupStack.push_back(Cleanup(&Result, Base, T, IsLifetimeExtended)); 1782 } 1783 return Result; 1784 } 1785 1786 APValue *EvalInfo::createHeapAlloc(const Expr *E, QualType T, LValue &LV) { 1787 if (NumHeapAllocs > DynamicAllocLValue::getMaxIndex()) { 1788 FFDiag(E, diag::note_constexpr_heap_alloc_limit_exceeded); 1789 return nullptr; 1790 } 1791 1792 DynamicAllocLValue DA(NumHeapAllocs++); 1793 LV.set(APValue::LValueBase::getDynamicAlloc(DA, T)); 1794 auto Result = HeapAllocs.emplace(std::piecewise_construct, 1795 std::forward_as_tuple(DA), std::tuple<>()); 1796 assert(Result.second && "reused a heap alloc index?"); 1797 Result.first->second.AllocExpr = E; 1798 return &Result.first->second.Value; 1799 } 1800 1801 /// Produce a string describing the given constexpr call. 1802 void CallStackFrame::describe(raw_ostream &Out) { 1803 unsigned ArgIndex = 0; 1804 bool IsMemberCall = isa<CXXMethodDecl>(Callee) && 1805 !isa<CXXConstructorDecl>(Callee) && 1806 cast<CXXMethodDecl>(Callee)->isInstance(); 1807 1808 if (!IsMemberCall) 1809 Out << *Callee << '('; 1810 1811 if (This && IsMemberCall) { 1812 APValue Val; 1813 This->moveInto(Val); 1814 Val.printPretty(Out, Info.Ctx, 1815 This->Designator.MostDerivedType); 1816 // FIXME: Add parens around Val if needed. 1817 Out << "->" << *Callee << '('; 1818 IsMemberCall = false; 1819 } 1820 1821 for (FunctionDecl::param_const_iterator I = Callee->param_begin(), 1822 E = Callee->param_end(); I != E; ++I, ++ArgIndex) { 1823 if (ArgIndex > (unsigned)IsMemberCall) 1824 Out << ", "; 1825 1826 const ParmVarDecl *Param = *I; 1827 const APValue &Arg = Arguments[ArgIndex]; 1828 Arg.printPretty(Out, Info.Ctx, Param->getType()); 1829 1830 if (ArgIndex == 0 && IsMemberCall) 1831 Out << "->" << *Callee << '('; 1832 } 1833 1834 Out << ')'; 1835 } 1836 1837 /// Evaluate an expression to see if it had side-effects, and discard its 1838 /// result. 1839 /// \return \c true if the caller should keep evaluating. 1840 static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) { 1841 APValue Scratch; 1842 if (!Evaluate(Scratch, Info, E)) 1843 // We don't need the value, but we might have skipped a side effect here. 1844 return Info.noteSideEffect(); 1845 return true; 1846 } 1847 1848 /// Should this call expression be treated as a string literal? 1849 static bool IsStringLiteralCall(const CallExpr *E) { 1850 unsigned Builtin = E->getBuiltinCallee(); 1851 return (Builtin == Builtin::BI__builtin___CFStringMakeConstantString || 1852 Builtin == Builtin::BI__builtin___NSStringMakeConstantString); 1853 } 1854 1855 static bool IsGlobalLValue(APValue::LValueBase B) { 1856 // C++11 [expr.const]p3 An address constant expression is a prvalue core 1857 // constant expression of pointer type that evaluates to... 1858 1859 // ... a null pointer value, or a prvalue core constant expression of type 1860 // std::nullptr_t. 1861 if (!B) return true; 1862 1863 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) { 1864 // ... the address of an object with static storage duration, 1865 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 1866 return VD->hasGlobalStorage(); 1867 // ... the address of a function, 1868 return isa<FunctionDecl>(D); 1869 } 1870 1871 if (B.is<TypeInfoLValue>() || B.is<DynamicAllocLValue>()) 1872 return true; 1873 1874 const Expr *E = B.get<const Expr*>(); 1875 switch (E->getStmtClass()) { 1876 default: 1877 return false; 1878 case Expr::CompoundLiteralExprClass: { 1879 const CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E); 1880 return CLE->isFileScope() && CLE->isLValue(); 1881 } 1882 case Expr::MaterializeTemporaryExprClass: 1883 // A materialized temporary might have been lifetime-extended to static 1884 // storage duration. 1885 return cast<MaterializeTemporaryExpr>(E)->getStorageDuration() == SD_Static; 1886 // A string literal has static storage duration. 1887 case Expr::StringLiteralClass: 1888 case Expr::PredefinedExprClass: 1889 case Expr::ObjCStringLiteralClass: 1890 case Expr::ObjCEncodeExprClass: 1891 case Expr::CXXUuidofExprClass: 1892 return true; 1893 case Expr::ObjCBoxedExprClass: 1894 return cast<ObjCBoxedExpr>(E)->isExpressibleAsConstantInitializer(); 1895 case Expr::CallExprClass: 1896 return IsStringLiteralCall(cast<CallExpr>(E)); 1897 // For GCC compatibility, &&label has static storage duration. 1898 case Expr::AddrLabelExprClass: 1899 return true; 1900 // A Block literal expression may be used as the initialization value for 1901 // Block variables at global or local static scope. 1902 case Expr::BlockExprClass: 1903 return !cast<BlockExpr>(E)->getBlockDecl()->hasCaptures(); 1904 case Expr::ImplicitValueInitExprClass: 1905 // FIXME: 1906 // We can never form an lvalue with an implicit value initialization as its 1907 // base through expression evaluation, so these only appear in one case: the 1908 // implicit variable declaration we invent when checking whether a constexpr 1909 // constructor can produce a constant expression. We must assume that such 1910 // an expression might be a global lvalue. 1911 return true; 1912 } 1913 } 1914 1915 static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) { 1916 return LVal.Base.dyn_cast<const ValueDecl*>(); 1917 } 1918 1919 static bool IsLiteralLValue(const LValue &Value) { 1920 if (Value.getLValueCallIndex()) 1921 return false; 1922 const Expr *E = Value.Base.dyn_cast<const Expr*>(); 1923 return E && !isa<MaterializeTemporaryExpr>(E); 1924 } 1925 1926 static bool IsWeakLValue(const LValue &Value) { 1927 const ValueDecl *Decl = GetLValueBaseDecl(Value); 1928 return Decl && Decl->isWeak(); 1929 } 1930 1931 static bool isZeroSized(const LValue &Value) { 1932 const ValueDecl *Decl = GetLValueBaseDecl(Value); 1933 if (Decl && isa<VarDecl>(Decl)) { 1934 QualType Ty = Decl->getType(); 1935 if (Ty->isArrayType()) 1936 return Ty->isIncompleteType() || 1937 Decl->getASTContext().getTypeSize(Ty) == 0; 1938 } 1939 return false; 1940 } 1941 1942 static bool HasSameBase(const LValue &A, const LValue &B) { 1943 if (!A.getLValueBase()) 1944 return !B.getLValueBase(); 1945 if (!B.getLValueBase()) 1946 return false; 1947 1948 if (A.getLValueBase().getOpaqueValue() != 1949 B.getLValueBase().getOpaqueValue()) { 1950 const Decl *ADecl = GetLValueBaseDecl(A); 1951 if (!ADecl) 1952 return false; 1953 const Decl *BDecl = GetLValueBaseDecl(B); 1954 if (!BDecl || ADecl->getCanonicalDecl() != BDecl->getCanonicalDecl()) 1955 return false; 1956 } 1957 1958 return IsGlobalLValue(A.getLValueBase()) || 1959 (A.getLValueCallIndex() == B.getLValueCallIndex() && 1960 A.getLValueVersion() == B.getLValueVersion()); 1961 } 1962 1963 static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) { 1964 assert(Base && "no location for a null lvalue"); 1965 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>(); 1966 if (VD) 1967 Info.Note(VD->getLocation(), diag::note_declared_at); 1968 else if (const Expr *E = Base.dyn_cast<const Expr*>()) 1969 Info.Note(E->getExprLoc(), diag::note_constexpr_temporary_here); 1970 else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) { 1971 // FIXME: Produce a note for dangling pointers too. 1972 if (Optional<DynAlloc*> Alloc = Info.lookupDynamicAlloc(DA)) 1973 Info.Note((*Alloc)->AllocExpr->getExprLoc(), 1974 diag::note_constexpr_dynamic_alloc_here); 1975 } 1976 // We have no information to show for a typeid(T) object. 1977 } 1978 1979 enum class CheckEvaluationResultKind { 1980 ConstantExpression, 1981 FullyInitialized, 1982 }; 1983 1984 /// Materialized temporaries that we've already checked to determine if they're 1985 /// initializsed by a constant expression. 1986 using CheckedTemporaries = 1987 llvm::SmallPtrSet<const MaterializeTemporaryExpr *, 8>; 1988 1989 static bool CheckEvaluationResult(CheckEvaluationResultKind CERK, 1990 EvalInfo &Info, SourceLocation DiagLoc, 1991 QualType Type, const APValue &Value, 1992 Expr::ConstExprUsage Usage, 1993 SourceLocation SubobjectLoc, 1994 CheckedTemporaries &CheckedTemps); 1995 1996 /// Check that this reference or pointer core constant expression is a valid 1997 /// value for an address or reference constant expression. Return true if we 1998 /// can fold this expression, whether or not it's a constant expression. 1999 static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc, 2000 QualType Type, const LValue &LVal, 2001 Expr::ConstExprUsage Usage, 2002 CheckedTemporaries &CheckedTemps) { 2003 bool IsReferenceType = Type->isReferenceType(); 2004 2005 APValue::LValueBase Base = LVal.getLValueBase(); 2006 const SubobjectDesignator &Designator = LVal.getLValueDesignator(); 2007 2008 // Check that the object is a global. Note that the fake 'this' object we 2009 // manufacture when checking potential constant expressions is conservatively 2010 // assumed to be global here. 2011 if (!IsGlobalLValue(Base)) { 2012 if (Info.getLangOpts().CPlusPlus11) { 2013 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>(); 2014 Info.FFDiag(Loc, diag::note_constexpr_non_global, 1) 2015 << IsReferenceType << !Designator.Entries.empty() 2016 << !!VD << VD; 2017 NoteLValueLocation(Info, Base); 2018 } else { 2019 Info.FFDiag(Loc); 2020 } 2021 // Don't allow references to temporaries to escape. 2022 return false; 2023 } 2024 assert((Info.checkingPotentialConstantExpression() || 2025 LVal.getLValueCallIndex() == 0) && 2026 "have call index for global lvalue"); 2027 2028 if (Base.is<DynamicAllocLValue>()) { 2029 Info.FFDiag(Loc, diag::note_constexpr_dynamic_alloc) 2030 << IsReferenceType << !Designator.Entries.empty(); 2031 NoteLValueLocation(Info, Base); 2032 return false; 2033 } 2034 2035 if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) { 2036 if (const VarDecl *Var = dyn_cast<const VarDecl>(VD)) { 2037 // Check if this is a thread-local variable. 2038 if (Var->getTLSKind()) 2039 // FIXME: Diagnostic! 2040 return false; 2041 2042 // A dllimport variable never acts like a constant. 2043 if (Usage == Expr::EvaluateForCodeGen && Var->hasAttr<DLLImportAttr>()) 2044 // FIXME: Diagnostic! 2045 return false; 2046 } 2047 if (const auto *FD = dyn_cast<const FunctionDecl>(VD)) { 2048 // __declspec(dllimport) must be handled very carefully: 2049 // We must never initialize an expression with the thunk in C++. 2050 // Doing otherwise would allow the same id-expression to yield 2051 // different addresses for the same function in different translation 2052 // units. However, this means that we must dynamically initialize the 2053 // expression with the contents of the import address table at runtime. 2054 // 2055 // The C language has no notion of ODR; furthermore, it has no notion of 2056 // dynamic initialization. This means that we are permitted to 2057 // perform initialization with the address of the thunk. 2058 if (Info.getLangOpts().CPlusPlus && Usage == Expr::EvaluateForCodeGen && 2059 FD->hasAttr<DLLImportAttr>()) 2060 // FIXME: Diagnostic! 2061 return false; 2062 } 2063 } else if (const auto *MTE = dyn_cast_or_null<MaterializeTemporaryExpr>( 2064 Base.dyn_cast<const Expr *>())) { 2065 if (CheckedTemps.insert(MTE).second) { 2066 QualType TempType = getType(Base); 2067 if (TempType.isDestructedType()) { 2068 Info.FFDiag(MTE->getExprLoc(), 2069 diag::note_constexpr_unsupported_tempoarary_nontrivial_dtor) 2070 << TempType; 2071 return false; 2072 } 2073 2074 APValue *V = MTE->getOrCreateValue(false); 2075 assert(V && "evasluation result refers to uninitialised temporary"); 2076 if (!CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression, 2077 Info, MTE->getExprLoc(), TempType, *V, 2078 Usage, SourceLocation(), CheckedTemps)) 2079 return false; 2080 } 2081 } 2082 2083 // Allow address constant expressions to be past-the-end pointers. This is 2084 // an extension: the standard requires them to point to an object. 2085 if (!IsReferenceType) 2086 return true; 2087 2088 // A reference constant expression must refer to an object. 2089 if (!Base) { 2090 // FIXME: diagnostic 2091 Info.CCEDiag(Loc); 2092 return true; 2093 } 2094 2095 // Does this refer one past the end of some object? 2096 if (!Designator.Invalid && Designator.isOnePastTheEnd()) { 2097 const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>(); 2098 Info.FFDiag(Loc, diag::note_constexpr_past_end, 1) 2099 << !Designator.Entries.empty() << !!VD << VD; 2100 NoteLValueLocation(Info, Base); 2101 } 2102 2103 return true; 2104 } 2105 2106 /// Member pointers are constant expressions unless they point to a 2107 /// non-virtual dllimport member function. 2108 static bool CheckMemberPointerConstantExpression(EvalInfo &Info, 2109 SourceLocation Loc, 2110 QualType Type, 2111 const APValue &Value, 2112 Expr::ConstExprUsage Usage) { 2113 const ValueDecl *Member = Value.getMemberPointerDecl(); 2114 const auto *FD = dyn_cast_or_null<CXXMethodDecl>(Member); 2115 if (!FD) 2116 return true; 2117 return Usage == Expr::EvaluateForMangling || FD->isVirtual() || 2118 !FD->hasAttr<DLLImportAttr>(); 2119 } 2120 2121 /// Check that this core constant expression is of literal type, and if not, 2122 /// produce an appropriate diagnostic. 2123 static bool CheckLiteralType(EvalInfo &Info, const Expr *E, 2124 const LValue *This = nullptr) { 2125 if (!E->isRValue() || E->getType()->isLiteralType(Info.Ctx)) 2126 return true; 2127 2128 // C++1y: A constant initializer for an object o [...] may also invoke 2129 // constexpr constructors for o and its subobjects even if those objects 2130 // are of non-literal class types. 2131 // 2132 // C++11 missed this detail for aggregates, so classes like this: 2133 // struct foo_t { union { int i; volatile int j; } u; }; 2134 // are not (obviously) initializable like so: 2135 // __attribute__((__require_constant_initialization__)) 2136 // static const foo_t x = {{0}}; 2137 // because "i" is a subobject with non-literal initialization (due to the 2138 // volatile member of the union). See: 2139 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1677 2140 // Therefore, we use the C++1y behavior. 2141 if (This && Info.EvaluatingDecl == This->getLValueBase()) 2142 return true; 2143 2144 // Prvalue constant expressions must be of literal types. 2145 if (Info.getLangOpts().CPlusPlus11) 2146 Info.FFDiag(E, diag::note_constexpr_nonliteral) 2147 << E->getType(); 2148 else 2149 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 2150 return false; 2151 } 2152 2153 static bool CheckEvaluationResult(CheckEvaluationResultKind CERK, 2154 EvalInfo &Info, SourceLocation DiagLoc, 2155 QualType Type, const APValue &Value, 2156 Expr::ConstExprUsage Usage, 2157 SourceLocation SubobjectLoc, 2158 CheckedTemporaries &CheckedTemps) { 2159 if (!Value.hasValue()) { 2160 Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized) 2161 << true << Type; 2162 if (SubobjectLoc.isValid()) 2163 Info.Note(SubobjectLoc, diag::note_constexpr_subobject_declared_here); 2164 return false; 2165 } 2166 2167 // We allow _Atomic(T) to be initialized from anything that T can be 2168 // initialized from. 2169 if (const AtomicType *AT = Type->getAs<AtomicType>()) 2170 Type = AT->getValueType(); 2171 2172 // Core issue 1454: For a literal constant expression of array or class type, 2173 // each subobject of its value shall have been initialized by a constant 2174 // expression. 2175 if (Value.isArray()) { 2176 QualType EltTy = Type->castAsArrayTypeUnsafe()->getElementType(); 2177 for (unsigned I = 0, N = Value.getArrayInitializedElts(); I != N; ++I) { 2178 if (!CheckEvaluationResult(CERK, Info, DiagLoc, EltTy, 2179 Value.getArrayInitializedElt(I), Usage, 2180 SubobjectLoc, CheckedTemps)) 2181 return false; 2182 } 2183 if (!Value.hasArrayFiller()) 2184 return true; 2185 return CheckEvaluationResult(CERK, Info, DiagLoc, EltTy, 2186 Value.getArrayFiller(), Usage, SubobjectLoc, 2187 CheckedTemps); 2188 } 2189 if (Value.isUnion() && Value.getUnionField()) { 2190 return CheckEvaluationResult( 2191 CERK, Info, DiagLoc, Value.getUnionField()->getType(), 2192 Value.getUnionValue(), Usage, Value.getUnionField()->getLocation(), 2193 CheckedTemps); 2194 } 2195 if (Value.isStruct()) { 2196 RecordDecl *RD = Type->castAs<RecordType>()->getDecl(); 2197 if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) { 2198 unsigned BaseIndex = 0; 2199 for (const CXXBaseSpecifier &BS : CD->bases()) { 2200 if (!CheckEvaluationResult(CERK, Info, DiagLoc, BS.getType(), 2201 Value.getStructBase(BaseIndex), Usage, 2202 BS.getBeginLoc(), CheckedTemps)) 2203 return false; 2204 ++BaseIndex; 2205 } 2206 } 2207 for (const auto *I : RD->fields()) { 2208 if (I->isUnnamedBitfield()) 2209 continue; 2210 2211 if (!CheckEvaluationResult(CERK, Info, DiagLoc, I->getType(), 2212 Value.getStructField(I->getFieldIndex()), 2213 Usage, I->getLocation(), CheckedTemps)) 2214 return false; 2215 } 2216 } 2217 2218 if (Value.isLValue() && 2219 CERK == CheckEvaluationResultKind::ConstantExpression) { 2220 LValue LVal; 2221 LVal.setFrom(Info.Ctx, Value); 2222 return CheckLValueConstantExpression(Info, DiagLoc, Type, LVal, Usage, 2223 CheckedTemps); 2224 } 2225 2226 if (Value.isMemberPointer() && 2227 CERK == CheckEvaluationResultKind::ConstantExpression) 2228 return CheckMemberPointerConstantExpression(Info, DiagLoc, Type, Value, Usage); 2229 2230 // Everything else is fine. 2231 return true; 2232 } 2233 2234 /// Check that this core constant expression value is a valid value for a 2235 /// constant expression. If not, report an appropriate diagnostic. Does not 2236 /// check that the expression is of literal type. 2237 static bool 2238 CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc, QualType Type, 2239 const APValue &Value, 2240 Expr::ConstExprUsage Usage = Expr::EvaluateForCodeGen) { 2241 CheckedTemporaries CheckedTemps; 2242 return CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression, 2243 Info, DiagLoc, Type, Value, Usage, 2244 SourceLocation(), CheckedTemps); 2245 } 2246 2247 /// Check that this evaluated value is fully-initialized and can be loaded by 2248 /// an lvalue-to-rvalue conversion. 2249 static bool CheckFullyInitialized(EvalInfo &Info, SourceLocation DiagLoc, 2250 QualType Type, const APValue &Value) { 2251 CheckedTemporaries CheckedTemps; 2252 return CheckEvaluationResult( 2253 CheckEvaluationResultKind::FullyInitialized, Info, DiagLoc, Type, Value, 2254 Expr::EvaluateForCodeGen, SourceLocation(), CheckedTemps); 2255 } 2256 2257 /// Enforce C++2a [expr.const]/4.17, which disallows new-expressions unless 2258 /// "the allocated storage is deallocated within the evaluation". 2259 static bool CheckMemoryLeaks(EvalInfo &Info) { 2260 if (!Info.HeapAllocs.empty()) { 2261 // We can still fold to a constant despite a compile-time memory leak, 2262 // so long as the heap allocation isn't referenced in the result (we check 2263 // that in CheckConstantExpression). 2264 Info.CCEDiag(Info.HeapAllocs.begin()->second.AllocExpr, 2265 diag::note_constexpr_memory_leak) 2266 << unsigned(Info.HeapAllocs.size() - 1); 2267 } 2268 return true; 2269 } 2270 2271 static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) { 2272 // A null base expression indicates a null pointer. These are always 2273 // evaluatable, and they are false unless the offset is zero. 2274 if (!Value.getLValueBase()) { 2275 Result = !Value.getLValueOffset().isZero(); 2276 return true; 2277 } 2278 2279 // We have a non-null base. These are generally known to be true, but if it's 2280 // a weak declaration it can be null at runtime. 2281 Result = true; 2282 const ValueDecl *Decl = Value.getLValueBase().dyn_cast<const ValueDecl*>(); 2283 return !Decl || !Decl->isWeak(); 2284 } 2285 2286 static bool HandleConversionToBool(const APValue &Val, bool &Result) { 2287 switch (Val.getKind()) { 2288 case APValue::None: 2289 case APValue::Indeterminate: 2290 return false; 2291 case APValue::Int: 2292 Result = Val.getInt().getBoolValue(); 2293 return true; 2294 case APValue::FixedPoint: 2295 Result = Val.getFixedPoint().getBoolValue(); 2296 return true; 2297 case APValue::Float: 2298 Result = !Val.getFloat().isZero(); 2299 return true; 2300 case APValue::ComplexInt: 2301 Result = Val.getComplexIntReal().getBoolValue() || 2302 Val.getComplexIntImag().getBoolValue(); 2303 return true; 2304 case APValue::ComplexFloat: 2305 Result = !Val.getComplexFloatReal().isZero() || 2306 !Val.getComplexFloatImag().isZero(); 2307 return true; 2308 case APValue::LValue: 2309 return EvalPointerValueAsBool(Val, Result); 2310 case APValue::MemberPointer: 2311 Result = Val.getMemberPointerDecl(); 2312 return true; 2313 case APValue::Vector: 2314 case APValue::Array: 2315 case APValue::Struct: 2316 case APValue::Union: 2317 case APValue::AddrLabelDiff: 2318 return false; 2319 } 2320 2321 llvm_unreachable("unknown APValue kind"); 2322 } 2323 2324 static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result, 2325 EvalInfo &Info) { 2326 assert(E->isRValue() && "missing lvalue-to-rvalue conv in bool condition"); 2327 APValue Val; 2328 if (!Evaluate(Val, Info, E)) 2329 return false; 2330 return HandleConversionToBool(Val, Result); 2331 } 2332 2333 template<typename T> 2334 static bool HandleOverflow(EvalInfo &Info, const Expr *E, 2335 const T &SrcValue, QualType DestType) { 2336 Info.CCEDiag(E, diag::note_constexpr_overflow) 2337 << SrcValue << DestType; 2338 return Info.noteUndefinedBehavior(); 2339 } 2340 2341 static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E, 2342 QualType SrcType, const APFloat &Value, 2343 QualType DestType, APSInt &Result) { 2344 unsigned DestWidth = Info.Ctx.getIntWidth(DestType); 2345 // Determine whether we are converting to unsigned or signed. 2346 bool DestSigned = DestType->isSignedIntegerOrEnumerationType(); 2347 2348 Result = APSInt(DestWidth, !DestSigned); 2349 bool ignored; 2350 if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored) 2351 & APFloat::opInvalidOp) 2352 return HandleOverflow(Info, E, Value, DestType); 2353 return true; 2354 } 2355 2356 static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E, 2357 QualType SrcType, QualType DestType, 2358 APFloat &Result) { 2359 APFloat Value = Result; 2360 bool ignored; 2361 Result.convert(Info.Ctx.getFloatTypeSemantics(DestType), 2362 APFloat::rmNearestTiesToEven, &ignored); 2363 return true; 2364 } 2365 2366 static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E, 2367 QualType DestType, QualType SrcType, 2368 const APSInt &Value) { 2369 unsigned DestWidth = Info.Ctx.getIntWidth(DestType); 2370 // Figure out if this is a truncate, extend or noop cast. 2371 // If the input is signed, do a sign extend, noop, or truncate. 2372 APSInt Result = Value.extOrTrunc(DestWidth); 2373 Result.setIsUnsigned(DestType->isUnsignedIntegerOrEnumerationType()); 2374 if (DestType->isBooleanType()) 2375 Result = Value.getBoolValue(); 2376 return Result; 2377 } 2378 2379 static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E, 2380 QualType SrcType, const APSInt &Value, 2381 QualType DestType, APFloat &Result) { 2382 Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1); 2383 Result.convertFromAPInt(Value, Value.isSigned(), 2384 APFloat::rmNearestTiesToEven); 2385 return true; 2386 } 2387 2388 static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E, 2389 APValue &Value, const FieldDecl *FD) { 2390 assert(FD->isBitField() && "truncateBitfieldValue on non-bitfield"); 2391 2392 if (!Value.isInt()) { 2393 // Trying to store a pointer-cast-to-integer into a bitfield. 2394 // FIXME: In this case, we should provide the diagnostic for casting 2395 // a pointer to an integer. 2396 assert(Value.isLValue() && "integral value neither int nor lvalue?"); 2397 Info.FFDiag(E); 2398 return false; 2399 } 2400 2401 APSInt &Int = Value.getInt(); 2402 unsigned OldBitWidth = Int.getBitWidth(); 2403 unsigned NewBitWidth = FD->getBitWidthValue(Info.Ctx); 2404 if (NewBitWidth < OldBitWidth) 2405 Int = Int.trunc(NewBitWidth).extend(OldBitWidth); 2406 return true; 2407 } 2408 2409 static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E, 2410 llvm::APInt &Res) { 2411 APValue SVal; 2412 if (!Evaluate(SVal, Info, E)) 2413 return false; 2414 if (SVal.isInt()) { 2415 Res = SVal.getInt(); 2416 return true; 2417 } 2418 if (SVal.isFloat()) { 2419 Res = SVal.getFloat().bitcastToAPInt(); 2420 return true; 2421 } 2422 if (SVal.isVector()) { 2423 QualType VecTy = E->getType(); 2424 unsigned VecSize = Info.Ctx.getTypeSize(VecTy); 2425 QualType EltTy = VecTy->castAs<VectorType>()->getElementType(); 2426 unsigned EltSize = Info.Ctx.getTypeSize(EltTy); 2427 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian(); 2428 Res = llvm::APInt::getNullValue(VecSize); 2429 for (unsigned i = 0; i < SVal.getVectorLength(); i++) { 2430 APValue &Elt = SVal.getVectorElt(i); 2431 llvm::APInt EltAsInt; 2432 if (Elt.isInt()) { 2433 EltAsInt = Elt.getInt(); 2434 } else if (Elt.isFloat()) { 2435 EltAsInt = Elt.getFloat().bitcastToAPInt(); 2436 } else { 2437 // Don't try to handle vectors of anything other than int or float 2438 // (not sure if it's possible to hit this case). 2439 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 2440 return false; 2441 } 2442 unsigned BaseEltSize = EltAsInt.getBitWidth(); 2443 if (BigEndian) 2444 Res |= EltAsInt.zextOrTrunc(VecSize).rotr(i*EltSize+BaseEltSize); 2445 else 2446 Res |= EltAsInt.zextOrTrunc(VecSize).rotl(i*EltSize); 2447 } 2448 return true; 2449 } 2450 // Give up if the input isn't an int, float, or vector. For example, we 2451 // reject "(v4i16)(intptr_t)&a". 2452 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 2453 return false; 2454 } 2455 2456 /// Perform the given integer operation, which is known to need at most BitWidth 2457 /// bits, and check for overflow in the original type (if that type was not an 2458 /// unsigned type). 2459 template<typename Operation> 2460 static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E, 2461 const APSInt &LHS, const APSInt &RHS, 2462 unsigned BitWidth, Operation Op, 2463 APSInt &Result) { 2464 if (LHS.isUnsigned()) { 2465 Result = Op(LHS, RHS); 2466 return true; 2467 } 2468 2469 APSInt Value(Op(LHS.extend(BitWidth), RHS.extend(BitWidth)), false); 2470 Result = Value.trunc(LHS.getBitWidth()); 2471 if (Result.extend(BitWidth) != Value) { 2472 if (Info.checkingForUndefinedBehavior()) 2473 Info.Ctx.getDiagnostics().Report(E->getExprLoc(), 2474 diag::warn_integer_constant_overflow) 2475 << Result.toString(10) << E->getType(); 2476 else 2477 return HandleOverflow(Info, E, Value, E->getType()); 2478 } 2479 return true; 2480 } 2481 2482 /// Perform the given binary integer operation. 2483 static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS, 2484 BinaryOperatorKind Opcode, APSInt RHS, 2485 APSInt &Result) { 2486 switch (Opcode) { 2487 default: 2488 Info.FFDiag(E); 2489 return false; 2490 case BO_Mul: 2491 return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() * 2, 2492 std::multiplies<APSInt>(), Result); 2493 case BO_Add: 2494 return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1, 2495 std::plus<APSInt>(), Result); 2496 case BO_Sub: 2497 return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1, 2498 std::minus<APSInt>(), Result); 2499 case BO_And: Result = LHS & RHS; return true; 2500 case BO_Xor: Result = LHS ^ RHS; return true; 2501 case BO_Or: Result = LHS | RHS; return true; 2502 case BO_Div: 2503 case BO_Rem: 2504 if (RHS == 0) { 2505 Info.FFDiag(E, diag::note_expr_divide_by_zero); 2506 return false; 2507 } 2508 Result = (Opcode == BO_Rem ? LHS % RHS : LHS / RHS); 2509 // Check for overflow case: INT_MIN / -1 or INT_MIN % -1. APSInt supports 2510 // this operation and gives the two's complement result. 2511 if (RHS.isNegative() && RHS.isAllOnesValue() && 2512 LHS.isSigned() && LHS.isMinSignedValue()) 2513 return HandleOverflow(Info, E, -LHS.extend(LHS.getBitWidth() + 1), 2514 E->getType()); 2515 return true; 2516 case BO_Shl: { 2517 if (Info.getLangOpts().OpenCL) 2518 // OpenCL 6.3j: shift values are effectively % word size of LHS. 2519 RHS &= APSInt(llvm::APInt(RHS.getBitWidth(), 2520 static_cast<uint64_t>(LHS.getBitWidth() - 1)), 2521 RHS.isUnsigned()); 2522 else if (RHS.isSigned() && RHS.isNegative()) { 2523 // During constant-folding, a negative shift is an opposite shift. Such 2524 // a shift is not a constant expression. 2525 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS; 2526 RHS = -RHS; 2527 goto shift_right; 2528 } 2529 shift_left: 2530 // C++11 [expr.shift]p1: Shift width must be less than the bit width of 2531 // the shifted type. 2532 unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1); 2533 if (SA != RHS) { 2534 Info.CCEDiag(E, diag::note_constexpr_large_shift) 2535 << RHS << E->getType() << LHS.getBitWidth(); 2536 } else if (LHS.isSigned() && !Info.getLangOpts().CPlusPlus2a) { 2537 // C++11 [expr.shift]p2: A signed left shift must have a non-negative 2538 // operand, and must not overflow the corresponding unsigned type. 2539 // C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to 2540 // E1 x 2^E2 module 2^N. 2541 if (LHS.isNegative()) 2542 Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS; 2543 else if (LHS.countLeadingZeros() < SA) 2544 Info.CCEDiag(E, diag::note_constexpr_lshift_discards); 2545 } 2546 Result = LHS << SA; 2547 return true; 2548 } 2549 case BO_Shr: { 2550 if (Info.getLangOpts().OpenCL) 2551 // OpenCL 6.3j: shift values are effectively % word size of LHS. 2552 RHS &= APSInt(llvm::APInt(RHS.getBitWidth(), 2553 static_cast<uint64_t>(LHS.getBitWidth() - 1)), 2554 RHS.isUnsigned()); 2555 else if (RHS.isSigned() && RHS.isNegative()) { 2556 // During constant-folding, a negative shift is an opposite shift. Such a 2557 // shift is not a constant expression. 2558 Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS; 2559 RHS = -RHS; 2560 goto shift_left; 2561 } 2562 shift_right: 2563 // C++11 [expr.shift]p1: Shift width must be less than the bit width of the 2564 // shifted type. 2565 unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1); 2566 if (SA != RHS) 2567 Info.CCEDiag(E, diag::note_constexpr_large_shift) 2568 << RHS << E->getType() << LHS.getBitWidth(); 2569 Result = LHS >> SA; 2570 return true; 2571 } 2572 2573 case BO_LT: Result = LHS < RHS; return true; 2574 case BO_GT: Result = LHS > RHS; return true; 2575 case BO_LE: Result = LHS <= RHS; return true; 2576 case BO_GE: Result = LHS >= RHS; return true; 2577 case BO_EQ: Result = LHS == RHS; return true; 2578 case BO_NE: Result = LHS != RHS; return true; 2579 case BO_Cmp: 2580 llvm_unreachable("BO_Cmp should be handled elsewhere"); 2581 } 2582 } 2583 2584 /// Perform the given binary floating-point operation, in-place, on LHS. 2585 static bool handleFloatFloatBinOp(EvalInfo &Info, const Expr *E, 2586 APFloat &LHS, BinaryOperatorKind Opcode, 2587 const APFloat &RHS) { 2588 switch (Opcode) { 2589 default: 2590 Info.FFDiag(E); 2591 return false; 2592 case BO_Mul: 2593 LHS.multiply(RHS, APFloat::rmNearestTiesToEven); 2594 break; 2595 case BO_Add: 2596 LHS.add(RHS, APFloat::rmNearestTiesToEven); 2597 break; 2598 case BO_Sub: 2599 LHS.subtract(RHS, APFloat::rmNearestTiesToEven); 2600 break; 2601 case BO_Div: 2602 // [expr.mul]p4: 2603 // If the second operand of / or % is zero the behavior is undefined. 2604 if (RHS.isZero()) 2605 Info.CCEDiag(E, diag::note_expr_divide_by_zero); 2606 LHS.divide(RHS, APFloat::rmNearestTiesToEven); 2607 break; 2608 } 2609 2610 // [expr.pre]p4: 2611 // If during the evaluation of an expression, the result is not 2612 // mathematically defined [...], the behavior is undefined. 2613 // FIXME: C++ rules require us to not conform to IEEE 754 here. 2614 if (LHS.isNaN()) { 2615 Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN(); 2616 return Info.noteUndefinedBehavior(); 2617 } 2618 return true; 2619 } 2620 2621 /// Cast an lvalue referring to a base subobject to a derived class, by 2622 /// truncating the lvalue's path to the given length. 2623 static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result, 2624 const RecordDecl *TruncatedType, 2625 unsigned TruncatedElements) { 2626 SubobjectDesignator &D = Result.Designator; 2627 2628 // Check we actually point to a derived class object. 2629 if (TruncatedElements == D.Entries.size()) 2630 return true; 2631 assert(TruncatedElements >= D.MostDerivedPathLength && 2632 "not casting to a derived class"); 2633 if (!Result.checkSubobject(Info, E, CSK_Derived)) 2634 return false; 2635 2636 // Truncate the path to the subobject, and remove any derived-to-base offsets. 2637 const RecordDecl *RD = TruncatedType; 2638 for (unsigned I = TruncatedElements, N = D.Entries.size(); I != N; ++I) { 2639 if (RD->isInvalidDecl()) return false; 2640 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 2641 const CXXRecordDecl *Base = getAsBaseClass(D.Entries[I]); 2642 if (isVirtualBaseClass(D.Entries[I])) 2643 Result.Offset -= Layout.getVBaseClassOffset(Base); 2644 else 2645 Result.Offset -= Layout.getBaseClassOffset(Base); 2646 RD = Base; 2647 } 2648 D.Entries.resize(TruncatedElements); 2649 return true; 2650 } 2651 2652 static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj, 2653 const CXXRecordDecl *Derived, 2654 const CXXRecordDecl *Base, 2655 const ASTRecordLayout *RL = nullptr) { 2656 if (!RL) { 2657 if (Derived->isInvalidDecl()) return false; 2658 RL = &Info.Ctx.getASTRecordLayout(Derived); 2659 } 2660 2661 Obj.getLValueOffset() += RL->getBaseClassOffset(Base); 2662 Obj.addDecl(Info, E, Base, /*Virtual*/ false); 2663 return true; 2664 } 2665 2666 static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj, 2667 const CXXRecordDecl *DerivedDecl, 2668 const CXXBaseSpecifier *Base) { 2669 const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl(); 2670 2671 if (!Base->isVirtual()) 2672 return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl); 2673 2674 SubobjectDesignator &D = Obj.Designator; 2675 if (D.Invalid) 2676 return false; 2677 2678 // Extract most-derived object and corresponding type. 2679 DerivedDecl = D.MostDerivedType->getAsCXXRecordDecl(); 2680 if (!CastToDerivedClass(Info, E, Obj, DerivedDecl, D.MostDerivedPathLength)) 2681 return false; 2682 2683 // Find the virtual base class. 2684 if (DerivedDecl->isInvalidDecl()) return false; 2685 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl); 2686 Obj.getLValueOffset() += Layout.getVBaseClassOffset(BaseDecl); 2687 Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true); 2688 return true; 2689 } 2690 2691 static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E, 2692 QualType Type, LValue &Result) { 2693 for (CastExpr::path_const_iterator PathI = E->path_begin(), 2694 PathE = E->path_end(); 2695 PathI != PathE; ++PathI) { 2696 if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(), 2697 *PathI)) 2698 return false; 2699 Type = (*PathI)->getType(); 2700 } 2701 return true; 2702 } 2703 2704 /// Cast an lvalue referring to a derived class to a known base subobject. 2705 static bool CastToBaseClass(EvalInfo &Info, const Expr *E, LValue &Result, 2706 const CXXRecordDecl *DerivedRD, 2707 const CXXRecordDecl *BaseRD) { 2708 CXXBasePaths Paths(/*FindAmbiguities=*/false, 2709 /*RecordPaths=*/true, /*DetectVirtual=*/false); 2710 if (!DerivedRD->isDerivedFrom(BaseRD, Paths)) 2711 llvm_unreachable("Class must be derived from the passed in base class!"); 2712 2713 for (CXXBasePathElement &Elem : Paths.front()) 2714 if (!HandleLValueBase(Info, E, Result, Elem.Class, Elem.Base)) 2715 return false; 2716 return true; 2717 } 2718 2719 /// Update LVal to refer to the given field, which must be a member of the type 2720 /// currently described by LVal. 2721 static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal, 2722 const FieldDecl *FD, 2723 const ASTRecordLayout *RL = nullptr) { 2724 if (!RL) { 2725 if (FD->getParent()->isInvalidDecl()) return false; 2726 RL = &Info.Ctx.getASTRecordLayout(FD->getParent()); 2727 } 2728 2729 unsigned I = FD->getFieldIndex(); 2730 LVal.adjustOffset(Info.Ctx.toCharUnitsFromBits(RL->getFieldOffset(I))); 2731 LVal.addDecl(Info, E, FD); 2732 return true; 2733 } 2734 2735 /// Update LVal to refer to the given indirect field. 2736 static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E, 2737 LValue &LVal, 2738 const IndirectFieldDecl *IFD) { 2739 for (const auto *C : IFD->chain()) 2740 if (!HandleLValueMember(Info, E, LVal, cast<FieldDecl>(C))) 2741 return false; 2742 return true; 2743 } 2744 2745 /// Get the size of the given type in char units. 2746 static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc, 2747 QualType Type, CharUnits &Size) { 2748 // sizeof(void), __alignof__(void), sizeof(function) = 1 as a gcc 2749 // extension. 2750 if (Type->isVoidType() || Type->isFunctionType()) { 2751 Size = CharUnits::One(); 2752 return true; 2753 } 2754 2755 if (Type->isDependentType()) { 2756 Info.FFDiag(Loc); 2757 return false; 2758 } 2759 2760 if (!Type->isConstantSizeType()) { 2761 // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2. 2762 // FIXME: Better diagnostic. 2763 Info.FFDiag(Loc); 2764 return false; 2765 } 2766 2767 Size = Info.Ctx.getTypeSizeInChars(Type); 2768 return true; 2769 } 2770 2771 /// Update a pointer value to model pointer arithmetic. 2772 /// \param Info - Information about the ongoing evaluation. 2773 /// \param E - The expression being evaluated, for diagnostic purposes. 2774 /// \param LVal - The pointer value to be updated. 2775 /// \param EltTy - The pointee type represented by LVal. 2776 /// \param Adjustment - The adjustment, in objects of type EltTy, to add. 2777 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E, 2778 LValue &LVal, QualType EltTy, 2779 APSInt Adjustment) { 2780 CharUnits SizeOfPointee; 2781 if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfPointee)) 2782 return false; 2783 2784 LVal.adjustOffsetAndIndex(Info, E, Adjustment, SizeOfPointee); 2785 return true; 2786 } 2787 2788 static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E, 2789 LValue &LVal, QualType EltTy, 2790 int64_t Adjustment) { 2791 return HandleLValueArrayAdjustment(Info, E, LVal, EltTy, 2792 APSInt::get(Adjustment)); 2793 } 2794 2795 /// Update an lvalue to refer to a component of a complex number. 2796 /// \param Info - Information about the ongoing evaluation. 2797 /// \param LVal - The lvalue to be updated. 2798 /// \param EltTy - The complex number's component type. 2799 /// \param Imag - False for the real component, true for the imaginary. 2800 static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E, 2801 LValue &LVal, QualType EltTy, 2802 bool Imag) { 2803 if (Imag) { 2804 CharUnits SizeOfComponent; 2805 if (!HandleSizeof(Info, E->getExprLoc(), EltTy, SizeOfComponent)) 2806 return false; 2807 LVal.Offset += SizeOfComponent; 2808 } 2809 LVal.addComplex(Info, E, EltTy, Imag); 2810 return true; 2811 } 2812 2813 /// Try to evaluate the initializer for a variable declaration. 2814 /// 2815 /// \param Info Information about the ongoing evaluation. 2816 /// \param E An expression to be used when printing diagnostics. 2817 /// \param VD The variable whose initializer should be obtained. 2818 /// \param Frame The frame in which the variable was created. Must be null 2819 /// if this variable is not local to the evaluation. 2820 /// \param Result Filled in with a pointer to the value of the variable. 2821 static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, 2822 const VarDecl *VD, CallStackFrame *Frame, 2823 APValue *&Result, const LValue *LVal) { 2824 2825 // If this is a parameter to an active constexpr function call, perform 2826 // argument substitution. 2827 if (const ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(VD)) { 2828 // Assume arguments of a potential constant expression are unknown 2829 // constant expressions. 2830 if (Info.checkingPotentialConstantExpression()) 2831 return false; 2832 if (!Frame || !Frame->Arguments) { 2833 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 2834 return false; 2835 } 2836 Result = &Frame->Arguments[PVD->getFunctionScopeIndex()]; 2837 return true; 2838 } 2839 2840 // If this is a local variable, dig out its value. 2841 if (Frame) { 2842 Result = LVal ? Frame->getTemporary(VD, LVal->getLValueVersion()) 2843 : Frame->getCurrentTemporary(VD); 2844 if (!Result) { 2845 // Assume variables referenced within a lambda's call operator that were 2846 // not declared within the call operator are captures and during checking 2847 // of a potential constant expression, assume they are unknown constant 2848 // expressions. 2849 assert(isLambdaCallOperator(Frame->Callee) && 2850 (VD->getDeclContext() != Frame->Callee || VD->isInitCapture()) && 2851 "missing value for local variable"); 2852 if (Info.checkingPotentialConstantExpression()) 2853 return false; 2854 // FIXME: implement capture evaluation during constant expr evaluation. 2855 Info.FFDiag(E->getBeginLoc(), 2856 diag::note_unimplemented_constexpr_lambda_feature_ast) 2857 << "captures not currently allowed"; 2858 return false; 2859 } 2860 return true; 2861 } 2862 2863 // Dig out the initializer, and use the declaration which it's attached to. 2864 const Expr *Init = VD->getAnyInitializer(VD); 2865 if (!Init || Init->isValueDependent()) { 2866 // If we're checking a potential constant expression, the variable could be 2867 // initialized later. 2868 if (!Info.checkingPotentialConstantExpression()) 2869 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 2870 return false; 2871 } 2872 2873 // If we're currently evaluating the initializer of this declaration, use that 2874 // in-flight value. 2875 if (Info.EvaluatingDecl.dyn_cast<const ValueDecl*>() == VD) { 2876 Result = Info.EvaluatingDeclValue; 2877 return true; 2878 } 2879 2880 // Never evaluate the initializer of a weak variable. We can't be sure that 2881 // this is the definition which will be used. 2882 if (VD->isWeak()) { 2883 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 2884 return false; 2885 } 2886 2887 // Check that we can fold the initializer. In C++, we will have already done 2888 // this in the cases where it matters for conformance. 2889 SmallVector<PartialDiagnosticAt, 8> Notes; 2890 if (!VD->evaluateValue(Notes)) { 2891 Info.FFDiag(E, diag::note_constexpr_var_init_non_constant, 2892 Notes.size() + 1) << VD; 2893 Info.Note(VD->getLocation(), diag::note_declared_at); 2894 Info.addNotes(Notes); 2895 return false; 2896 } else if (!VD->checkInitIsICE()) { 2897 Info.CCEDiag(E, diag::note_constexpr_var_init_non_constant, 2898 Notes.size() + 1) << VD; 2899 Info.Note(VD->getLocation(), diag::note_declared_at); 2900 Info.addNotes(Notes); 2901 } 2902 2903 Result = VD->getEvaluatedValue(); 2904 return true; 2905 } 2906 2907 static bool IsConstNonVolatile(QualType T) { 2908 Qualifiers Quals = T.getQualifiers(); 2909 return Quals.hasConst() && !Quals.hasVolatile(); 2910 } 2911 2912 /// Get the base index of the given base class within an APValue representing 2913 /// the given derived class. 2914 static unsigned getBaseIndex(const CXXRecordDecl *Derived, 2915 const CXXRecordDecl *Base) { 2916 Base = Base->getCanonicalDecl(); 2917 unsigned Index = 0; 2918 for (CXXRecordDecl::base_class_const_iterator I = Derived->bases_begin(), 2919 E = Derived->bases_end(); I != E; ++I, ++Index) { 2920 if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == Base) 2921 return Index; 2922 } 2923 2924 llvm_unreachable("base class missing from derived class's bases list"); 2925 } 2926 2927 /// Extract the value of a character from a string literal. 2928 static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit, 2929 uint64_t Index) { 2930 assert(!isa<SourceLocExpr>(Lit) && 2931 "SourceLocExpr should have already been converted to a StringLiteral"); 2932 2933 // FIXME: Support MakeStringConstant 2934 if (const auto *ObjCEnc = dyn_cast<ObjCEncodeExpr>(Lit)) { 2935 std::string Str; 2936 Info.Ctx.getObjCEncodingForType(ObjCEnc->getEncodedType(), Str); 2937 assert(Index <= Str.size() && "Index too large"); 2938 return APSInt::getUnsigned(Str.c_str()[Index]); 2939 } 2940 2941 if (auto PE = dyn_cast<PredefinedExpr>(Lit)) 2942 Lit = PE->getFunctionName(); 2943 const StringLiteral *S = cast<StringLiteral>(Lit); 2944 const ConstantArrayType *CAT = 2945 Info.Ctx.getAsConstantArrayType(S->getType()); 2946 assert(CAT && "string literal isn't an array"); 2947 QualType CharType = CAT->getElementType(); 2948 assert(CharType->isIntegerType() && "unexpected character type"); 2949 2950 APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(), 2951 CharType->isUnsignedIntegerType()); 2952 if (Index < S->getLength()) 2953 Value = S->getCodeUnit(Index); 2954 return Value; 2955 } 2956 2957 // Expand a string literal into an array of characters. 2958 // 2959 // FIXME: This is inefficient; we should probably introduce something similar 2960 // to the LLVM ConstantDataArray to make this cheaper. 2961 static void expandStringLiteral(EvalInfo &Info, const StringLiteral *S, 2962 APValue &Result, 2963 QualType AllocType = QualType()) { 2964 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType( 2965 AllocType.isNull() ? S->getType() : AllocType); 2966 assert(CAT && "string literal isn't an array"); 2967 QualType CharType = CAT->getElementType(); 2968 assert(CharType->isIntegerType() && "unexpected character type"); 2969 2970 unsigned Elts = CAT->getSize().getZExtValue(); 2971 Result = APValue(APValue::UninitArray(), 2972 std::min(S->getLength(), Elts), Elts); 2973 APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(), 2974 CharType->isUnsignedIntegerType()); 2975 if (Result.hasArrayFiller()) 2976 Result.getArrayFiller() = APValue(Value); 2977 for (unsigned I = 0, N = Result.getArrayInitializedElts(); I != N; ++I) { 2978 Value = S->getCodeUnit(I); 2979 Result.getArrayInitializedElt(I) = APValue(Value); 2980 } 2981 } 2982 2983 // Expand an array so that it has more than Index filled elements. 2984 static void expandArray(APValue &Array, unsigned Index) { 2985 unsigned Size = Array.getArraySize(); 2986 assert(Index < Size); 2987 2988 // Always at least double the number of elements for which we store a value. 2989 unsigned OldElts = Array.getArrayInitializedElts(); 2990 unsigned NewElts = std::max(Index+1, OldElts * 2); 2991 NewElts = std::min(Size, std::max(NewElts, 8u)); 2992 2993 // Copy the data across. 2994 APValue NewValue(APValue::UninitArray(), NewElts, Size); 2995 for (unsigned I = 0; I != OldElts; ++I) 2996 NewValue.getArrayInitializedElt(I).swap(Array.getArrayInitializedElt(I)); 2997 for (unsigned I = OldElts; I != NewElts; ++I) 2998 NewValue.getArrayInitializedElt(I) = Array.getArrayFiller(); 2999 if (NewValue.hasArrayFiller()) 3000 NewValue.getArrayFiller() = Array.getArrayFiller(); 3001 Array.swap(NewValue); 3002 } 3003 3004 /// Determine whether a type would actually be read by an lvalue-to-rvalue 3005 /// conversion. If it's of class type, we may assume that the copy operation 3006 /// is trivial. Note that this is never true for a union type with fields 3007 /// (because the copy always "reads" the active member) and always true for 3008 /// a non-class type. 3009 static bool isReadByLvalueToRvalueConversion(QualType T) { 3010 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 3011 if (!RD || (RD->isUnion() && !RD->field_empty())) 3012 return true; 3013 if (RD->isEmpty()) 3014 return false; 3015 3016 for (auto *Field : RD->fields()) 3017 if (isReadByLvalueToRvalueConversion(Field->getType())) 3018 return true; 3019 3020 for (auto &BaseSpec : RD->bases()) 3021 if (isReadByLvalueToRvalueConversion(BaseSpec.getType())) 3022 return true; 3023 3024 return false; 3025 } 3026 3027 /// Diagnose an attempt to read from any unreadable field within the specified 3028 /// type, which might be a class type. 3029 static bool diagnoseMutableFields(EvalInfo &Info, const Expr *E, AccessKinds AK, 3030 QualType T) { 3031 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 3032 if (!RD) 3033 return false; 3034 3035 if (!RD->hasMutableFields()) 3036 return false; 3037 3038 for (auto *Field : RD->fields()) { 3039 // If we're actually going to read this field in some way, then it can't 3040 // be mutable. If we're in a union, then assigning to a mutable field 3041 // (even an empty one) can change the active member, so that's not OK. 3042 // FIXME: Add core issue number for the union case. 3043 if (Field->isMutable() && 3044 (RD->isUnion() || isReadByLvalueToRvalueConversion(Field->getType()))) { 3045 Info.FFDiag(E, diag::note_constexpr_access_mutable, 1) << AK << Field; 3046 Info.Note(Field->getLocation(), diag::note_declared_at); 3047 return true; 3048 } 3049 3050 if (diagnoseMutableFields(Info, E, AK, Field->getType())) 3051 return true; 3052 } 3053 3054 for (auto &BaseSpec : RD->bases()) 3055 if (diagnoseMutableFields(Info, E, AK, BaseSpec.getType())) 3056 return true; 3057 3058 // All mutable fields were empty, and thus not actually read. 3059 return false; 3060 } 3061 3062 static bool lifetimeStartedInEvaluation(EvalInfo &Info, 3063 APValue::LValueBase Base, 3064 bool MutableSubobject = false) { 3065 // A temporary we created. 3066 if (Base.getCallIndex()) 3067 return true; 3068 3069 auto *Evaluating = Info.EvaluatingDecl.dyn_cast<const ValueDecl*>(); 3070 if (!Evaluating) 3071 return false; 3072 3073 auto *BaseD = Base.dyn_cast<const ValueDecl*>(); 3074 3075 switch (Info.IsEvaluatingDecl) { 3076 case EvalInfo::EvaluatingDeclKind::None: 3077 return false; 3078 3079 case EvalInfo::EvaluatingDeclKind::Ctor: 3080 // The variable whose initializer we're evaluating. 3081 if (BaseD) 3082 return declaresSameEntity(Evaluating, BaseD); 3083 3084 // A temporary lifetime-extended by the variable whose initializer we're 3085 // evaluating. 3086 if (auto *BaseE = Base.dyn_cast<const Expr *>()) 3087 if (auto *BaseMTE = dyn_cast<MaterializeTemporaryExpr>(BaseE)) 3088 return declaresSameEntity(BaseMTE->getExtendingDecl(), Evaluating); 3089 return false; 3090 3091 case EvalInfo::EvaluatingDeclKind::Dtor: 3092 // C++2a [expr.const]p6: 3093 // [during constant destruction] the lifetime of a and its non-mutable 3094 // subobjects (but not its mutable subobjects) [are] considered to start 3095 // within e. 3096 // 3097 // FIXME: We can meaningfully extend this to cover non-const objects, but 3098 // we will need special handling: we should be able to access only 3099 // subobjects of such objects that are themselves declared const. 3100 if (!BaseD || 3101 !(BaseD->getType().isConstQualified() || 3102 BaseD->getType()->isReferenceType()) || 3103 MutableSubobject) 3104 return false; 3105 return declaresSameEntity(Evaluating, BaseD); 3106 } 3107 3108 llvm_unreachable("unknown evaluating decl kind"); 3109 } 3110 3111 namespace { 3112 /// A handle to a complete object (an object that is not a subobject of 3113 /// another object). 3114 struct CompleteObject { 3115 /// The identity of the object. 3116 APValue::LValueBase Base; 3117 /// The value of the complete object. 3118 APValue *Value; 3119 /// The type of the complete object. 3120 QualType Type; 3121 3122 CompleteObject() : Value(nullptr) {} 3123 CompleteObject(APValue::LValueBase Base, APValue *Value, QualType Type) 3124 : Base(Base), Value(Value), Type(Type) {} 3125 3126 bool mayAccessMutableMembers(EvalInfo &Info, AccessKinds AK) const { 3127 // In C++14 onwards, it is permitted to read a mutable member whose 3128 // lifetime began within the evaluation. 3129 // FIXME: Should we also allow this in C++11? 3130 if (!Info.getLangOpts().CPlusPlus14) 3131 return false; 3132 return lifetimeStartedInEvaluation(Info, Base, /*MutableSubobject*/true); 3133 } 3134 3135 explicit operator bool() const { return !Type.isNull(); } 3136 }; 3137 } // end anonymous namespace 3138 3139 static QualType getSubobjectType(QualType ObjType, QualType SubobjType, 3140 bool IsMutable = false) { 3141 // C++ [basic.type.qualifier]p1: 3142 // - A const object is an object of type const T or a non-mutable subobject 3143 // of a const object. 3144 if (ObjType.isConstQualified() && !IsMutable) 3145 SubobjType.addConst(); 3146 // - A volatile object is an object of type const T or a subobject of a 3147 // volatile object. 3148 if (ObjType.isVolatileQualified()) 3149 SubobjType.addVolatile(); 3150 return SubobjType; 3151 } 3152 3153 /// Find the designated sub-object of an rvalue. 3154 template<typename SubobjectHandler> 3155 typename SubobjectHandler::result_type 3156 findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, 3157 const SubobjectDesignator &Sub, SubobjectHandler &handler) { 3158 if (Sub.Invalid) 3159 // A diagnostic will have already been produced. 3160 return handler.failed(); 3161 if (Sub.isOnePastTheEnd() || Sub.isMostDerivedAnUnsizedArray()) { 3162 if (Info.getLangOpts().CPlusPlus11) 3163 Info.FFDiag(E, Sub.isOnePastTheEnd() 3164 ? diag::note_constexpr_access_past_end 3165 : diag::note_constexpr_access_unsized_array) 3166 << handler.AccessKind; 3167 else 3168 Info.FFDiag(E); 3169 return handler.failed(); 3170 } 3171 3172 APValue *O = Obj.Value; 3173 QualType ObjType = Obj.Type; 3174 const FieldDecl *LastField = nullptr; 3175 const FieldDecl *VolatileField = nullptr; 3176 3177 // Walk the designator's path to find the subobject. 3178 for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) { 3179 // Reading an indeterminate value is undefined, but assigning over one is OK. 3180 if ((O->isAbsent() && !(handler.AccessKind == AK_Construct && I == N)) || 3181 (O->isIndeterminate() && handler.AccessKind != AK_Construct && 3182 handler.AccessKind != AK_Assign && 3183 handler.AccessKind != AK_ReadObjectRepresentation)) { 3184 if (!Info.checkingPotentialConstantExpression()) 3185 Info.FFDiag(E, diag::note_constexpr_access_uninit) 3186 << handler.AccessKind << O->isIndeterminate(); 3187 return handler.failed(); 3188 } 3189 3190 // C++ [class.ctor]p5, C++ [class.dtor]p5: 3191 // const and volatile semantics are not applied on an object under 3192 // {con,de}struction. 3193 if ((ObjType.isConstQualified() || ObjType.isVolatileQualified()) && 3194 ObjType->isRecordType() && 3195 Info.isEvaluatingCtorDtor( 3196 Obj.Base, llvm::makeArrayRef(Sub.Entries.begin(), 3197 Sub.Entries.begin() + I)) != 3198 ConstructionPhase::None) { 3199 ObjType = Info.Ctx.getCanonicalType(ObjType); 3200 ObjType.removeLocalConst(); 3201 ObjType.removeLocalVolatile(); 3202 } 3203 3204 // If this is our last pass, check that the final object type is OK. 3205 if (I == N || (I == N - 1 && ObjType->isAnyComplexType())) { 3206 // Accesses to volatile objects are prohibited. 3207 if (ObjType.isVolatileQualified() && isFormalAccess(handler.AccessKind)) { 3208 if (Info.getLangOpts().CPlusPlus) { 3209 int DiagKind; 3210 SourceLocation Loc; 3211 const NamedDecl *Decl = nullptr; 3212 if (VolatileField) { 3213 DiagKind = 2; 3214 Loc = VolatileField->getLocation(); 3215 Decl = VolatileField; 3216 } else if (auto *VD = Obj.Base.dyn_cast<const ValueDecl*>()) { 3217 DiagKind = 1; 3218 Loc = VD->getLocation(); 3219 Decl = VD; 3220 } else { 3221 DiagKind = 0; 3222 if (auto *E = Obj.Base.dyn_cast<const Expr *>()) 3223 Loc = E->getExprLoc(); 3224 } 3225 Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1) 3226 << handler.AccessKind << DiagKind << Decl; 3227 Info.Note(Loc, diag::note_constexpr_volatile_here) << DiagKind; 3228 } else { 3229 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 3230 } 3231 return handler.failed(); 3232 } 3233 3234 // If we are reading an object of class type, there may still be more 3235 // things we need to check: if there are any mutable subobjects, we 3236 // cannot perform this read. (This only happens when performing a trivial 3237 // copy or assignment.) 3238 if (ObjType->isRecordType() && 3239 !Obj.mayAccessMutableMembers(Info, handler.AccessKind) && 3240 diagnoseMutableFields(Info, E, handler.AccessKind, ObjType)) 3241 return handler.failed(); 3242 } 3243 3244 if (I == N) { 3245 if (!handler.found(*O, ObjType)) 3246 return false; 3247 3248 // If we modified a bit-field, truncate it to the right width. 3249 if (isModification(handler.AccessKind) && 3250 LastField && LastField->isBitField() && 3251 !truncateBitfieldValue(Info, E, *O, LastField)) 3252 return false; 3253 3254 return true; 3255 } 3256 3257 LastField = nullptr; 3258 if (ObjType->isArrayType()) { 3259 // Next subobject is an array element. 3260 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(ObjType); 3261 assert(CAT && "vla in literal type?"); 3262 uint64_t Index = Sub.Entries[I].getAsArrayIndex(); 3263 if (CAT->getSize().ule(Index)) { 3264 // Note, it should not be possible to form a pointer with a valid 3265 // designator which points more than one past the end of the array. 3266 if (Info.getLangOpts().CPlusPlus11) 3267 Info.FFDiag(E, diag::note_constexpr_access_past_end) 3268 << handler.AccessKind; 3269 else 3270 Info.FFDiag(E); 3271 return handler.failed(); 3272 } 3273 3274 ObjType = CAT->getElementType(); 3275 3276 if (O->getArrayInitializedElts() > Index) 3277 O = &O->getArrayInitializedElt(Index); 3278 else if (!isRead(handler.AccessKind)) { 3279 expandArray(*O, Index); 3280 O = &O->getArrayInitializedElt(Index); 3281 } else 3282 O = &O->getArrayFiller(); 3283 } else if (ObjType->isAnyComplexType()) { 3284 // Next subobject is a complex number. 3285 uint64_t Index = Sub.Entries[I].getAsArrayIndex(); 3286 if (Index > 1) { 3287 if (Info.getLangOpts().CPlusPlus11) 3288 Info.FFDiag(E, diag::note_constexpr_access_past_end) 3289 << handler.AccessKind; 3290 else 3291 Info.FFDiag(E); 3292 return handler.failed(); 3293 } 3294 3295 ObjType = getSubobjectType( 3296 ObjType, ObjType->castAs<ComplexType>()->getElementType()); 3297 3298 assert(I == N - 1 && "extracting subobject of scalar?"); 3299 if (O->isComplexInt()) { 3300 return handler.found(Index ? O->getComplexIntImag() 3301 : O->getComplexIntReal(), ObjType); 3302 } else { 3303 assert(O->isComplexFloat()); 3304 return handler.found(Index ? O->getComplexFloatImag() 3305 : O->getComplexFloatReal(), ObjType); 3306 } 3307 } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) { 3308 if (Field->isMutable() && 3309 !Obj.mayAccessMutableMembers(Info, handler.AccessKind)) { 3310 Info.FFDiag(E, diag::note_constexpr_access_mutable, 1) 3311 << handler.AccessKind << Field; 3312 Info.Note(Field->getLocation(), diag::note_declared_at); 3313 return handler.failed(); 3314 } 3315 3316 // Next subobject is a class, struct or union field. 3317 RecordDecl *RD = ObjType->castAs<RecordType>()->getDecl(); 3318 if (RD->isUnion()) { 3319 const FieldDecl *UnionField = O->getUnionField(); 3320 if (!UnionField || 3321 UnionField->getCanonicalDecl() != Field->getCanonicalDecl()) { 3322 if (I == N - 1 && handler.AccessKind == AK_Construct) { 3323 // Placement new onto an inactive union member makes it active. 3324 O->setUnion(Field, APValue()); 3325 } else { 3326 // FIXME: If O->getUnionValue() is absent, report that there's no 3327 // active union member rather than reporting the prior active union 3328 // member. We'll need to fix nullptr_t to not use APValue() as its 3329 // representation first. 3330 Info.FFDiag(E, diag::note_constexpr_access_inactive_union_member) 3331 << handler.AccessKind << Field << !UnionField << UnionField; 3332 return handler.failed(); 3333 } 3334 } 3335 O = &O->getUnionValue(); 3336 } else 3337 O = &O->getStructField(Field->getFieldIndex()); 3338 3339 ObjType = getSubobjectType(ObjType, Field->getType(), Field->isMutable()); 3340 LastField = Field; 3341 if (Field->getType().isVolatileQualified()) 3342 VolatileField = Field; 3343 } else { 3344 // Next subobject is a base class. 3345 const CXXRecordDecl *Derived = ObjType->getAsCXXRecordDecl(); 3346 const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]); 3347 O = &O->getStructBase(getBaseIndex(Derived, Base)); 3348 3349 ObjType = getSubobjectType(ObjType, Info.Ctx.getRecordType(Base)); 3350 } 3351 } 3352 } 3353 3354 namespace { 3355 struct ExtractSubobjectHandler { 3356 EvalInfo &Info; 3357 const Expr *E; 3358 APValue &Result; 3359 const AccessKinds AccessKind; 3360 3361 typedef bool result_type; 3362 bool failed() { return false; } 3363 bool found(APValue &Subobj, QualType SubobjType) { 3364 Result = Subobj; 3365 if (AccessKind == AK_ReadObjectRepresentation) 3366 return true; 3367 return CheckFullyInitialized(Info, E->getExprLoc(), SubobjType, Result); 3368 } 3369 bool found(APSInt &Value, QualType SubobjType) { 3370 Result = APValue(Value); 3371 return true; 3372 } 3373 bool found(APFloat &Value, QualType SubobjType) { 3374 Result = APValue(Value); 3375 return true; 3376 } 3377 }; 3378 } // end anonymous namespace 3379 3380 /// Extract the designated sub-object of an rvalue. 3381 static bool extractSubobject(EvalInfo &Info, const Expr *E, 3382 const CompleteObject &Obj, 3383 const SubobjectDesignator &Sub, APValue &Result, 3384 AccessKinds AK = AK_Read) { 3385 assert(AK == AK_Read || AK == AK_ReadObjectRepresentation); 3386 ExtractSubobjectHandler Handler = {Info, E, Result, AK}; 3387 return findSubobject(Info, E, Obj, Sub, Handler); 3388 } 3389 3390 namespace { 3391 struct ModifySubobjectHandler { 3392 EvalInfo &Info; 3393 APValue &NewVal; 3394 const Expr *E; 3395 3396 typedef bool result_type; 3397 static const AccessKinds AccessKind = AK_Assign; 3398 3399 bool checkConst(QualType QT) { 3400 // Assigning to a const object has undefined behavior. 3401 if (QT.isConstQualified()) { 3402 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT; 3403 return false; 3404 } 3405 return true; 3406 } 3407 3408 bool failed() { return false; } 3409 bool found(APValue &Subobj, QualType SubobjType) { 3410 if (!checkConst(SubobjType)) 3411 return false; 3412 // We've been given ownership of NewVal, so just swap it in. 3413 Subobj.swap(NewVal); 3414 return true; 3415 } 3416 bool found(APSInt &Value, QualType SubobjType) { 3417 if (!checkConst(SubobjType)) 3418 return false; 3419 if (!NewVal.isInt()) { 3420 // Maybe trying to write a cast pointer value into a complex? 3421 Info.FFDiag(E); 3422 return false; 3423 } 3424 Value = NewVal.getInt(); 3425 return true; 3426 } 3427 bool found(APFloat &Value, QualType SubobjType) { 3428 if (!checkConst(SubobjType)) 3429 return false; 3430 Value = NewVal.getFloat(); 3431 return true; 3432 } 3433 }; 3434 } // end anonymous namespace 3435 3436 const AccessKinds ModifySubobjectHandler::AccessKind; 3437 3438 /// Update the designated sub-object of an rvalue to the given value. 3439 static bool modifySubobject(EvalInfo &Info, const Expr *E, 3440 const CompleteObject &Obj, 3441 const SubobjectDesignator &Sub, 3442 APValue &NewVal) { 3443 ModifySubobjectHandler Handler = { Info, NewVal, E }; 3444 return findSubobject(Info, E, Obj, Sub, Handler); 3445 } 3446 3447 /// Find the position where two subobject designators diverge, or equivalently 3448 /// the length of the common initial subsequence. 3449 static unsigned FindDesignatorMismatch(QualType ObjType, 3450 const SubobjectDesignator &A, 3451 const SubobjectDesignator &B, 3452 bool &WasArrayIndex) { 3453 unsigned I = 0, N = std::min(A.Entries.size(), B.Entries.size()); 3454 for (/**/; I != N; ++I) { 3455 if (!ObjType.isNull() && 3456 (ObjType->isArrayType() || ObjType->isAnyComplexType())) { 3457 // Next subobject is an array element. 3458 if (A.Entries[I].getAsArrayIndex() != B.Entries[I].getAsArrayIndex()) { 3459 WasArrayIndex = true; 3460 return I; 3461 } 3462 if (ObjType->isAnyComplexType()) 3463 ObjType = ObjType->castAs<ComplexType>()->getElementType(); 3464 else 3465 ObjType = ObjType->castAsArrayTypeUnsafe()->getElementType(); 3466 } else { 3467 if (A.Entries[I].getAsBaseOrMember() != 3468 B.Entries[I].getAsBaseOrMember()) { 3469 WasArrayIndex = false; 3470 return I; 3471 } 3472 if (const FieldDecl *FD = getAsField(A.Entries[I])) 3473 // Next subobject is a field. 3474 ObjType = FD->getType(); 3475 else 3476 // Next subobject is a base class. 3477 ObjType = QualType(); 3478 } 3479 } 3480 WasArrayIndex = false; 3481 return I; 3482 } 3483 3484 /// Determine whether the given subobject designators refer to elements of the 3485 /// same array object. 3486 static bool AreElementsOfSameArray(QualType ObjType, 3487 const SubobjectDesignator &A, 3488 const SubobjectDesignator &B) { 3489 if (A.Entries.size() != B.Entries.size()) 3490 return false; 3491 3492 bool IsArray = A.MostDerivedIsArrayElement; 3493 if (IsArray && A.MostDerivedPathLength != A.Entries.size()) 3494 // A is a subobject of the array element. 3495 return false; 3496 3497 // If A (and B) designates an array element, the last entry will be the array 3498 // index. That doesn't have to match. Otherwise, we're in the 'implicit array 3499 // of length 1' case, and the entire path must match. 3500 bool WasArrayIndex; 3501 unsigned CommonLength = FindDesignatorMismatch(ObjType, A, B, WasArrayIndex); 3502 return CommonLength >= A.Entries.size() - IsArray; 3503 } 3504 3505 /// Find the complete object to which an LValue refers. 3506 static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, 3507 AccessKinds AK, const LValue &LVal, 3508 QualType LValType) { 3509 if (LVal.InvalidBase) { 3510 Info.FFDiag(E); 3511 return CompleteObject(); 3512 } 3513 3514 if (!LVal.Base) { 3515 Info.FFDiag(E, diag::note_constexpr_access_null) << AK; 3516 return CompleteObject(); 3517 } 3518 3519 CallStackFrame *Frame = nullptr; 3520 unsigned Depth = 0; 3521 if (LVal.getLValueCallIndex()) { 3522 std::tie(Frame, Depth) = 3523 Info.getCallFrameAndDepth(LVal.getLValueCallIndex()); 3524 if (!Frame) { 3525 Info.FFDiag(E, diag::note_constexpr_lifetime_ended, 1) 3526 << AK << LVal.Base.is<const ValueDecl*>(); 3527 NoteLValueLocation(Info, LVal.Base); 3528 return CompleteObject(); 3529 } 3530 } 3531 3532 bool IsAccess = isAnyAccess(AK); 3533 3534 // C++11 DR1311: An lvalue-to-rvalue conversion on a volatile-qualified type 3535 // is not a constant expression (even if the object is non-volatile). We also 3536 // apply this rule to C++98, in order to conform to the expected 'volatile' 3537 // semantics. 3538 if (isFormalAccess(AK) && LValType.isVolatileQualified()) { 3539 if (Info.getLangOpts().CPlusPlus) 3540 Info.FFDiag(E, diag::note_constexpr_access_volatile_type) 3541 << AK << LValType; 3542 else 3543 Info.FFDiag(E); 3544 return CompleteObject(); 3545 } 3546 3547 // Compute value storage location and type of base object. 3548 APValue *BaseVal = nullptr; 3549 QualType BaseType = getType(LVal.Base); 3550 3551 if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl*>()) { 3552 // In C++98, const, non-volatile integers initialized with ICEs are ICEs. 3553 // In C++11, constexpr, non-volatile variables initialized with constant 3554 // expressions are constant expressions too. Inside constexpr functions, 3555 // parameters are constant expressions even if they're non-const. 3556 // In C++1y, objects local to a constant expression (those with a Frame) are 3557 // both readable and writable inside constant expressions. 3558 // In C, such things can also be folded, although they are not ICEs. 3559 const VarDecl *VD = dyn_cast<VarDecl>(D); 3560 if (VD) { 3561 if (const VarDecl *VDef = VD->getDefinition(Info.Ctx)) 3562 VD = VDef; 3563 } 3564 if (!VD || VD->isInvalidDecl()) { 3565 Info.FFDiag(E); 3566 return CompleteObject(); 3567 } 3568 3569 // Unless we're looking at a local variable or argument in a constexpr call, 3570 // the variable we're reading must be const. 3571 if (!Frame) { 3572 if (Info.getLangOpts().CPlusPlus14 && 3573 lifetimeStartedInEvaluation(Info, LVal.Base)) { 3574 // OK, we can read and modify an object if we're in the process of 3575 // evaluating its initializer, because its lifetime began in this 3576 // evaluation. 3577 } else if (isModification(AK)) { 3578 // All the remaining cases do not permit modification of the object. 3579 Info.FFDiag(E, diag::note_constexpr_modify_global); 3580 return CompleteObject(); 3581 } else if (VD->isConstexpr()) { 3582 // OK, we can read this variable. 3583 } else if (BaseType->isIntegralOrEnumerationType()) { 3584 // In OpenCL if a variable is in constant address space it is a const 3585 // value. 3586 if (!(BaseType.isConstQualified() || 3587 (Info.getLangOpts().OpenCL && 3588 BaseType.getAddressSpace() == LangAS::opencl_constant))) { 3589 if (!IsAccess) 3590 return CompleteObject(LVal.getLValueBase(), nullptr, BaseType); 3591 if (Info.getLangOpts().CPlusPlus) { 3592 Info.FFDiag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD; 3593 Info.Note(VD->getLocation(), diag::note_declared_at); 3594 } else { 3595 Info.FFDiag(E); 3596 } 3597 return CompleteObject(); 3598 } 3599 } else if (!IsAccess) { 3600 return CompleteObject(LVal.getLValueBase(), nullptr, BaseType); 3601 } else if (BaseType->isFloatingType() && BaseType.isConstQualified()) { 3602 // We support folding of const floating-point types, in order to make 3603 // static const data members of such types (supported as an extension) 3604 // more useful. 3605 if (Info.getLangOpts().CPlusPlus11) { 3606 Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD; 3607 Info.Note(VD->getLocation(), diag::note_declared_at); 3608 } else { 3609 Info.CCEDiag(E); 3610 } 3611 } else if (BaseType.isConstQualified() && VD->hasDefinition(Info.Ctx)) { 3612 Info.CCEDiag(E, diag::note_constexpr_ltor_non_constexpr) << VD; 3613 // Keep evaluating to see what we can do. 3614 } else { 3615 // FIXME: Allow folding of values of any literal type in all languages. 3616 if (Info.checkingPotentialConstantExpression() && 3617 VD->getType().isConstQualified() && !VD->hasDefinition(Info.Ctx)) { 3618 // The definition of this variable could be constexpr. We can't 3619 // access it right now, but may be able to in future. 3620 } else if (Info.getLangOpts().CPlusPlus11) { 3621 Info.FFDiag(E, diag::note_constexpr_ltor_non_constexpr, 1) << VD; 3622 Info.Note(VD->getLocation(), diag::note_declared_at); 3623 } else { 3624 Info.FFDiag(E); 3625 } 3626 return CompleteObject(); 3627 } 3628 } 3629 3630 if (!evaluateVarDeclInit(Info, E, VD, Frame, BaseVal, &LVal)) 3631 return CompleteObject(); 3632 } else if (DynamicAllocLValue DA = LVal.Base.dyn_cast<DynamicAllocLValue>()) { 3633 Optional<DynAlloc*> Alloc = Info.lookupDynamicAlloc(DA); 3634 if (!Alloc) { 3635 Info.FFDiag(E, diag::note_constexpr_access_deleted_object) << AK; 3636 return CompleteObject(); 3637 } 3638 return CompleteObject(LVal.Base, &(*Alloc)->Value, 3639 LVal.Base.getDynamicAllocType()); 3640 } else { 3641 const Expr *Base = LVal.Base.dyn_cast<const Expr*>(); 3642 3643 if (!Frame) { 3644 if (const MaterializeTemporaryExpr *MTE = 3645 dyn_cast_or_null<MaterializeTemporaryExpr>(Base)) { 3646 assert(MTE->getStorageDuration() == SD_Static && 3647 "should have a frame for a non-global materialized temporary"); 3648 3649 // Per C++1y [expr.const]p2: 3650 // an lvalue-to-rvalue conversion [is not allowed unless it applies to] 3651 // - a [...] glvalue of integral or enumeration type that refers to 3652 // a non-volatile const object [...] 3653 // [...] 3654 // - a [...] glvalue of literal type that refers to a non-volatile 3655 // object whose lifetime began within the evaluation of e. 3656 // 3657 // C++11 misses the 'began within the evaluation of e' check and 3658 // instead allows all temporaries, including things like: 3659 // int &&r = 1; 3660 // int x = ++r; 3661 // constexpr int k = r; 3662 // Therefore we use the C++14 rules in C++11 too. 3663 // 3664 // Note that temporaries whose lifetimes began while evaluating a 3665 // variable's constructor are not usable while evaluating the 3666 // corresponding destructor, not even if they're of const-qualified 3667 // types. 3668 if (!(BaseType.isConstQualified() && 3669 BaseType->isIntegralOrEnumerationType()) && 3670 !lifetimeStartedInEvaluation(Info, LVal.Base)) { 3671 if (!IsAccess) 3672 return CompleteObject(LVal.getLValueBase(), nullptr, BaseType); 3673 Info.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK; 3674 Info.Note(MTE->getExprLoc(), diag::note_constexpr_temporary_here); 3675 return CompleteObject(); 3676 } 3677 3678 BaseVal = MTE->getOrCreateValue(false); 3679 assert(BaseVal && "got reference to unevaluated temporary"); 3680 } else { 3681 if (!IsAccess) 3682 return CompleteObject(LVal.getLValueBase(), nullptr, BaseType); 3683 APValue Val; 3684 LVal.moveInto(Val); 3685 Info.FFDiag(E, diag::note_constexpr_access_unreadable_object) 3686 << AK 3687 << Val.getAsString(Info.Ctx, 3688 Info.Ctx.getLValueReferenceType(LValType)); 3689 NoteLValueLocation(Info, LVal.Base); 3690 return CompleteObject(); 3691 } 3692 } else { 3693 BaseVal = Frame->getTemporary(Base, LVal.Base.getVersion()); 3694 assert(BaseVal && "missing value for temporary"); 3695 } 3696 } 3697 3698 // In C++14, we can't safely access any mutable state when we might be 3699 // evaluating after an unmodeled side effect. 3700 // 3701 // FIXME: Not all local state is mutable. Allow local constant subobjects 3702 // to be read here (but take care with 'mutable' fields). 3703 if ((Frame && Info.getLangOpts().CPlusPlus14 && 3704 Info.EvalStatus.HasSideEffects) || 3705 (isModification(AK) && Depth < Info.SpeculativeEvaluationDepth)) 3706 return CompleteObject(); 3707 3708 return CompleteObject(LVal.getLValueBase(), BaseVal, BaseType); 3709 } 3710 3711 /// Perform an lvalue-to-rvalue conversion on the given glvalue. This 3712 /// can also be used for 'lvalue-to-lvalue' conversions for looking up the 3713 /// glvalue referred to by an entity of reference type. 3714 /// 3715 /// \param Info - Information about the ongoing evaluation. 3716 /// \param Conv - The expression for which we are performing the conversion. 3717 /// Used for diagnostics. 3718 /// \param Type - The type of the glvalue (before stripping cv-qualifiers in the 3719 /// case of a non-class type). 3720 /// \param LVal - The glvalue on which we are attempting to perform this action. 3721 /// \param RVal - The produced value will be placed here. 3722 /// \param WantObjectRepresentation - If true, we're looking for the object 3723 /// representation rather than the value, and in particular, 3724 /// there is no requirement that the result be fully initialized. 3725 static bool 3726 handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv, QualType Type, 3727 const LValue &LVal, APValue &RVal, 3728 bool WantObjectRepresentation = false) { 3729 if (LVal.Designator.Invalid) 3730 return false; 3731 3732 // Check for special cases where there is no existing APValue to look at. 3733 const Expr *Base = LVal.Base.dyn_cast<const Expr*>(); 3734 3735 AccessKinds AK = 3736 WantObjectRepresentation ? AK_ReadObjectRepresentation : AK_Read; 3737 3738 if (Base && !LVal.getLValueCallIndex() && !Type.isVolatileQualified()) { 3739 if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) { 3740 // In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the 3741 // initializer until now for such expressions. Such an expression can't be 3742 // an ICE in C, so this only matters for fold. 3743 if (Type.isVolatileQualified()) { 3744 Info.FFDiag(Conv); 3745 return false; 3746 } 3747 APValue Lit; 3748 if (!Evaluate(Lit, Info, CLE->getInitializer())) 3749 return false; 3750 CompleteObject LitObj(LVal.Base, &Lit, Base->getType()); 3751 return extractSubobject(Info, Conv, LitObj, LVal.Designator, RVal, AK); 3752 } else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) { 3753 // Special-case character extraction so we don't have to construct an 3754 // APValue for the whole string. 3755 assert(LVal.Designator.Entries.size() <= 1 && 3756 "Can only read characters from string literals"); 3757 if (LVal.Designator.Entries.empty()) { 3758 // Fail for now for LValue to RValue conversion of an array. 3759 // (This shouldn't show up in C/C++, but it could be triggered by a 3760 // weird EvaluateAsRValue call from a tool.) 3761 Info.FFDiag(Conv); 3762 return false; 3763 } 3764 if (LVal.Designator.isOnePastTheEnd()) { 3765 if (Info.getLangOpts().CPlusPlus11) 3766 Info.FFDiag(Conv, diag::note_constexpr_access_past_end) << AK; 3767 else 3768 Info.FFDiag(Conv); 3769 return false; 3770 } 3771 uint64_t CharIndex = LVal.Designator.Entries[0].getAsArrayIndex(); 3772 RVal = APValue(extractStringLiteralCharacter(Info, Base, CharIndex)); 3773 return true; 3774 } 3775 } 3776 3777 CompleteObject Obj = findCompleteObject(Info, Conv, AK, LVal, Type); 3778 return Obj && extractSubobject(Info, Conv, Obj, LVal.Designator, RVal, AK); 3779 } 3780 3781 /// Perform an assignment of Val to LVal. Takes ownership of Val. 3782 static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal, 3783 QualType LValType, APValue &Val) { 3784 if (LVal.Designator.Invalid) 3785 return false; 3786 3787 if (!Info.getLangOpts().CPlusPlus14) { 3788 Info.FFDiag(E); 3789 return false; 3790 } 3791 3792 CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType); 3793 return Obj && modifySubobject(Info, E, Obj, LVal.Designator, Val); 3794 } 3795 3796 namespace { 3797 struct CompoundAssignSubobjectHandler { 3798 EvalInfo &Info; 3799 const Expr *E; 3800 QualType PromotedLHSType; 3801 BinaryOperatorKind Opcode; 3802 const APValue &RHS; 3803 3804 static const AccessKinds AccessKind = AK_Assign; 3805 3806 typedef bool result_type; 3807 3808 bool checkConst(QualType QT) { 3809 // Assigning to a const object has undefined behavior. 3810 if (QT.isConstQualified()) { 3811 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT; 3812 return false; 3813 } 3814 return true; 3815 } 3816 3817 bool failed() { return false; } 3818 bool found(APValue &Subobj, QualType SubobjType) { 3819 switch (Subobj.getKind()) { 3820 case APValue::Int: 3821 return found(Subobj.getInt(), SubobjType); 3822 case APValue::Float: 3823 return found(Subobj.getFloat(), SubobjType); 3824 case APValue::ComplexInt: 3825 case APValue::ComplexFloat: 3826 // FIXME: Implement complex compound assignment. 3827 Info.FFDiag(E); 3828 return false; 3829 case APValue::LValue: 3830 return foundPointer(Subobj, SubobjType); 3831 default: 3832 // FIXME: can this happen? 3833 Info.FFDiag(E); 3834 return false; 3835 } 3836 } 3837 bool found(APSInt &Value, QualType SubobjType) { 3838 if (!checkConst(SubobjType)) 3839 return false; 3840 3841 if (!SubobjType->isIntegerType()) { 3842 // We don't support compound assignment on integer-cast-to-pointer 3843 // values. 3844 Info.FFDiag(E); 3845 return false; 3846 } 3847 3848 if (RHS.isInt()) { 3849 APSInt LHS = 3850 HandleIntToIntCast(Info, E, PromotedLHSType, SubobjType, Value); 3851 if (!handleIntIntBinOp(Info, E, LHS, Opcode, RHS.getInt(), LHS)) 3852 return false; 3853 Value = HandleIntToIntCast(Info, E, SubobjType, PromotedLHSType, LHS); 3854 return true; 3855 } else if (RHS.isFloat()) { 3856 APFloat FValue(0.0); 3857 return HandleIntToFloatCast(Info, E, SubobjType, Value, PromotedLHSType, 3858 FValue) && 3859 handleFloatFloatBinOp(Info, E, FValue, Opcode, RHS.getFloat()) && 3860 HandleFloatToIntCast(Info, E, PromotedLHSType, FValue, SubobjType, 3861 Value); 3862 } 3863 3864 Info.FFDiag(E); 3865 return false; 3866 } 3867 bool found(APFloat &Value, QualType SubobjType) { 3868 return checkConst(SubobjType) && 3869 HandleFloatToFloatCast(Info, E, SubobjType, PromotedLHSType, 3870 Value) && 3871 handleFloatFloatBinOp(Info, E, Value, Opcode, RHS.getFloat()) && 3872 HandleFloatToFloatCast(Info, E, PromotedLHSType, SubobjType, Value); 3873 } 3874 bool foundPointer(APValue &Subobj, QualType SubobjType) { 3875 if (!checkConst(SubobjType)) 3876 return false; 3877 3878 QualType PointeeType; 3879 if (const PointerType *PT = SubobjType->getAs<PointerType>()) 3880 PointeeType = PT->getPointeeType(); 3881 3882 if (PointeeType.isNull() || !RHS.isInt() || 3883 (Opcode != BO_Add && Opcode != BO_Sub)) { 3884 Info.FFDiag(E); 3885 return false; 3886 } 3887 3888 APSInt Offset = RHS.getInt(); 3889 if (Opcode == BO_Sub) 3890 negateAsSigned(Offset); 3891 3892 LValue LVal; 3893 LVal.setFrom(Info.Ctx, Subobj); 3894 if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType, Offset)) 3895 return false; 3896 LVal.moveInto(Subobj); 3897 return true; 3898 } 3899 }; 3900 } // end anonymous namespace 3901 3902 const AccessKinds CompoundAssignSubobjectHandler::AccessKind; 3903 3904 /// Perform a compound assignment of LVal <op>= RVal. 3905 static bool handleCompoundAssignment( 3906 EvalInfo &Info, const Expr *E, 3907 const LValue &LVal, QualType LValType, QualType PromotedLValType, 3908 BinaryOperatorKind Opcode, const APValue &RVal) { 3909 if (LVal.Designator.Invalid) 3910 return false; 3911 3912 if (!Info.getLangOpts().CPlusPlus14) { 3913 Info.FFDiag(E); 3914 return false; 3915 } 3916 3917 CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType); 3918 CompoundAssignSubobjectHandler Handler = { Info, E, PromotedLValType, Opcode, 3919 RVal }; 3920 return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler); 3921 } 3922 3923 namespace { 3924 struct IncDecSubobjectHandler { 3925 EvalInfo &Info; 3926 const UnaryOperator *E; 3927 AccessKinds AccessKind; 3928 APValue *Old; 3929 3930 typedef bool result_type; 3931 3932 bool checkConst(QualType QT) { 3933 // Assigning to a const object has undefined behavior. 3934 if (QT.isConstQualified()) { 3935 Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT; 3936 return false; 3937 } 3938 return true; 3939 } 3940 3941 bool failed() { return false; } 3942 bool found(APValue &Subobj, QualType SubobjType) { 3943 // Stash the old value. Also clear Old, so we don't clobber it later 3944 // if we're post-incrementing a complex. 3945 if (Old) { 3946 *Old = Subobj; 3947 Old = nullptr; 3948 } 3949 3950 switch (Subobj.getKind()) { 3951 case APValue::Int: 3952 return found(Subobj.getInt(), SubobjType); 3953 case APValue::Float: 3954 return found(Subobj.getFloat(), SubobjType); 3955 case APValue::ComplexInt: 3956 return found(Subobj.getComplexIntReal(), 3957 SubobjType->castAs<ComplexType>()->getElementType() 3958 .withCVRQualifiers(SubobjType.getCVRQualifiers())); 3959 case APValue::ComplexFloat: 3960 return found(Subobj.getComplexFloatReal(), 3961 SubobjType->castAs<ComplexType>()->getElementType() 3962 .withCVRQualifiers(SubobjType.getCVRQualifiers())); 3963 case APValue::LValue: 3964 return foundPointer(Subobj, SubobjType); 3965 default: 3966 // FIXME: can this happen? 3967 Info.FFDiag(E); 3968 return false; 3969 } 3970 } 3971 bool found(APSInt &Value, QualType SubobjType) { 3972 if (!checkConst(SubobjType)) 3973 return false; 3974 3975 if (!SubobjType->isIntegerType()) { 3976 // We don't support increment / decrement on integer-cast-to-pointer 3977 // values. 3978 Info.FFDiag(E); 3979 return false; 3980 } 3981 3982 if (Old) *Old = APValue(Value); 3983 3984 // bool arithmetic promotes to int, and the conversion back to bool 3985 // doesn't reduce mod 2^n, so special-case it. 3986 if (SubobjType->isBooleanType()) { 3987 if (AccessKind == AK_Increment) 3988 Value = 1; 3989 else 3990 Value = !Value; 3991 return true; 3992 } 3993 3994 bool WasNegative = Value.isNegative(); 3995 if (AccessKind == AK_Increment) { 3996 ++Value; 3997 3998 if (!WasNegative && Value.isNegative() && E->canOverflow()) { 3999 APSInt ActualValue(Value, /*IsUnsigned*/true); 4000 return HandleOverflow(Info, E, ActualValue, SubobjType); 4001 } 4002 } else { 4003 --Value; 4004 4005 if (WasNegative && !Value.isNegative() && E->canOverflow()) { 4006 unsigned BitWidth = Value.getBitWidth(); 4007 APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/false); 4008 ActualValue.setBit(BitWidth); 4009 return HandleOverflow(Info, E, ActualValue, SubobjType); 4010 } 4011 } 4012 return true; 4013 } 4014 bool found(APFloat &Value, QualType SubobjType) { 4015 if (!checkConst(SubobjType)) 4016 return false; 4017 4018 if (Old) *Old = APValue(Value); 4019 4020 APFloat One(Value.getSemantics(), 1); 4021 if (AccessKind == AK_Increment) 4022 Value.add(One, APFloat::rmNearestTiesToEven); 4023 else 4024 Value.subtract(One, APFloat::rmNearestTiesToEven); 4025 return true; 4026 } 4027 bool foundPointer(APValue &Subobj, QualType SubobjType) { 4028 if (!checkConst(SubobjType)) 4029 return false; 4030 4031 QualType PointeeType; 4032 if (const PointerType *PT = SubobjType->getAs<PointerType>()) 4033 PointeeType = PT->getPointeeType(); 4034 else { 4035 Info.FFDiag(E); 4036 return false; 4037 } 4038 4039 LValue LVal; 4040 LVal.setFrom(Info.Ctx, Subobj); 4041 if (!HandleLValueArrayAdjustment(Info, E, LVal, PointeeType, 4042 AccessKind == AK_Increment ? 1 : -1)) 4043 return false; 4044 LVal.moveInto(Subobj); 4045 return true; 4046 } 4047 }; 4048 } // end anonymous namespace 4049 4050 /// Perform an increment or decrement on LVal. 4051 static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal, 4052 QualType LValType, bool IsIncrement, APValue *Old) { 4053 if (LVal.Designator.Invalid) 4054 return false; 4055 4056 if (!Info.getLangOpts().CPlusPlus14) { 4057 Info.FFDiag(E); 4058 return false; 4059 } 4060 4061 AccessKinds AK = IsIncrement ? AK_Increment : AK_Decrement; 4062 CompleteObject Obj = findCompleteObject(Info, E, AK, LVal, LValType); 4063 IncDecSubobjectHandler Handler = {Info, cast<UnaryOperator>(E), AK, Old}; 4064 return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler); 4065 } 4066 4067 /// Build an lvalue for the object argument of a member function call. 4068 static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object, 4069 LValue &This) { 4070 if (Object->getType()->isPointerType() && Object->isRValue()) 4071 return EvaluatePointer(Object, This, Info); 4072 4073 if (Object->isGLValue()) 4074 return EvaluateLValue(Object, This, Info); 4075 4076 if (Object->getType()->isLiteralType(Info.Ctx)) 4077 return EvaluateTemporary(Object, This, Info); 4078 4079 Info.FFDiag(Object, diag::note_constexpr_nonliteral) << Object->getType(); 4080 return false; 4081 } 4082 4083 /// HandleMemberPointerAccess - Evaluate a member access operation and build an 4084 /// lvalue referring to the result. 4085 /// 4086 /// \param Info - Information about the ongoing evaluation. 4087 /// \param LV - An lvalue referring to the base of the member pointer. 4088 /// \param RHS - The member pointer expression. 4089 /// \param IncludeMember - Specifies whether the member itself is included in 4090 /// the resulting LValue subobject designator. This is not possible when 4091 /// creating a bound member function. 4092 /// \return The field or method declaration to which the member pointer refers, 4093 /// or 0 if evaluation fails. 4094 static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info, 4095 QualType LVType, 4096 LValue &LV, 4097 const Expr *RHS, 4098 bool IncludeMember = true) { 4099 MemberPtr MemPtr; 4100 if (!EvaluateMemberPointer(RHS, MemPtr, Info)) 4101 return nullptr; 4102 4103 // C++11 [expr.mptr.oper]p6: If the second operand is the null pointer to 4104 // member value, the behavior is undefined. 4105 if (!MemPtr.getDecl()) { 4106 // FIXME: Specific diagnostic. 4107 Info.FFDiag(RHS); 4108 return nullptr; 4109 } 4110 4111 if (MemPtr.isDerivedMember()) { 4112 // This is a member of some derived class. Truncate LV appropriately. 4113 // The end of the derived-to-base path for the base object must match the 4114 // derived-to-base path for the member pointer. 4115 if (LV.Designator.MostDerivedPathLength + MemPtr.Path.size() > 4116 LV.Designator.Entries.size()) { 4117 Info.FFDiag(RHS); 4118 return nullptr; 4119 } 4120 unsigned PathLengthToMember = 4121 LV.Designator.Entries.size() - MemPtr.Path.size(); 4122 for (unsigned I = 0, N = MemPtr.Path.size(); I != N; ++I) { 4123 const CXXRecordDecl *LVDecl = getAsBaseClass( 4124 LV.Designator.Entries[PathLengthToMember + I]); 4125 const CXXRecordDecl *MPDecl = MemPtr.Path[I]; 4126 if (LVDecl->getCanonicalDecl() != MPDecl->getCanonicalDecl()) { 4127 Info.FFDiag(RHS); 4128 return nullptr; 4129 } 4130 } 4131 4132 // Truncate the lvalue to the appropriate derived class. 4133 if (!CastToDerivedClass(Info, RHS, LV, MemPtr.getContainingRecord(), 4134 PathLengthToMember)) 4135 return nullptr; 4136 } else if (!MemPtr.Path.empty()) { 4137 // Extend the LValue path with the member pointer's path. 4138 LV.Designator.Entries.reserve(LV.Designator.Entries.size() + 4139 MemPtr.Path.size() + IncludeMember); 4140 4141 // Walk down to the appropriate base class. 4142 if (const PointerType *PT = LVType->getAs<PointerType>()) 4143 LVType = PT->getPointeeType(); 4144 const CXXRecordDecl *RD = LVType->getAsCXXRecordDecl(); 4145 assert(RD && "member pointer access on non-class-type expression"); 4146 // The first class in the path is that of the lvalue. 4147 for (unsigned I = 1, N = MemPtr.Path.size(); I != N; ++I) { 4148 const CXXRecordDecl *Base = MemPtr.Path[N - I - 1]; 4149 if (!HandleLValueDirectBase(Info, RHS, LV, RD, Base)) 4150 return nullptr; 4151 RD = Base; 4152 } 4153 // Finally cast to the class containing the member. 4154 if (!HandleLValueDirectBase(Info, RHS, LV, RD, 4155 MemPtr.getContainingRecord())) 4156 return nullptr; 4157 } 4158 4159 // Add the member. Note that we cannot build bound member functions here. 4160 if (IncludeMember) { 4161 if (const FieldDecl *FD = dyn_cast<FieldDecl>(MemPtr.getDecl())) { 4162 if (!HandleLValueMember(Info, RHS, LV, FD)) 4163 return nullptr; 4164 } else if (const IndirectFieldDecl *IFD = 4165 dyn_cast<IndirectFieldDecl>(MemPtr.getDecl())) { 4166 if (!HandleLValueIndirectMember(Info, RHS, LV, IFD)) 4167 return nullptr; 4168 } else { 4169 llvm_unreachable("can't construct reference to bound member function"); 4170 } 4171 } 4172 4173 return MemPtr.getDecl(); 4174 } 4175 4176 static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info, 4177 const BinaryOperator *BO, 4178 LValue &LV, 4179 bool IncludeMember = true) { 4180 assert(BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI); 4181 4182 if (!EvaluateObjectArgument(Info, BO->getLHS(), LV)) { 4183 if (Info.noteFailure()) { 4184 MemberPtr MemPtr; 4185 EvaluateMemberPointer(BO->getRHS(), MemPtr, Info); 4186 } 4187 return nullptr; 4188 } 4189 4190 return HandleMemberPointerAccess(Info, BO->getLHS()->getType(), LV, 4191 BO->getRHS(), IncludeMember); 4192 } 4193 4194 /// HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on 4195 /// the provided lvalue, which currently refers to the base object. 4196 static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E, 4197 LValue &Result) { 4198 SubobjectDesignator &D = Result.Designator; 4199 if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived)) 4200 return false; 4201 4202 QualType TargetQT = E->getType(); 4203 if (const PointerType *PT = TargetQT->getAs<PointerType>()) 4204 TargetQT = PT->getPointeeType(); 4205 4206 // Check this cast lands within the final derived-to-base subobject path. 4207 if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) { 4208 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast) 4209 << D.MostDerivedType << TargetQT; 4210 return false; 4211 } 4212 4213 // Check the type of the final cast. We don't need to check the path, 4214 // since a cast can only be formed if the path is unique. 4215 unsigned NewEntriesSize = D.Entries.size() - E->path_size(); 4216 const CXXRecordDecl *TargetType = TargetQT->getAsCXXRecordDecl(); 4217 const CXXRecordDecl *FinalType; 4218 if (NewEntriesSize == D.MostDerivedPathLength) 4219 FinalType = D.MostDerivedType->getAsCXXRecordDecl(); 4220 else 4221 FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]); 4222 if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) { 4223 Info.CCEDiag(E, diag::note_constexpr_invalid_downcast) 4224 << D.MostDerivedType << TargetQT; 4225 return false; 4226 } 4227 4228 // Truncate the lvalue to the appropriate derived class. 4229 return CastToDerivedClass(Info, E, Result, TargetType, NewEntriesSize); 4230 } 4231 4232 /// Get the value to use for a default-initialized object of type T. 4233 static APValue getDefaultInitValue(QualType T) { 4234 if (auto *RD = T->getAsCXXRecordDecl()) { 4235 if (RD->isUnion()) 4236 return APValue((const FieldDecl*)nullptr); 4237 4238 APValue Struct(APValue::UninitStruct(), RD->getNumBases(), 4239 std::distance(RD->field_begin(), RD->field_end())); 4240 4241 unsigned Index = 0; 4242 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 4243 End = RD->bases_end(); I != End; ++I, ++Index) 4244 Struct.getStructBase(Index) = getDefaultInitValue(I->getType()); 4245 4246 for (const auto *I : RD->fields()) { 4247 if (I->isUnnamedBitfield()) 4248 continue; 4249 Struct.getStructField(I->getFieldIndex()) = 4250 getDefaultInitValue(I->getType()); 4251 } 4252 return Struct; 4253 } 4254 4255 if (auto *AT = 4256 dyn_cast_or_null<ConstantArrayType>(T->getAsArrayTypeUnsafe())) { 4257 APValue Array(APValue::UninitArray(), 0, AT->getSize().getZExtValue()); 4258 if (Array.hasArrayFiller()) 4259 Array.getArrayFiller() = getDefaultInitValue(AT->getElementType()); 4260 return Array; 4261 } 4262 4263 return APValue::IndeterminateValue(); 4264 } 4265 4266 namespace { 4267 enum EvalStmtResult { 4268 /// Evaluation failed. 4269 ESR_Failed, 4270 /// Hit a 'return' statement. 4271 ESR_Returned, 4272 /// Evaluation succeeded. 4273 ESR_Succeeded, 4274 /// Hit a 'continue' statement. 4275 ESR_Continue, 4276 /// Hit a 'break' statement. 4277 ESR_Break, 4278 /// Still scanning for 'case' or 'default' statement. 4279 ESR_CaseNotFound 4280 }; 4281 } 4282 4283 static bool EvaluateVarDecl(EvalInfo &Info, const VarDecl *VD) { 4284 // We don't need to evaluate the initializer for a static local. 4285 if (!VD->hasLocalStorage()) 4286 return true; 4287 4288 LValue Result; 4289 APValue &Val = 4290 Info.CurrentCall->createTemporary(VD, VD->getType(), true, Result); 4291 4292 const Expr *InitE = VD->getInit(); 4293 if (!InitE) { 4294 Val = getDefaultInitValue(VD->getType()); 4295 return true; 4296 } 4297 4298 if (InitE->isValueDependent()) 4299 return false; 4300 4301 if (!EvaluateInPlace(Val, Info, Result, InitE)) { 4302 // Wipe out any partially-computed value, to allow tracking that this 4303 // evaluation failed. 4304 Val = APValue(); 4305 return false; 4306 } 4307 4308 return true; 4309 } 4310 4311 static bool EvaluateDecl(EvalInfo &Info, const Decl *D) { 4312 bool OK = true; 4313 4314 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 4315 OK &= EvaluateVarDecl(Info, VD); 4316 4317 if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(D)) 4318 for (auto *BD : DD->bindings()) 4319 if (auto *VD = BD->getHoldingVar()) 4320 OK &= EvaluateDecl(Info, VD); 4321 4322 return OK; 4323 } 4324 4325 4326 /// Evaluate a condition (either a variable declaration or an expression). 4327 static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl, 4328 const Expr *Cond, bool &Result) { 4329 FullExpressionRAII Scope(Info); 4330 if (CondDecl && !EvaluateDecl(Info, CondDecl)) 4331 return false; 4332 if (!EvaluateAsBooleanCondition(Cond, Result, Info)) 4333 return false; 4334 return Scope.destroy(); 4335 } 4336 4337 namespace { 4338 /// A location where the result (returned value) of evaluating a 4339 /// statement should be stored. 4340 struct StmtResult { 4341 /// The APValue that should be filled in with the returned value. 4342 APValue &Value; 4343 /// The location containing the result, if any (used to support RVO). 4344 const LValue *Slot; 4345 }; 4346 4347 struct TempVersionRAII { 4348 CallStackFrame &Frame; 4349 4350 TempVersionRAII(CallStackFrame &Frame) : Frame(Frame) { 4351 Frame.pushTempVersion(); 4352 } 4353 4354 ~TempVersionRAII() { 4355 Frame.popTempVersion(); 4356 } 4357 }; 4358 4359 } 4360 4361 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info, 4362 const Stmt *S, 4363 const SwitchCase *SC = nullptr); 4364 4365 /// Evaluate the body of a loop, and translate the result as appropriate. 4366 static EvalStmtResult EvaluateLoopBody(StmtResult &Result, EvalInfo &Info, 4367 const Stmt *Body, 4368 const SwitchCase *Case = nullptr) { 4369 BlockScopeRAII Scope(Info); 4370 4371 EvalStmtResult ESR = EvaluateStmt(Result, Info, Body, Case); 4372 if (ESR != ESR_Failed && ESR != ESR_CaseNotFound && !Scope.destroy()) 4373 ESR = ESR_Failed; 4374 4375 switch (ESR) { 4376 case ESR_Break: 4377 return ESR_Succeeded; 4378 case ESR_Succeeded: 4379 case ESR_Continue: 4380 return ESR_Continue; 4381 case ESR_Failed: 4382 case ESR_Returned: 4383 case ESR_CaseNotFound: 4384 return ESR; 4385 } 4386 llvm_unreachable("Invalid EvalStmtResult!"); 4387 } 4388 4389 /// Evaluate a switch statement. 4390 static EvalStmtResult EvaluateSwitch(StmtResult &Result, EvalInfo &Info, 4391 const SwitchStmt *SS) { 4392 BlockScopeRAII Scope(Info); 4393 4394 // Evaluate the switch condition. 4395 APSInt Value; 4396 { 4397 if (const Stmt *Init = SS->getInit()) { 4398 EvalStmtResult ESR = EvaluateStmt(Result, Info, Init); 4399 if (ESR != ESR_Succeeded) { 4400 if (ESR != ESR_Failed && !Scope.destroy()) 4401 ESR = ESR_Failed; 4402 return ESR; 4403 } 4404 } 4405 4406 FullExpressionRAII CondScope(Info); 4407 if (SS->getConditionVariable() && 4408 !EvaluateDecl(Info, SS->getConditionVariable())) 4409 return ESR_Failed; 4410 if (!EvaluateInteger(SS->getCond(), Value, Info)) 4411 return ESR_Failed; 4412 if (!CondScope.destroy()) 4413 return ESR_Failed; 4414 } 4415 4416 // Find the switch case corresponding to the value of the condition. 4417 // FIXME: Cache this lookup. 4418 const SwitchCase *Found = nullptr; 4419 for (const SwitchCase *SC = SS->getSwitchCaseList(); SC; 4420 SC = SC->getNextSwitchCase()) { 4421 if (isa<DefaultStmt>(SC)) { 4422 Found = SC; 4423 continue; 4424 } 4425 4426 const CaseStmt *CS = cast<CaseStmt>(SC); 4427 APSInt LHS = CS->getLHS()->EvaluateKnownConstInt(Info.Ctx); 4428 APSInt RHS = CS->getRHS() ? CS->getRHS()->EvaluateKnownConstInt(Info.Ctx) 4429 : LHS; 4430 if (LHS <= Value && Value <= RHS) { 4431 Found = SC; 4432 break; 4433 } 4434 } 4435 4436 if (!Found) 4437 return Scope.destroy() ? ESR_Succeeded : ESR_Failed; 4438 4439 // Search the switch body for the switch case and evaluate it from there. 4440 EvalStmtResult ESR = EvaluateStmt(Result, Info, SS->getBody(), Found); 4441 if (ESR != ESR_Failed && ESR != ESR_CaseNotFound && !Scope.destroy()) 4442 return ESR_Failed; 4443 4444 switch (ESR) { 4445 case ESR_Break: 4446 return ESR_Succeeded; 4447 case ESR_Succeeded: 4448 case ESR_Continue: 4449 case ESR_Failed: 4450 case ESR_Returned: 4451 return ESR; 4452 case ESR_CaseNotFound: 4453 // This can only happen if the switch case is nested within a statement 4454 // expression. We have no intention of supporting that. 4455 Info.FFDiag(Found->getBeginLoc(), 4456 diag::note_constexpr_stmt_expr_unsupported); 4457 return ESR_Failed; 4458 } 4459 llvm_unreachable("Invalid EvalStmtResult!"); 4460 } 4461 4462 // Evaluate a statement. 4463 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info, 4464 const Stmt *S, const SwitchCase *Case) { 4465 if (!Info.nextStep(S)) 4466 return ESR_Failed; 4467 4468 // If we're hunting down a 'case' or 'default' label, recurse through 4469 // substatements until we hit the label. 4470 if (Case) { 4471 switch (S->getStmtClass()) { 4472 case Stmt::CompoundStmtClass: 4473 // FIXME: Precompute which substatement of a compound statement we 4474 // would jump to, and go straight there rather than performing a 4475 // linear scan each time. 4476 case Stmt::LabelStmtClass: 4477 case Stmt::AttributedStmtClass: 4478 case Stmt::DoStmtClass: 4479 break; 4480 4481 case Stmt::CaseStmtClass: 4482 case Stmt::DefaultStmtClass: 4483 if (Case == S) 4484 Case = nullptr; 4485 break; 4486 4487 case Stmt::IfStmtClass: { 4488 // FIXME: Precompute which side of an 'if' we would jump to, and go 4489 // straight there rather than scanning both sides. 4490 const IfStmt *IS = cast<IfStmt>(S); 4491 4492 // Wrap the evaluation in a block scope, in case it's a DeclStmt 4493 // preceded by our switch label. 4494 BlockScopeRAII Scope(Info); 4495 4496 // Step into the init statement in case it brings an (uninitialized) 4497 // variable into scope. 4498 if (const Stmt *Init = IS->getInit()) { 4499 EvalStmtResult ESR = EvaluateStmt(Result, Info, Init, Case); 4500 if (ESR != ESR_CaseNotFound) { 4501 assert(ESR != ESR_Succeeded); 4502 return ESR; 4503 } 4504 } 4505 4506 // Condition variable must be initialized if it exists. 4507 // FIXME: We can skip evaluating the body if there's a condition 4508 // variable, as there can't be any case labels within it. 4509 // (The same is true for 'for' statements.) 4510 4511 EvalStmtResult ESR = EvaluateStmt(Result, Info, IS->getThen(), Case); 4512 if (ESR == ESR_Failed) 4513 return ESR; 4514 if (ESR != ESR_CaseNotFound) 4515 return Scope.destroy() ? ESR : ESR_Failed; 4516 if (!IS->getElse()) 4517 return ESR_CaseNotFound; 4518 4519 ESR = EvaluateStmt(Result, Info, IS->getElse(), Case); 4520 if (ESR == ESR_Failed) 4521 return ESR; 4522 if (ESR != ESR_CaseNotFound) 4523 return Scope.destroy() ? ESR : ESR_Failed; 4524 return ESR_CaseNotFound; 4525 } 4526 4527 case Stmt::WhileStmtClass: { 4528 EvalStmtResult ESR = 4529 EvaluateLoopBody(Result, Info, cast<WhileStmt>(S)->getBody(), Case); 4530 if (ESR != ESR_Continue) 4531 return ESR; 4532 break; 4533 } 4534 4535 case Stmt::ForStmtClass: { 4536 const ForStmt *FS = cast<ForStmt>(S); 4537 BlockScopeRAII Scope(Info); 4538 4539 // Step into the init statement in case it brings an (uninitialized) 4540 // variable into scope. 4541 if (const Stmt *Init = FS->getInit()) { 4542 EvalStmtResult ESR = EvaluateStmt(Result, Info, Init, Case); 4543 if (ESR != ESR_CaseNotFound) { 4544 assert(ESR != ESR_Succeeded); 4545 return ESR; 4546 } 4547 } 4548 4549 EvalStmtResult ESR = 4550 EvaluateLoopBody(Result, Info, FS->getBody(), Case); 4551 if (ESR != ESR_Continue) 4552 return ESR; 4553 if (FS->getInc()) { 4554 FullExpressionRAII IncScope(Info); 4555 if (!EvaluateIgnoredValue(Info, FS->getInc()) || !IncScope.destroy()) 4556 return ESR_Failed; 4557 } 4558 break; 4559 } 4560 4561 case Stmt::DeclStmtClass: { 4562 // Start the lifetime of any uninitialized variables we encounter. They 4563 // might be used by the selected branch of the switch. 4564 const DeclStmt *DS = cast<DeclStmt>(S); 4565 for (const auto *D : DS->decls()) { 4566 if (const auto *VD = dyn_cast<VarDecl>(D)) { 4567 if (VD->hasLocalStorage() && !VD->getInit()) 4568 if (!EvaluateVarDecl(Info, VD)) 4569 return ESR_Failed; 4570 // FIXME: If the variable has initialization that can't be jumped 4571 // over, bail out of any immediately-surrounding compound-statement 4572 // too. There can't be any case labels here. 4573 } 4574 } 4575 return ESR_CaseNotFound; 4576 } 4577 4578 default: 4579 return ESR_CaseNotFound; 4580 } 4581 } 4582 4583 switch (S->getStmtClass()) { 4584 default: 4585 if (const Expr *E = dyn_cast<Expr>(S)) { 4586 // Don't bother evaluating beyond an expression-statement which couldn't 4587 // be evaluated. 4588 // FIXME: Do we need the FullExpressionRAII object here? 4589 // VisitExprWithCleanups should create one when necessary. 4590 FullExpressionRAII Scope(Info); 4591 if (!EvaluateIgnoredValue(Info, E) || !Scope.destroy()) 4592 return ESR_Failed; 4593 return ESR_Succeeded; 4594 } 4595 4596 Info.FFDiag(S->getBeginLoc()); 4597 return ESR_Failed; 4598 4599 case Stmt::NullStmtClass: 4600 return ESR_Succeeded; 4601 4602 case Stmt::DeclStmtClass: { 4603 const DeclStmt *DS = cast<DeclStmt>(S); 4604 for (const auto *D : DS->decls()) { 4605 // Each declaration initialization is its own full-expression. 4606 FullExpressionRAII Scope(Info); 4607 if (!EvaluateDecl(Info, D) && !Info.noteFailure()) 4608 return ESR_Failed; 4609 if (!Scope.destroy()) 4610 return ESR_Failed; 4611 } 4612 return ESR_Succeeded; 4613 } 4614 4615 case Stmt::ReturnStmtClass: { 4616 const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue(); 4617 FullExpressionRAII Scope(Info); 4618 if (RetExpr && 4619 !(Result.Slot 4620 ? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr) 4621 : Evaluate(Result.Value, Info, RetExpr))) 4622 return ESR_Failed; 4623 return Scope.destroy() ? ESR_Returned : ESR_Failed; 4624 } 4625 4626 case Stmt::CompoundStmtClass: { 4627 BlockScopeRAII Scope(Info); 4628 4629 const CompoundStmt *CS = cast<CompoundStmt>(S); 4630 for (const auto *BI : CS->body()) { 4631 EvalStmtResult ESR = EvaluateStmt(Result, Info, BI, Case); 4632 if (ESR == ESR_Succeeded) 4633 Case = nullptr; 4634 else if (ESR != ESR_CaseNotFound) { 4635 if (ESR != ESR_Failed && !Scope.destroy()) 4636 return ESR_Failed; 4637 return ESR; 4638 } 4639 } 4640 if (Case) 4641 return ESR_CaseNotFound; 4642 return Scope.destroy() ? ESR_Succeeded : ESR_Failed; 4643 } 4644 4645 case Stmt::IfStmtClass: { 4646 const IfStmt *IS = cast<IfStmt>(S); 4647 4648 // Evaluate the condition, as either a var decl or as an expression. 4649 BlockScopeRAII Scope(Info); 4650 if (const Stmt *Init = IS->getInit()) { 4651 EvalStmtResult ESR = EvaluateStmt(Result, Info, Init); 4652 if (ESR != ESR_Succeeded) { 4653 if (ESR != ESR_Failed && !Scope.destroy()) 4654 return ESR_Failed; 4655 return ESR; 4656 } 4657 } 4658 bool Cond; 4659 if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond)) 4660 return ESR_Failed; 4661 4662 if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) { 4663 EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt); 4664 if (ESR != ESR_Succeeded) { 4665 if (ESR != ESR_Failed && !Scope.destroy()) 4666 return ESR_Failed; 4667 return ESR; 4668 } 4669 } 4670 return Scope.destroy() ? ESR_Succeeded : ESR_Failed; 4671 } 4672 4673 case Stmt::WhileStmtClass: { 4674 const WhileStmt *WS = cast<WhileStmt>(S); 4675 while (true) { 4676 BlockScopeRAII Scope(Info); 4677 bool Continue; 4678 if (!EvaluateCond(Info, WS->getConditionVariable(), WS->getCond(), 4679 Continue)) 4680 return ESR_Failed; 4681 if (!Continue) 4682 break; 4683 4684 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, WS->getBody()); 4685 if (ESR != ESR_Continue) { 4686 if (ESR != ESR_Failed && !Scope.destroy()) 4687 return ESR_Failed; 4688 return ESR; 4689 } 4690 if (!Scope.destroy()) 4691 return ESR_Failed; 4692 } 4693 return ESR_Succeeded; 4694 } 4695 4696 case Stmt::DoStmtClass: { 4697 const DoStmt *DS = cast<DoStmt>(S); 4698 bool Continue; 4699 do { 4700 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, DS->getBody(), Case); 4701 if (ESR != ESR_Continue) 4702 return ESR; 4703 Case = nullptr; 4704 4705 FullExpressionRAII CondScope(Info); 4706 if (!EvaluateAsBooleanCondition(DS->getCond(), Continue, Info) || 4707 !CondScope.destroy()) 4708 return ESR_Failed; 4709 } while (Continue); 4710 return ESR_Succeeded; 4711 } 4712 4713 case Stmt::ForStmtClass: { 4714 const ForStmt *FS = cast<ForStmt>(S); 4715 BlockScopeRAII ForScope(Info); 4716 if (FS->getInit()) { 4717 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit()); 4718 if (ESR != ESR_Succeeded) { 4719 if (ESR != ESR_Failed && !ForScope.destroy()) 4720 return ESR_Failed; 4721 return ESR; 4722 } 4723 } 4724 while (true) { 4725 BlockScopeRAII IterScope(Info); 4726 bool Continue = true; 4727 if (FS->getCond() && !EvaluateCond(Info, FS->getConditionVariable(), 4728 FS->getCond(), Continue)) 4729 return ESR_Failed; 4730 if (!Continue) 4731 break; 4732 4733 EvalStmtResult ESR = EvaluateLoopBody(Result, Info, FS->getBody()); 4734 if (ESR != ESR_Continue) { 4735 if (ESR != ESR_Failed && (!IterScope.destroy() || !ForScope.destroy())) 4736 return ESR_Failed; 4737 return ESR; 4738 } 4739 4740 if (FS->getInc()) { 4741 FullExpressionRAII IncScope(Info); 4742 if (!EvaluateIgnoredValue(Info, FS->getInc()) || !IncScope.destroy()) 4743 return ESR_Failed; 4744 } 4745 4746 if (!IterScope.destroy()) 4747 return ESR_Failed; 4748 } 4749 return ForScope.destroy() ? ESR_Succeeded : ESR_Failed; 4750 } 4751 4752 case Stmt::CXXForRangeStmtClass: { 4753 const CXXForRangeStmt *FS = cast<CXXForRangeStmt>(S); 4754 BlockScopeRAII Scope(Info); 4755 4756 // Evaluate the init-statement if present. 4757 if (FS->getInit()) { 4758 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit()); 4759 if (ESR != ESR_Succeeded) { 4760 if (ESR != ESR_Failed && !Scope.destroy()) 4761 return ESR_Failed; 4762 return ESR; 4763 } 4764 } 4765 4766 // Initialize the __range variable. 4767 EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getRangeStmt()); 4768 if (ESR != ESR_Succeeded) { 4769 if (ESR != ESR_Failed && !Scope.destroy()) 4770 return ESR_Failed; 4771 return ESR; 4772 } 4773 4774 // Create the __begin and __end iterators. 4775 ESR = EvaluateStmt(Result, Info, FS->getBeginStmt()); 4776 if (ESR != ESR_Succeeded) { 4777 if (ESR != ESR_Failed && !Scope.destroy()) 4778 return ESR_Failed; 4779 return ESR; 4780 } 4781 ESR = EvaluateStmt(Result, Info, FS->getEndStmt()); 4782 if (ESR != ESR_Succeeded) { 4783 if (ESR != ESR_Failed && !Scope.destroy()) 4784 return ESR_Failed; 4785 return ESR; 4786 } 4787 4788 while (true) { 4789 // Condition: __begin != __end. 4790 { 4791 bool Continue = true; 4792 FullExpressionRAII CondExpr(Info); 4793 if (!EvaluateAsBooleanCondition(FS->getCond(), Continue, Info)) 4794 return ESR_Failed; 4795 if (!Continue) 4796 break; 4797 } 4798 4799 // User's variable declaration, initialized by *__begin. 4800 BlockScopeRAII InnerScope(Info); 4801 ESR = EvaluateStmt(Result, Info, FS->getLoopVarStmt()); 4802 if (ESR != ESR_Succeeded) { 4803 if (ESR != ESR_Failed && (!InnerScope.destroy() || !Scope.destroy())) 4804 return ESR_Failed; 4805 return ESR; 4806 } 4807 4808 // Loop body. 4809 ESR = EvaluateLoopBody(Result, Info, FS->getBody()); 4810 if (ESR != ESR_Continue) { 4811 if (ESR != ESR_Failed && (!InnerScope.destroy() || !Scope.destroy())) 4812 return ESR_Failed; 4813 return ESR; 4814 } 4815 4816 // Increment: ++__begin 4817 if (!EvaluateIgnoredValue(Info, FS->getInc())) 4818 return ESR_Failed; 4819 4820 if (!InnerScope.destroy()) 4821 return ESR_Failed; 4822 } 4823 4824 return Scope.destroy() ? ESR_Succeeded : ESR_Failed; 4825 } 4826 4827 case Stmt::SwitchStmtClass: 4828 return EvaluateSwitch(Result, Info, cast<SwitchStmt>(S)); 4829 4830 case Stmt::ContinueStmtClass: 4831 return ESR_Continue; 4832 4833 case Stmt::BreakStmtClass: 4834 return ESR_Break; 4835 4836 case Stmt::LabelStmtClass: 4837 return EvaluateStmt(Result, Info, cast<LabelStmt>(S)->getSubStmt(), Case); 4838 4839 case Stmt::AttributedStmtClass: 4840 // As a general principle, C++11 attributes can be ignored without 4841 // any semantic impact. 4842 return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(), 4843 Case); 4844 4845 case Stmt::CaseStmtClass: 4846 case Stmt::DefaultStmtClass: 4847 return EvaluateStmt(Result, Info, cast<SwitchCase>(S)->getSubStmt(), Case); 4848 case Stmt::CXXTryStmtClass: 4849 // Evaluate try blocks by evaluating all sub statements. 4850 return EvaluateStmt(Result, Info, cast<CXXTryStmt>(S)->getTryBlock(), Case); 4851 } 4852 } 4853 4854 /// CheckTrivialDefaultConstructor - Check whether a constructor is a trivial 4855 /// default constructor. If so, we'll fold it whether or not it's marked as 4856 /// constexpr. If it is marked as constexpr, we will never implicitly define it, 4857 /// so we need special handling. 4858 static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc, 4859 const CXXConstructorDecl *CD, 4860 bool IsValueInitialization) { 4861 if (!CD->isTrivial() || !CD->isDefaultConstructor()) 4862 return false; 4863 4864 // Value-initialization does not call a trivial default constructor, so such a 4865 // call is a core constant expression whether or not the constructor is 4866 // constexpr. 4867 if (!CD->isConstexpr() && !IsValueInitialization) { 4868 if (Info.getLangOpts().CPlusPlus11) { 4869 // FIXME: If DiagDecl is an implicitly-declared special member function, 4870 // we should be much more explicit about why it's not constexpr. 4871 Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1) 4872 << /*IsConstexpr*/0 << /*IsConstructor*/1 << CD; 4873 Info.Note(CD->getLocation(), diag::note_declared_at); 4874 } else { 4875 Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr); 4876 } 4877 } 4878 return true; 4879 } 4880 4881 /// CheckConstexprFunction - Check that a function can be called in a constant 4882 /// expression. 4883 static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc, 4884 const FunctionDecl *Declaration, 4885 const FunctionDecl *Definition, 4886 const Stmt *Body) { 4887 // Potential constant expressions can contain calls to declared, but not yet 4888 // defined, constexpr functions. 4889 if (Info.checkingPotentialConstantExpression() && !Definition && 4890 Declaration->isConstexpr()) 4891 return false; 4892 4893 // Bail out if the function declaration itself is invalid. We will 4894 // have produced a relevant diagnostic while parsing it, so just 4895 // note the problematic sub-expression. 4896 if (Declaration->isInvalidDecl()) { 4897 Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr); 4898 return false; 4899 } 4900 4901 // DR1872: An instantiated virtual constexpr function can't be called in a 4902 // constant expression (prior to C++20). We can still constant-fold such a 4903 // call. 4904 if (!Info.Ctx.getLangOpts().CPlusPlus2a && isa<CXXMethodDecl>(Declaration) && 4905 cast<CXXMethodDecl>(Declaration)->isVirtual()) 4906 Info.CCEDiag(CallLoc, diag::note_constexpr_virtual_call); 4907 4908 if (Definition && Definition->isInvalidDecl()) { 4909 Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr); 4910 return false; 4911 } 4912 4913 // Can we evaluate this function call? 4914 if (Definition && Definition->isConstexpr() && Body) 4915 return true; 4916 4917 if (Info.getLangOpts().CPlusPlus11) { 4918 const FunctionDecl *DiagDecl = Definition ? Definition : Declaration; 4919 4920 // If this function is not constexpr because it is an inherited 4921 // non-constexpr constructor, diagnose that directly. 4922 auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl); 4923 if (CD && CD->isInheritingConstructor()) { 4924 auto *Inherited = CD->getInheritedConstructor().getConstructor(); 4925 if (!Inherited->isConstexpr()) 4926 DiagDecl = CD = Inherited; 4927 } 4928 4929 // FIXME: If DiagDecl is an implicitly-declared special member function 4930 // or an inheriting constructor, we should be much more explicit about why 4931 // it's not constexpr. 4932 if (CD && CD->isInheritingConstructor()) 4933 Info.FFDiag(CallLoc, diag::note_constexpr_invalid_inhctor, 1) 4934 << CD->getInheritedConstructor().getConstructor()->getParent(); 4935 else 4936 Info.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1) 4937 << DiagDecl->isConstexpr() << (bool)CD << DiagDecl; 4938 Info.Note(DiagDecl->getLocation(), diag::note_declared_at); 4939 } else { 4940 Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr); 4941 } 4942 return false; 4943 } 4944 4945 namespace { 4946 struct CheckDynamicTypeHandler { 4947 AccessKinds AccessKind; 4948 typedef bool result_type; 4949 bool failed() { return false; } 4950 bool found(APValue &Subobj, QualType SubobjType) { return true; } 4951 bool found(APSInt &Value, QualType SubobjType) { return true; } 4952 bool found(APFloat &Value, QualType SubobjType) { return true; } 4953 }; 4954 } // end anonymous namespace 4955 4956 /// Check that we can access the notional vptr of an object / determine its 4957 /// dynamic type. 4958 static bool checkDynamicType(EvalInfo &Info, const Expr *E, const LValue &This, 4959 AccessKinds AK, bool Polymorphic) { 4960 if (This.Designator.Invalid) 4961 return false; 4962 4963 CompleteObject Obj = findCompleteObject(Info, E, AK, This, QualType()); 4964 4965 if (!Obj) 4966 return false; 4967 4968 if (!Obj.Value) { 4969 // The object is not usable in constant expressions, so we can't inspect 4970 // its value to see if it's in-lifetime or what the active union members 4971 // are. We can still check for a one-past-the-end lvalue. 4972 if (This.Designator.isOnePastTheEnd() || 4973 This.Designator.isMostDerivedAnUnsizedArray()) { 4974 Info.FFDiag(E, This.Designator.isOnePastTheEnd() 4975 ? diag::note_constexpr_access_past_end 4976 : diag::note_constexpr_access_unsized_array) 4977 << AK; 4978 return false; 4979 } else if (Polymorphic) { 4980 // Conservatively refuse to perform a polymorphic operation if we would 4981 // not be able to read a notional 'vptr' value. 4982 APValue Val; 4983 This.moveInto(Val); 4984 QualType StarThisType = 4985 Info.Ctx.getLValueReferenceType(This.Designator.getType(Info.Ctx)); 4986 Info.FFDiag(E, diag::note_constexpr_polymorphic_unknown_dynamic_type) 4987 << AK << Val.getAsString(Info.Ctx, StarThisType); 4988 return false; 4989 } 4990 return true; 4991 } 4992 4993 CheckDynamicTypeHandler Handler{AK}; 4994 return Obj && findSubobject(Info, E, Obj, This.Designator, Handler); 4995 } 4996 4997 /// Check that the pointee of the 'this' pointer in a member function call is 4998 /// either within its lifetime or in its period of construction or destruction. 4999 static bool 5000 checkNonVirtualMemberCallThisPointer(EvalInfo &Info, const Expr *E, 5001 const LValue &This, 5002 const CXXMethodDecl *NamedMember) { 5003 return checkDynamicType( 5004 Info, E, This, 5005 isa<CXXDestructorDecl>(NamedMember) ? AK_Destroy : AK_MemberCall, false); 5006 } 5007 5008 struct DynamicType { 5009 /// The dynamic class type of the object. 5010 const CXXRecordDecl *Type; 5011 /// The corresponding path length in the lvalue. 5012 unsigned PathLength; 5013 }; 5014 5015 static const CXXRecordDecl *getBaseClassType(SubobjectDesignator &Designator, 5016 unsigned PathLength) { 5017 assert(PathLength >= Designator.MostDerivedPathLength && PathLength <= 5018 Designator.Entries.size() && "invalid path length"); 5019 return (PathLength == Designator.MostDerivedPathLength) 5020 ? Designator.MostDerivedType->getAsCXXRecordDecl() 5021 : getAsBaseClass(Designator.Entries[PathLength - 1]); 5022 } 5023 5024 /// Determine the dynamic type of an object. 5025 static Optional<DynamicType> ComputeDynamicType(EvalInfo &Info, const Expr *E, 5026 LValue &This, AccessKinds AK) { 5027 // If we don't have an lvalue denoting an object of class type, there is no 5028 // meaningful dynamic type. (We consider objects of non-class type to have no 5029 // dynamic type.) 5030 if (!checkDynamicType(Info, E, This, AK, true)) 5031 return None; 5032 5033 // Refuse to compute a dynamic type in the presence of virtual bases. This 5034 // shouldn't happen other than in constant-folding situations, since literal 5035 // types can't have virtual bases. 5036 // 5037 // Note that consumers of DynamicType assume that the type has no virtual 5038 // bases, and will need modifications if this restriction is relaxed. 5039 const CXXRecordDecl *Class = 5040 This.Designator.MostDerivedType->getAsCXXRecordDecl(); 5041 if (!Class || Class->getNumVBases()) { 5042 Info.FFDiag(E); 5043 return None; 5044 } 5045 5046 // FIXME: For very deep class hierarchies, it might be beneficial to use a 5047 // binary search here instead. But the overwhelmingly common case is that 5048 // we're not in the middle of a constructor, so it probably doesn't matter 5049 // in practice. 5050 ArrayRef<APValue::LValuePathEntry> Path = This.Designator.Entries; 5051 for (unsigned PathLength = This.Designator.MostDerivedPathLength; 5052 PathLength <= Path.size(); ++PathLength) { 5053 switch (Info.isEvaluatingCtorDtor(This.getLValueBase(), 5054 Path.slice(0, PathLength))) { 5055 case ConstructionPhase::Bases: 5056 case ConstructionPhase::DestroyingBases: 5057 // We're constructing or destroying a base class. This is not the dynamic 5058 // type. 5059 break; 5060 5061 case ConstructionPhase::None: 5062 case ConstructionPhase::AfterBases: 5063 case ConstructionPhase::Destroying: 5064 // We've finished constructing the base classes and not yet started 5065 // destroying them again, so this is the dynamic type. 5066 return DynamicType{getBaseClassType(This.Designator, PathLength), 5067 PathLength}; 5068 } 5069 } 5070 5071 // CWG issue 1517: we're constructing a base class of the object described by 5072 // 'This', so that object has not yet begun its period of construction and 5073 // any polymorphic operation on it results in undefined behavior. 5074 Info.FFDiag(E); 5075 return None; 5076 } 5077 5078 /// Perform virtual dispatch. 5079 static const CXXMethodDecl *HandleVirtualDispatch( 5080 EvalInfo &Info, const Expr *E, LValue &This, const CXXMethodDecl *Found, 5081 llvm::SmallVectorImpl<QualType> &CovariantAdjustmentPath) { 5082 Optional<DynamicType> DynType = ComputeDynamicType( 5083 Info, E, This, 5084 isa<CXXDestructorDecl>(Found) ? AK_Destroy : AK_MemberCall); 5085 if (!DynType) 5086 return nullptr; 5087 5088 // Find the final overrider. It must be declared in one of the classes on the 5089 // path from the dynamic type to the static type. 5090 // FIXME: If we ever allow literal types to have virtual base classes, that 5091 // won't be true. 5092 const CXXMethodDecl *Callee = Found; 5093 unsigned PathLength = DynType->PathLength; 5094 for (/**/; PathLength <= This.Designator.Entries.size(); ++PathLength) { 5095 const CXXRecordDecl *Class = getBaseClassType(This.Designator, PathLength); 5096 const CXXMethodDecl *Overrider = 5097 Found->getCorrespondingMethodDeclaredInClass(Class, false); 5098 if (Overrider) { 5099 Callee = Overrider; 5100 break; 5101 } 5102 } 5103 5104 // C++2a [class.abstract]p6: 5105 // the effect of making a virtual call to a pure virtual function [...] is 5106 // undefined 5107 if (Callee->isPure()) { 5108 Info.FFDiag(E, diag::note_constexpr_pure_virtual_call, 1) << Callee; 5109 Info.Note(Callee->getLocation(), diag::note_declared_at); 5110 return nullptr; 5111 } 5112 5113 // If necessary, walk the rest of the path to determine the sequence of 5114 // covariant adjustment steps to apply. 5115 if (!Info.Ctx.hasSameUnqualifiedType(Callee->getReturnType(), 5116 Found->getReturnType())) { 5117 CovariantAdjustmentPath.push_back(Callee->getReturnType()); 5118 for (unsigned CovariantPathLength = PathLength + 1; 5119 CovariantPathLength != This.Designator.Entries.size(); 5120 ++CovariantPathLength) { 5121 const CXXRecordDecl *NextClass = 5122 getBaseClassType(This.Designator, CovariantPathLength); 5123 const CXXMethodDecl *Next = 5124 Found->getCorrespondingMethodDeclaredInClass(NextClass, false); 5125 if (Next && !Info.Ctx.hasSameUnqualifiedType( 5126 Next->getReturnType(), CovariantAdjustmentPath.back())) 5127 CovariantAdjustmentPath.push_back(Next->getReturnType()); 5128 } 5129 if (!Info.Ctx.hasSameUnqualifiedType(Found->getReturnType(), 5130 CovariantAdjustmentPath.back())) 5131 CovariantAdjustmentPath.push_back(Found->getReturnType()); 5132 } 5133 5134 // Perform 'this' adjustment. 5135 if (!CastToDerivedClass(Info, E, This, Callee->getParent(), PathLength)) 5136 return nullptr; 5137 5138 return Callee; 5139 } 5140 5141 /// Perform the adjustment from a value returned by a virtual function to 5142 /// a value of the statically expected type, which may be a pointer or 5143 /// reference to a base class of the returned type. 5144 static bool HandleCovariantReturnAdjustment(EvalInfo &Info, const Expr *E, 5145 APValue &Result, 5146 ArrayRef<QualType> Path) { 5147 assert(Result.isLValue() && 5148 "unexpected kind of APValue for covariant return"); 5149 if (Result.isNullPointer()) 5150 return true; 5151 5152 LValue LVal; 5153 LVal.setFrom(Info.Ctx, Result); 5154 5155 const CXXRecordDecl *OldClass = Path[0]->getPointeeCXXRecordDecl(); 5156 for (unsigned I = 1; I != Path.size(); ++I) { 5157 const CXXRecordDecl *NewClass = Path[I]->getPointeeCXXRecordDecl(); 5158 assert(OldClass && NewClass && "unexpected kind of covariant return"); 5159 if (OldClass != NewClass && 5160 !CastToBaseClass(Info, E, LVal, OldClass, NewClass)) 5161 return false; 5162 OldClass = NewClass; 5163 } 5164 5165 LVal.moveInto(Result); 5166 return true; 5167 } 5168 5169 /// Determine whether \p Base, which is known to be a direct base class of 5170 /// \p Derived, is a public base class. 5171 static bool isBaseClassPublic(const CXXRecordDecl *Derived, 5172 const CXXRecordDecl *Base) { 5173 for (const CXXBaseSpecifier &BaseSpec : Derived->bases()) { 5174 auto *BaseClass = BaseSpec.getType()->getAsCXXRecordDecl(); 5175 if (BaseClass && declaresSameEntity(BaseClass, Base)) 5176 return BaseSpec.getAccessSpecifier() == AS_public; 5177 } 5178 llvm_unreachable("Base is not a direct base of Derived"); 5179 } 5180 5181 /// Apply the given dynamic cast operation on the provided lvalue. 5182 /// 5183 /// This implements the hard case of dynamic_cast, requiring a "runtime check" 5184 /// to find a suitable target subobject. 5185 static bool HandleDynamicCast(EvalInfo &Info, const ExplicitCastExpr *E, 5186 LValue &Ptr) { 5187 // We can't do anything with a non-symbolic pointer value. 5188 SubobjectDesignator &D = Ptr.Designator; 5189 if (D.Invalid) 5190 return false; 5191 5192 // C++ [expr.dynamic.cast]p6: 5193 // If v is a null pointer value, the result is a null pointer value. 5194 if (Ptr.isNullPointer() && !E->isGLValue()) 5195 return true; 5196 5197 // For all the other cases, we need the pointer to point to an object within 5198 // its lifetime / period of construction / destruction, and we need to know 5199 // its dynamic type. 5200 Optional<DynamicType> DynType = 5201 ComputeDynamicType(Info, E, Ptr, AK_DynamicCast); 5202 if (!DynType) 5203 return false; 5204 5205 // C++ [expr.dynamic.cast]p7: 5206 // If T is "pointer to cv void", then the result is a pointer to the most 5207 // derived object 5208 if (E->getType()->isVoidPointerType()) 5209 return CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength); 5210 5211 const CXXRecordDecl *C = E->getTypeAsWritten()->getPointeeCXXRecordDecl(); 5212 assert(C && "dynamic_cast target is not void pointer nor class"); 5213 CanQualType CQT = Info.Ctx.getCanonicalType(Info.Ctx.getRecordType(C)); 5214 5215 auto RuntimeCheckFailed = [&] (CXXBasePaths *Paths) { 5216 // C++ [expr.dynamic.cast]p9: 5217 if (!E->isGLValue()) { 5218 // The value of a failed cast to pointer type is the null pointer value 5219 // of the required result type. 5220 Ptr.setNull(Info.Ctx, E->getType()); 5221 return true; 5222 } 5223 5224 // A failed cast to reference type throws [...] std::bad_cast. 5225 unsigned DiagKind; 5226 if (!Paths && (declaresSameEntity(DynType->Type, C) || 5227 DynType->Type->isDerivedFrom(C))) 5228 DiagKind = 0; 5229 else if (!Paths || Paths->begin() == Paths->end()) 5230 DiagKind = 1; 5231 else if (Paths->isAmbiguous(CQT)) 5232 DiagKind = 2; 5233 else { 5234 assert(Paths->front().Access != AS_public && "why did the cast fail?"); 5235 DiagKind = 3; 5236 } 5237 Info.FFDiag(E, diag::note_constexpr_dynamic_cast_to_reference_failed) 5238 << DiagKind << Ptr.Designator.getType(Info.Ctx) 5239 << Info.Ctx.getRecordType(DynType->Type) 5240 << E->getType().getUnqualifiedType(); 5241 return false; 5242 }; 5243 5244 // Runtime check, phase 1: 5245 // Walk from the base subobject towards the derived object looking for the 5246 // target type. 5247 for (int PathLength = Ptr.Designator.Entries.size(); 5248 PathLength >= (int)DynType->PathLength; --PathLength) { 5249 const CXXRecordDecl *Class = getBaseClassType(Ptr.Designator, PathLength); 5250 if (declaresSameEntity(Class, C)) 5251 return CastToDerivedClass(Info, E, Ptr, Class, PathLength); 5252 // We can only walk across public inheritance edges. 5253 if (PathLength > (int)DynType->PathLength && 5254 !isBaseClassPublic(getBaseClassType(Ptr.Designator, PathLength - 1), 5255 Class)) 5256 return RuntimeCheckFailed(nullptr); 5257 } 5258 5259 // Runtime check, phase 2: 5260 // Search the dynamic type for an unambiguous public base of type C. 5261 CXXBasePaths Paths(/*FindAmbiguities=*/true, 5262 /*RecordPaths=*/true, /*DetectVirtual=*/false); 5263 if (DynType->Type->isDerivedFrom(C, Paths) && !Paths.isAmbiguous(CQT) && 5264 Paths.front().Access == AS_public) { 5265 // Downcast to the dynamic type... 5266 if (!CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength)) 5267 return false; 5268 // ... then upcast to the chosen base class subobject. 5269 for (CXXBasePathElement &Elem : Paths.front()) 5270 if (!HandleLValueBase(Info, E, Ptr, Elem.Class, Elem.Base)) 5271 return false; 5272 return true; 5273 } 5274 5275 // Otherwise, the runtime check fails. 5276 return RuntimeCheckFailed(&Paths); 5277 } 5278 5279 namespace { 5280 struct StartLifetimeOfUnionMemberHandler { 5281 const FieldDecl *Field; 5282 5283 static const AccessKinds AccessKind = AK_Assign; 5284 5285 typedef bool result_type; 5286 bool failed() { return false; } 5287 bool found(APValue &Subobj, QualType SubobjType) { 5288 // We are supposed to perform no initialization but begin the lifetime of 5289 // the object. We interpret that as meaning to do what default 5290 // initialization of the object would do if all constructors involved were 5291 // trivial: 5292 // * All base, non-variant member, and array element subobjects' lifetimes 5293 // begin 5294 // * No variant members' lifetimes begin 5295 // * All scalar subobjects whose lifetimes begin have indeterminate values 5296 assert(SubobjType->isUnionType()); 5297 if (!declaresSameEntity(Subobj.getUnionField(), Field) || 5298 !Subobj.getUnionValue().hasValue()) 5299 Subobj.setUnion(Field, getDefaultInitValue(Field->getType())); 5300 return true; 5301 } 5302 bool found(APSInt &Value, QualType SubobjType) { 5303 llvm_unreachable("wrong value kind for union object"); 5304 } 5305 bool found(APFloat &Value, QualType SubobjType) { 5306 llvm_unreachable("wrong value kind for union object"); 5307 } 5308 }; 5309 } // end anonymous namespace 5310 5311 const AccessKinds StartLifetimeOfUnionMemberHandler::AccessKind; 5312 5313 /// Handle a builtin simple-assignment or a call to a trivial assignment 5314 /// operator whose left-hand side might involve a union member access. If it 5315 /// does, implicitly start the lifetime of any accessed union elements per 5316 /// C++20 [class.union]5. 5317 static bool HandleUnionActiveMemberChange(EvalInfo &Info, const Expr *LHSExpr, 5318 const LValue &LHS) { 5319 if (LHS.InvalidBase || LHS.Designator.Invalid) 5320 return false; 5321 5322 llvm::SmallVector<std::pair<unsigned, const FieldDecl*>, 4> UnionPathLengths; 5323 // C++ [class.union]p5: 5324 // define the set S(E) of subexpressions of E as follows: 5325 unsigned PathLength = LHS.Designator.Entries.size(); 5326 for (const Expr *E = LHSExpr; E != nullptr;) { 5327 // -- If E is of the form A.B, S(E) contains the elements of S(A)... 5328 if (auto *ME = dyn_cast<MemberExpr>(E)) { 5329 auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()); 5330 // Note that we can't implicitly start the lifetime of a reference, 5331 // so we don't need to proceed any further if we reach one. 5332 if (!FD || FD->getType()->isReferenceType()) 5333 break; 5334 5335 // ... and also contains A.B if B names a union member ... 5336 if (FD->getParent()->isUnion()) { 5337 // ... of a non-class, non-array type, or of a class type with a 5338 // trivial default constructor that is not deleted, or an array of 5339 // such types. 5340 auto *RD = 5341 FD->getType()->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 5342 if (!RD || RD->hasTrivialDefaultConstructor()) 5343 UnionPathLengths.push_back({PathLength - 1, FD}); 5344 } 5345 5346 E = ME->getBase(); 5347 --PathLength; 5348 assert(declaresSameEntity(FD, 5349 LHS.Designator.Entries[PathLength] 5350 .getAsBaseOrMember().getPointer())); 5351 5352 // -- If E is of the form A[B] and is interpreted as a built-in array 5353 // subscripting operator, S(E) is [S(the array operand, if any)]. 5354 } else if (auto *ASE = dyn_cast<ArraySubscriptExpr>(E)) { 5355 // Step over an ArrayToPointerDecay implicit cast. 5356 auto *Base = ASE->getBase()->IgnoreImplicit(); 5357 if (!Base->getType()->isArrayType()) 5358 break; 5359 5360 E = Base; 5361 --PathLength; 5362 5363 } else if (auto *ICE = dyn_cast<ImplicitCastExpr>(E)) { 5364 // Step over a derived-to-base conversion. 5365 E = ICE->getSubExpr(); 5366 if (ICE->getCastKind() == CK_NoOp) 5367 continue; 5368 if (ICE->getCastKind() != CK_DerivedToBase && 5369 ICE->getCastKind() != CK_UncheckedDerivedToBase) 5370 break; 5371 // Walk path backwards as we walk up from the base to the derived class. 5372 for (const CXXBaseSpecifier *Elt : llvm::reverse(ICE->path())) { 5373 --PathLength; 5374 (void)Elt; 5375 assert(declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(), 5376 LHS.Designator.Entries[PathLength] 5377 .getAsBaseOrMember().getPointer())); 5378 } 5379 5380 // -- Otherwise, S(E) is empty. 5381 } else { 5382 break; 5383 } 5384 } 5385 5386 // Common case: no unions' lifetimes are started. 5387 if (UnionPathLengths.empty()) 5388 return true; 5389 5390 // if modification of X [would access an inactive union member], an object 5391 // of the type of X is implicitly created 5392 CompleteObject Obj = 5393 findCompleteObject(Info, LHSExpr, AK_Assign, LHS, LHSExpr->getType()); 5394 if (!Obj) 5395 return false; 5396 for (std::pair<unsigned, const FieldDecl *> LengthAndField : 5397 llvm::reverse(UnionPathLengths)) { 5398 // Form a designator for the union object. 5399 SubobjectDesignator D = LHS.Designator; 5400 D.truncate(Info.Ctx, LHS.Base, LengthAndField.first); 5401 5402 StartLifetimeOfUnionMemberHandler StartLifetime{LengthAndField.second}; 5403 if (!findSubobject(Info, LHSExpr, Obj, D, StartLifetime)) 5404 return false; 5405 } 5406 5407 return true; 5408 } 5409 5410 /// Determine if a class has any fields that might need to be copied by a 5411 /// trivial copy or move operation. 5412 static bool hasFields(const CXXRecordDecl *RD) { 5413 if (!RD || RD->isEmpty()) 5414 return false; 5415 for (auto *FD : RD->fields()) { 5416 if (FD->isUnnamedBitfield()) 5417 continue; 5418 return true; 5419 } 5420 for (auto &Base : RD->bases()) 5421 if (hasFields(Base.getType()->getAsCXXRecordDecl())) 5422 return true; 5423 return false; 5424 } 5425 5426 namespace { 5427 typedef SmallVector<APValue, 8> ArgVector; 5428 } 5429 5430 /// EvaluateArgs - Evaluate the arguments to a function call. 5431 static bool EvaluateArgs(ArrayRef<const Expr *> Args, ArgVector &ArgValues, 5432 EvalInfo &Info, const FunctionDecl *Callee) { 5433 bool Success = true; 5434 llvm::SmallBitVector ForbiddenNullArgs; 5435 if (Callee->hasAttr<NonNullAttr>()) { 5436 ForbiddenNullArgs.resize(Args.size()); 5437 for (const auto *Attr : Callee->specific_attrs<NonNullAttr>()) { 5438 if (!Attr->args_size()) { 5439 ForbiddenNullArgs.set(); 5440 break; 5441 } else 5442 for (auto Idx : Attr->args()) { 5443 unsigned ASTIdx = Idx.getASTIndex(); 5444 if (ASTIdx >= Args.size()) 5445 continue; 5446 ForbiddenNullArgs[ASTIdx] = 1; 5447 } 5448 } 5449 } 5450 for (unsigned Idx = 0; Idx < Args.size(); Idx++) { 5451 if (!Evaluate(ArgValues[Idx], Info, Args[Idx])) { 5452 // If we're checking for a potential constant expression, evaluate all 5453 // initializers even if some of them fail. 5454 if (!Info.noteFailure()) 5455 return false; 5456 Success = false; 5457 } else if (!ForbiddenNullArgs.empty() && 5458 ForbiddenNullArgs[Idx] && 5459 ArgValues[Idx].isLValue() && 5460 ArgValues[Idx].isNullPointer()) { 5461 Info.CCEDiag(Args[Idx], diag::note_non_null_attribute_failed); 5462 if (!Info.noteFailure()) 5463 return false; 5464 Success = false; 5465 } 5466 } 5467 return Success; 5468 } 5469 5470 /// Evaluate a function call. 5471 static bool HandleFunctionCall(SourceLocation CallLoc, 5472 const FunctionDecl *Callee, const LValue *This, 5473 ArrayRef<const Expr*> Args, const Stmt *Body, 5474 EvalInfo &Info, APValue &Result, 5475 const LValue *ResultSlot) { 5476 ArgVector ArgValues(Args.size()); 5477 if (!EvaluateArgs(Args, ArgValues, Info, Callee)) 5478 return false; 5479 5480 if (!Info.CheckCallLimit(CallLoc)) 5481 return false; 5482 5483 CallStackFrame Frame(Info, CallLoc, Callee, This, ArgValues.data()); 5484 5485 // For a trivial copy or move assignment, perform an APValue copy. This is 5486 // essential for unions, where the operations performed by the assignment 5487 // operator cannot be represented as statements. 5488 // 5489 // Skip this for non-union classes with no fields; in that case, the defaulted 5490 // copy/move does not actually read the object. 5491 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee); 5492 if (MD && MD->isDefaulted() && 5493 (MD->getParent()->isUnion() || 5494 (MD->isTrivial() && hasFields(MD->getParent())))) { 5495 assert(This && 5496 (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator())); 5497 LValue RHS; 5498 RHS.setFrom(Info.Ctx, ArgValues[0]); 5499 APValue RHSValue; 5500 if (!handleLValueToRValueConversion(Info, Args[0], Args[0]->getType(), RHS, 5501 RHSValue, MD->getParent()->isUnion())) 5502 return false; 5503 if (Info.getLangOpts().CPlusPlus2a && MD->isTrivial() && 5504 !HandleUnionActiveMemberChange(Info, Args[0], *This)) 5505 return false; 5506 if (!handleAssignment(Info, Args[0], *This, MD->getThisType(), 5507 RHSValue)) 5508 return false; 5509 This->moveInto(Result); 5510 return true; 5511 } else if (MD && isLambdaCallOperator(MD)) { 5512 // We're in a lambda; determine the lambda capture field maps unless we're 5513 // just constexpr checking a lambda's call operator. constexpr checking is 5514 // done before the captures have been added to the closure object (unless 5515 // we're inferring constexpr-ness), so we don't have access to them in this 5516 // case. But since we don't need the captures to constexpr check, we can 5517 // just ignore them. 5518 if (!Info.checkingPotentialConstantExpression()) 5519 MD->getParent()->getCaptureFields(Frame.LambdaCaptureFields, 5520 Frame.LambdaThisCaptureField); 5521 } 5522 5523 StmtResult Ret = {Result, ResultSlot}; 5524 EvalStmtResult ESR = EvaluateStmt(Ret, Info, Body); 5525 if (ESR == ESR_Succeeded) { 5526 if (Callee->getReturnType()->isVoidType()) 5527 return true; 5528 Info.FFDiag(Callee->getEndLoc(), diag::note_constexpr_no_return); 5529 } 5530 return ESR == ESR_Returned; 5531 } 5532 5533 /// Evaluate a constructor call. 5534 static bool HandleConstructorCall(const Expr *E, const LValue &This, 5535 APValue *ArgValues, 5536 const CXXConstructorDecl *Definition, 5537 EvalInfo &Info, APValue &Result) { 5538 SourceLocation CallLoc = E->getExprLoc(); 5539 if (!Info.CheckCallLimit(CallLoc)) 5540 return false; 5541 5542 const CXXRecordDecl *RD = Definition->getParent(); 5543 if (RD->getNumVBases()) { 5544 Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD; 5545 return false; 5546 } 5547 5548 EvalInfo::EvaluatingConstructorRAII EvalObj( 5549 Info, 5550 ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries}, 5551 RD->getNumBases()); 5552 CallStackFrame Frame(Info, CallLoc, Definition, &This, ArgValues); 5553 5554 // FIXME: Creating an APValue just to hold a nonexistent return value is 5555 // wasteful. 5556 APValue RetVal; 5557 StmtResult Ret = {RetVal, nullptr}; 5558 5559 // If it's a delegating constructor, delegate. 5560 if (Definition->isDelegatingConstructor()) { 5561 CXXConstructorDecl::init_const_iterator I = Definition->init_begin(); 5562 { 5563 FullExpressionRAII InitScope(Info); 5564 if (!EvaluateInPlace(Result, Info, This, (*I)->getInit()) || 5565 !InitScope.destroy()) 5566 return false; 5567 } 5568 return EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed; 5569 } 5570 5571 // For a trivial copy or move constructor, perform an APValue copy. This is 5572 // essential for unions (or classes with anonymous union members), where the 5573 // operations performed by the constructor cannot be represented by 5574 // ctor-initializers. 5575 // 5576 // Skip this for empty non-union classes; we should not perform an 5577 // lvalue-to-rvalue conversion on them because their copy constructor does not 5578 // actually read them. 5579 if (Definition->isDefaulted() && Definition->isCopyOrMoveConstructor() && 5580 (Definition->getParent()->isUnion() || 5581 (Definition->isTrivial() && hasFields(Definition->getParent())))) { 5582 LValue RHS; 5583 RHS.setFrom(Info.Ctx, ArgValues[0]); 5584 return handleLValueToRValueConversion( 5585 Info, E, Definition->getParamDecl(0)->getType().getNonReferenceType(), 5586 RHS, Result, Definition->getParent()->isUnion()); 5587 } 5588 5589 // Reserve space for the struct members. 5590 if (!RD->isUnion() && !Result.hasValue()) 5591 Result = APValue(APValue::UninitStruct(), RD->getNumBases(), 5592 std::distance(RD->field_begin(), RD->field_end())); 5593 5594 if (RD->isInvalidDecl()) return false; 5595 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 5596 5597 // A scope for temporaries lifetime-extended by reference members. 5598 BlockScopeRAII LifetimeExtendedScope(Info); 5599 5600 bool Success = true; 5601 unsigned BasesSeen = 0; 5602 #ifndef NDEBUG 5603 CXXRecordDecl::base_class_const_iterator BaseIt = RD->bases_begin(); 5604 #endif 5605 CXXRecordDecl::field_iterator FieldIt = RD->field_begin(); 5606 auto SkipToField = [&](FieldDecl *FD, bool Indirect) { 5607 // We might be initializing the same field again if this is an indirect 5608 // field initialization. 5609 if (FieldIt == RD->field_end() || 5610 FieldIt->getFieldIndex() > FD->getFieldIndex()) { 5611 assert(Indirect && "fields out of order?"); 5612 return; 5613 } 5614 5615 // Default-initialize any fields with no explicit initializer. 5616 for (; !declaresSameEntity(*FieldIt, FD); ++FieldIt) { 5617 assert(FieldIt != RD->field_end() && "missing field?"); 5618 if (!FieldIt->isUnnamedBitfield()) 5619 Result.getStructField(FieldIt->getFieldIndex()) = 5620 getDefaultInitValue(FieldIt->getType()); 5621 } 5622 ++FieldIt; 5623 }; 5624 for (const auto *I : Definition->inits()) { 5625 LValue Subobject = This; 5626 LValue SubobjectParent = This; 5627 APValue *Value = &Result; 5628 5629 // Determine the subobject to initialize. 5630 FieldDecl *FD = nullptr; 5631 if (I->isBaseInitializer()) { 5632 QualType BaseType(I->getBaseClass(), 0); 5633 #ifndef NDEBUG 5634 // Non-virtual base classes are initialized in the order in the class 5635 // definition. We have already checked for virtual base classes. 5636 assert(!BaseIt->isVirtual() && "virtual base for literal type"); 5637 assert(Info.Ctx.hasSameType(BaseIt->getType(), BaseType) && 5638 "base class initializers not in expected order"); 5639 ++BaseIt; 5640 #endif 5641 if (!HandleLValueDirectBase(Info, I->getInit(), Subobject, RD, 5642 BaseType->getAsCXXRecordDecl(), &Layout)) 5643 return false; 5644 Value = &Result.getStructBase(BasesSeen++); 5645 } else if ((FD = I->getMember())) { 5646 if (!HandleLValueMember(Info, I->getInit(), Subobject, FD, &Layout)) 5647 return false; 5648 if (RD->isUnion()) { 5649 Result = APValue(FD); 5650 Value = &Result.getUnionValue(); 5651 } else { 5652 SkipToField(FD, false); 5653 Value = &Result.getStructField(FD->getFieldIndex()); 5654 } 5655 } else if (IndirectFieldDecl *IFD = I->getIndirectMember()) { 5656 // Walk the indirect field decl's chain to find the object to initialize, 5657 // and make sure we've initialized every step along it. 5658 auto IndirectFieldChain = IFD->chain(); 5659 for (auto *C : IndirectFieldChain) { 5660 FD = cast<FieldDecl>(C); 5661 CXXRecordDecl *CD = cast<CXXRecordDecl>(FD->getParent()); 5662 // Switch the union field if it differs. This happens if we had 5663 // preceding zero-initialization, and we're now initializing a union 5664 // subobject other than the first. 5665 // FIXME: In this case, the values of the other subobjects are 5666 // specified, since zero-initialization sets all padding bits to zero. 5667 if (!Value->hasValue() || 5668 (Value->isUnion() && Value->getUnionField() != FD)) { 5669 if (CD->isUnion()) 5670 *Value = APValue(FD); 5671 else 5672 // FIXME: This immediately starts the lifetime of all members of an 5673 // anonymous struct. It would be preferable to strictly start member 5674 // lifetime in initialization order. 5675 *Value = getDefaultInitValue(Info.Ctx.getRecordType(CD)); 5676 } 5677 // Store Subobject as its parent before updating it for the last element 5678 // in the chain. 5679 if (C == IndirectFieldChain.back()) 5680 SubobjectParent = Subobject; 5681 if (!HandleLValueMember(Info, I->getInit(), Subobject, FD)) 5682 return false; 5683 if (CD->isUnion()) 5684 Value = &Value->getUnionValue(); 5685 else { 5686 if (C == IndirectFieldChain.front() && !RD->isUnion()) 5687 SkipToField(FD, true); 5688 Value = &Value->getStructField(FD->getFieldIndex()); 5689 } 5690 } 5691 } else { 5692 llvm_unreachable("unknown base initializer kind"); 5693 } 5694 5695 // Need to override This for implicit field initializers as in this case 5696 // This refers to innermost anonymous struct/union containing initializer, 5697 // not to currently constructed class. 5698 const Expr *Init = I->getInit(); 5699 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &SubobjectParent, 5700 isa<CXXDefaultInitExpr>(Init)); 5701 FullExpressionRAII InitScope(Info); 5702 if (!EvaluateInPlace(*Value, Info, Subobject, Init) || 5703 (FD && FD->isBitField() && 5704 !truncateBitfieldValue(Info, Init, *Value, FD))) { 5705 // If we're checking for a potential constant expression, evaluate all 5706 // initializers even if some of them fail. 5707 if (!Info.noteFailure()) 5708 return false; 5709 Success = false; 5710 } 5711 5712 // This is the point at which the dynamic type of the object becomes this 5713 // class type. 5714 if (I->isBaseInitializer() && BasesSeen == RD->getNumBases()) 5715 EvalObj.finishedConstructingBases(); 5716 } 5717 5718 // Default-initialize any remaining fields. 5719 if (!RD->isUnion()) { 5720 for (; FieldIt != RD->field_end(); ++FieldIt) { 5721 if (!FieldIt->isUnnamedBitfield()) 5722 Result.getStructField(FieldIt->getFieldIndex()) = 5723 getDefaultInitValue(FieldIt->getType()); 5724 } 5725 } 5726 5727 return Success && 5728 EvaluateStmt(Ret, Info, Definition->getBody()) != ESR_Failed && 5729 LifetimeExtendedScope.destroy(); 5730 } 5731 5732 static bool HandleConstructorCall(const Expr *E, const LValue &This, 5733 ArrayRef<const Expr*> Args, 5734 const CXXConstructorDecl *Definition, 5735 EvalInfo &Info, APValue &Result) { 5736 ArgVector ArgValues(Args.size()); 5737 if (!EvaluateArgs(Args, ArgValues, Info, Definition)) 5738 return false; 5739 5740 return HandleConstructorCall(E, This, ArgValues.data(), Definition, 5741 Info, Result); 5742 } 5743 5744 static bool HandleDestructionImpl(EvalInfo &Info, SourceLocation CallLoc, 5745 const LValue &This, APValue &Value, 5746 QualType T) { 5747 // Objects can only be destroyed while they're within their lifetimes. 5748 // FIXME: We have no representation for whether an object of type nullptr_t 5749 // is in its lifetime; it usually doesn't matter. Perhaps we should model it 5750 // as indeterminate instead? 5751 if (Value.isAbsent() && !T->isNullPtrType()) { 5752 APValue Printable; 5753 This.moveInto(Printable); 5754 Info.FFDiag(CallLoc, diag::note_constexpr_destroy_out_of_lifetime) 5755 << Printable.getAsString(Info.Ctx, Info.Ctx.getLValueReferenceType(T)); 5756 return false; 5757 } 5758 5759 // Invent an expression for location purposes. 5760 // FIXME: We shouldn't need to do this. 5761 OpaqueValueExpr LocE(CallLoc, Info.Ctx.IntTy, VK_RValue); 5762 5763 // For arrays, destroy elements right-to-left. 5764 if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(T)) { 5765 uint64_t Size = CAT->getSize().getZExtValue(); 5766 QualType ElemT = CAT->getElementType(); 5767 5768 LValue ElemLV = This; 5769 ElemLV.addArray(Info, &LocE, CAT); 5770 if (!HandleLValueArrayAdjustment(Info, &LocE, ElemLV, ElemT, Size)) 5771 return false; 5772 5773 // Ensure that we have actual array elements available to destroy; the 5774 // destructors might mutate the value, so we can't run them on the array 5775 // filler. 5776 if (Size && Size > Value.getArrayInitializedElts()) 5777 expandArray(Value, Value.getArraySize() - 1); 5778 5779 for (; Size != 0; --Size) { 5780 APValue &Elem = Value.getArrayInitializedElt(Size - 1); 5781 if (!HandleLValueArrayAdjustment(Info, &LocE, ElemLV, ElemT, -1) || 5782 !HandleDestructionImpl(Info, CallLoc, ElemLV, Elem, ElemT)) 5783 return false; 5784 } 5785 5786 // End the lifetime of this array now. 5787 Value = APValue(); 5788 return true; 5789 } 5790 5791 const CXXRecordDecl *RD = T->getAsCXXRecordDecl(); 5792 if (!RD) { 5793 if (T.isDestructedType()) { 5794 Info.FFDiag(CallLoc, diag::note_constexpr_unsupported_destruction) << T; 5795 return false; 5796 } 5797 5798 Value = APValue(); 5799 return true; 5800 } 5801 5802 if (RD->getNumVBases()) { 5803 Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD; 5804 return false; 5805 } 5806 5807 const CXXDestructorDecl *DD = RD->getDestructor(); 5808 if (!DD && !RD->hasTrivialDestructor()) { 5809 Info.FFDiag(CallLoc); 5810 return false; 5811 } 5812 5813 if (!DD || DD->isTrivial() || 5814 (RD->isAnonymousStructOrUnion() && RD->isUnion())) { 5815 // A trivial destructor just ends the lifetime of the object. Check for 5816 // this case before checking for a body, because we might not bother 5817 // building a body for a trivial destructor. Note that it doesn't matter 5818 // whether the destructor is constexpr in this case; all trivial 5819 // destructors are constexpr. 5820 // 5821 // If an anonymous union would be destroyed, some enclosing destructor must 5822 // have been explicitly defined, and the anonymous union destruction should 5823 // have no effect. 5824 Value = APValue(); 5825 return true; 5826 } 5827 5828 if (!Info.CheckCallLimit(CallLoc)) 5829 return false; 5830 5831 const FunctionDecl *Definition = nullptr; 5832 const Stmt *Body = DD->getBody(Definition); 5833 5834 if (!CheckConstexprFunction(Info, CallLoc, DD, Definition, Body)) 5835 return false; 5836 5837 CallStackFrame Frame(Info, CallLoc, Definition, &This, nullptr); 5838 5839 // We're now in the period of destruction of this object. 5840 unsigned BasesLeft = RD->getNumBases(); 5841 EvalInfo::EvaluatingDestructorRAII EvalObj( 5842 Info, 5843 ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries}); 5844 if (!EvalObj.DidInsert) { 5845 // C++2a [class.dtor]p19: 5846 // the behavior is undefined if the destructor is invoked for an object 5847 // whose lifetime has ended 5848 // (Note that formally the lifetime ends when the period of destruction 5849 // begins, even though certain uses of the object remain valid until the 5850 // period of destruction ends.) 5851 Info.FFDiag(CallLoc, diag::note_constexpr_double_destroy); 5852 return false; 5853 } 5854 5855 // FIXME: Creating an APValue just to hold a nonexistent return value is 5856 // wasteful. 5857 APValue RetVal; 5858 StmtResult Ret = {RetVal, nullptr}; 5859 if (EvaluateStmt(Ret, Info, Definition->getBody()) == ESR_Failed) 5860 return false; 5861 5862 // A union destructor does not implicitly destroy its members. 5863 if (RD->isUnion()) 5864 return true; 5865 5866 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 5867 5868 // We don't have a good way to iterate fields in reverse, so collect all the 5869 // fields first and then walk them backwards. 5870 SmallVector<FieldDecl*, 16> Fields(RD->field_begin(), RD->field_end()); 5871 for (const FieldDecl *FD : llvm::reverse(Fields)) { 5872 if (FD->isUnnamedBitfield()) 5873 continue; 5874 5875 LValue Subobject = This; 5876 if (!HandleLValueMember(Info, &LocE, Subobject, FD, &Layout)) 5877 return false; 5878 5879 APValue *SubobjectValue = &Value.getStructField(FD->getFieldIndex()); 5880 if (!HandleDestructionImpl(Info, CallLoc, Subobject, *SubobjectValue, 5881 FD->getType())) 5882 return false; 5883 } 5884 5885 if (BasesLeft != 0) 5886 EvalObj.startedDestroyingBases(); 5887 5888 // Destroy base classes in reverse order. 5889 for (const CXXBaseSpecifier &Base : llvm::reverse(RD->bases())) { 5890 --BasesLeft; 5891 5892 QualType BaseType = Base.getType(); 5893 LValue Subobject = This; 5894 if (!HandleLValueDirectBase(Info, &LocE, Subobject, RD, 5895 BaseType->getAsCXXRecordDecl(), &Layout)) 5896 return false; 5897 5898 APValue *SubobjectValue = &Value.getStructBase(BasesLeft); 5899 if (!HandleDestructionImpl(Info, CallLoc, Subobject, *SubobjectValue, 5900 BaseType)) 5901 return false; 5902 } 5903 assert(BasesLeft == 0 && "NumBases was wrong?"); 5904 5905 // The period of destruction ends now. The object is gone. 5906 Value = APValue(); 5907 return true; 5908 } 5909 5910 namespace { 5911 struct DestroyObjectHandler { 5912 EvalInfo &Info; 5913 const Expr *E; 5914 const LValue &This; 5915 const AccessKinds AccessKind; 5916 5917 typedef bool result_type; 5918 bool failed() { return false; } 5919 bool found(APValue &Subobj, QualType SubobjType) { 5920 return HandleDestructionImpl(Info, E->getExprLoc(), This, Subobj, 5921 SubobjType); 5922 } 5923 bool found(APSInt &Value, QualType SubobjType) { 5924 Info.FFDiag(E, diag::note_constexpr_destroy_complex_elem); 5925 return false; 5926 } 5927 bool found(APFloat &Value, QualType SubobjType) { 5928 Info.FFDiag(E, diag::note_constexpr_destroy_complex_elem); 5929 return false; 5930 } 5931 }; 5932 } 5933 5934 /// Perform a destructor or pseudo-destructor call on the given object, which 5935 /// might in general not be a complete object. 5936 static bool HandleDestruction(EvalInfo &Info, const Expr *E, 5937 const LValue &This, QualType ThisType) { 5938 CompleteObject Obj = findCompleteObject(Info, E, AK_Destroy, This, ThisType); 5939 DestroyObjectHandler Handler = {Info, E, This, AK_Destroy}; 5940 return Obj && findSubobject(Info, E, Obj, This.Designator, Handler); 5941 } 5942 5943 /// Destroy and end the lifetime of the given complete object. 5944 static bool HandleDestruction(EvalInfo &Info, SourceLocation Loc, 5945 APValue::LValueBase LVBase, APValue &Value, 5946 QualType T) { 5947 // If we've had an unmodeled side-effect, we can't rely on mutable state 5948 // (such as the object we're about to destroy) being correct. 5949 if (Info.EvalStatus.HasSideEffects) 5950 return false; 5951 5952 LValue LV; 5953 LV.set({LVBase}); 5954 return HandleDestructionImpl(Info, Loc, LV, Value, T); 5955 } 5956 5957 /// Perform a call to 'perator new' or to `__builtin_operator_new'. 5958 static bool HandleOperatorNewCall(EvalInfo &Info, const CallExpr *E, 5959 LValue &Result) { 5960 if (Info.checkingPotentialConstantExpression() || 5961 Info.SpeculativeEvaluationDepth) 5962 return false; 5963 5964 // This is permitted only within a call to std::allocator<T>::allocate. 5965 auto Caller = Info.getStdAllocatorCaller("allocate"); 5966 if (!Caller) { 5967 Info.FFDiag(E->getExprLoc(), Info.getLangOpts().CPlusPlus2a 5968 ? diag::note_constexpr_new_untyped 5969 : diag::note_constexpr_new); 5970 return false; 5971 } 5972 5973 QualType ElemType = Caller.ElemType; 5974 if (ElemType->isIncompleteType() || ElemType->isFunctionType()) { 5975 Info.FFDiag(E->getExprLoc(), 5976 diag::note_constexpr_new_not_complete_object_type) 5977 << (ElemType->isIncompleteType() ? 0 : 1) << ElemType; 5978 return false; 5979 } 5980 5981 APSInt ByteSize; 5982 if (!EvaluateInteger(E->getArg(0), ByteSize, Info)) 5983 return false; 5984 bool IsNothrow = false; 5985 for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I) { 5986 EvaluateIgnoredValue(Info, E->getArg(I)); 5987 IsNothrow |= E->getType()->isNothrowT(); 5988 } 5989 5990 CharUnits ElemSize; 5991 if (!HandleSizeof(Info, E->getExprLoc(), ElemType, ElemSize)) 5992 return false; 5993 APInt Size, Remainder; 5994 APInt ElemSizeAP(ByteSize.getBitWidth(), ElemSize.getQuantity()); 5995 APInt::udivrem(ByteSize, ElemSizeAP, Size, Remainder); 5996 if (Remainder != 0) { 5997 // This likely indicates a bug in the implementation of 'std::allocator'. 5998 Info.FFDiag(E->getExprLoc(), diag::note_constexpr_operator_new_bad_size) 5999 << ByteSize << APSInt(ElemSizeAP, true) << ElemType; 6000 return false; 6001 } 6002 6003 if (ByteSize.getActiveBits() > ConstantArrayType::getMaxSizeBits(Info.Ctx)) { 6004 if (IsNothrow) { 6005 Result.setNull(Info.Ctx, E->getType()); 6006 return true; 6007 } 6008 6009 Info.FFDiag(E, diag::note_constexpr_new_too_large) << APSInt(Size, true); 6010 return false; 6011 } 6012 6013 QualType AllocType = Info.Ctx.getConstantArrayType(ElemType, Size, nullptr, 6014 ArrayType::Normal, 0); 6015 APValue *Val = Info.createHeapAlloc(E, AllocType, Result); 6016 *Val = APValue(APValue::UninitArray(), 0, Size.getZExtValue()); 6017 Result.addArray(Info, E, cast<ConstantArrayType>(AllocType)); 6018 return true; 6019 } 6020 6021 static bool hasVirtualDestructor(QualType T) { 6022 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 6023 if (CXXDestructorDecl *DD = RD->getDestructor()) 6024 return DD->isVirtual(); 6025 return false; 6026 } 6027 6028 static const FunctionDecl *getVirtualOperatorDelete(QualType T) { 6029 if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 6030 if (CXXDestructorDecl *DD = RD->getDestructor()) 6031 return DD->isVirtual() ? DD->getOperatorDelete() : nullptr; 6032 return nullptr; 6033 } 6034 6035 /// Check that the given object is a suitable pointer to a heap allocation that 6036 /// still exists and is of the right kind for the purpose of a deletion. 6037 /// 6038 /// On success, returns the heap allocation to deallocate. On failure, produces 6039 /// a diagnostic and returns None. 6040 static Optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E, 6041 const LValue &Pointer, 6042 DynAlloc::Kind DeallocKind) { 6043 auto PointerAsString = [&] { 6044 return Pointer.toString(Info.Ctx, Info.Ctx.VoidPtrTy); 6045 }; 6046 6047 DynamicAllocLValue DA = Pointer.Base.dyn_cast<DynamicAllocLValue>(); 6048 if (!DA) { 6049 Info.FFDiag(E, diag::note_constexpr_delete_not_heap_alloc) 6050 << PointerAsString(); 6051 if (Pointer.Base) 6052 NoteLValueLocation(Info, Pointer.Base); 6053 return None; 6054 } 6055 6056 Optional<DynAlloc *> Alloc = Info.lookupDynamicAlloc(DA); 6057 if (!Alloc) { 6058 Info.FFDiag(E, diag::note_constexpr_double_delete); 6059 return None; 6060 } 6061 6062 QualType AllocType = Pointer.Base.getDynamicAllocType(); 6063 if (DeallocKind != (*Alloc)->getKind()) { 6064 Info.FFDiag(E, diag::note_constexpr_new_delete_mismatch) 6065 << DeallocKind << (*Alloc)->getKind() << AllocType; 6066 NoteLValueLocation(Info, Pointer.Base); 6067 return None; 6068 } 6069 6070 bool Subobject = false; 6071 if (DeallocKind == DynAlloc::New) { 6072 Subobject = Pointer.Designator.MostDerivedPathLength != 0 || 6073 Pointer.Designator.isOnePastTheEnd(); 6074 } else { 6075 Subobject = Pointer.Designator.Entries.size() != 1 || 6076 Pointer.Designator.Entries[0].getAsArrayIndex() != 0; 6077 } 6078 if (Subobject) { 6079 Info.FFDiag(E, diag::note_constexpr_delete_subobject) 6080 << PointerAsString() << Pointer.Designator.isOnePastTheEnd(); 6081 return None; 6082 } 6083 6084 return Alloc; 6085 } 6086 6087 // Perform a call to 'operator delete' or '__builtin_operator_delete'. 6088 bool HandleOperatorDeleteCall(EvalInfo &Info, const CallExpr *E) { 6089 if (Info.checkingPotentialConstantExpression() || 6090 Info.SpeculativeEvaluationDepth) 6091 return false; 6092 6093 // This is permitted only within a call to std::allocator<T>::deallocate. 6094 if (!Info.getStdAllocatorCaller("deallocate")) { 6095 Info.FFDiag(E->getExprLoc()); 6096 return true; 6097 } 6098 6099 LValue Pointer; 6100 if (!EvaluatePointer(E->getArg(0), Pointer, Info)) 6101 return false; 6102 for (unsigned I = 1, N = E->getNumArgs(); I != N; ++I) 6103 EvaluateIgnoredValue(Info, E->getArg(I)); 6104 6105 if (Pointer.Designator.Invalid) 6106 return false; 6107 6108 // Deleting a null pointer has no effect. 6109 if (Pointer.isNullPointer()) 6110 return true; 6111 6112 if (!CheckDeleteKind(Info, E, Pointer, DynAlloc::StdAllocator)) 6113 return false; 6114 6115 Info.HeapAllocs.erase(Pointer.Base.get<DynamicAllocLValue>()); 6116 return true; 6117 } 6118 6119 //===----------------------------------------------------------------------===// 6120 // Generic Evaluation 6121 //===----------------------------------------------------------------------===// 6122 namespace { 6123 6124 class BitCastBuffer { 6125 // FIXME: We're going to need bit-level granularity when we support 6126 // bit-fields. 6127 // FIXME: Its possible under the C++ standard for 'char' to not be 8 bits, but 6128 // we don't support a host or target where that is the case. Still, we should 6129 // use a more generic type in case we ever do. 6130 SmallVector<Optional<unsigned char>, 32> Bytes; 6131 6132 static_assert(std::numeric_limits<unsigned char>::digits >= 8, 6133 "Need at least 8 bit unsigned char"); 6134 6135 bool TargetIsLittleEndian; 6136 6137 public: 6138 BitCastBuffer(CharUnits Width, bool TargetIsLittleEndian) 6139 : Bytes(Width.getQuantity()), 6140 TargetIsLittleEndian(TargetIsLittleEndian) {} 6141 6142 LLVM_NODISCARD 6143 bool readObject(CharUnits Offset, CharUnits Width, 6144 SmallVectorImpl<unsigned char> &Output) const { 6145 for (CharUnits I = Offset, E = Offset + Width; I != E; ++I) { 6146 // If a byte of an integer is uninitialized, then the whole integer is 6147 // uninitalized. 6148 if (!Bytes[I.getQuantity()]) 6149 return false; 6150 Output.push_back(*Bytes[I.getQuantity()]); 6151 } 6152 if (llvm::sys::IsLittleEndianHost != TargetIsLittleEndian) 6153 std::reverse(Output.begin(), Output.end()); 6154 return true; 6155 } 6156 6157 void writeObject(CharUnits Offset, SmallVectorImpl<unsigned char> &Input) { 6158 if (llvm::sys::IsLittleEndianHost != TargetIsLittleEndian) 6159 std::reverse(Input.begin(), Input.end()); 6160 6161 size_t Index = 0; 6162 for (unsigned char Byte : Input) { 6163 assert(!Bytes[Offset.getQuantity() + Index] && "overwriting a byte?"); 6164 Bytes[Offset.getQuantity() + Index] = Byte; 6165 ++Index; 6166 } 6167 } 6168 6169 size_t size() { return Bytes.size(); } 6170 }; 6171 6172 /// Traverse an APValue to produce an BitCastBuffer, emulating how the current 6173 /// target would represent the value at runtime. 6174 class APValueToBufferConverter { 6175 EvalInfo &Info; 6176 BitCastBuffer Buffer; 6177 const CastExpr *BCE; 6178 6179 APValueToBufferConverter(EvalInfo &Info, CharUnits ObjectWidth, 6180 const CastExpr *BCE) 6181 : Info(Info), 6182 Buffer(ObjectWidth, Info.Ctx.getTargetInfo().isLittleEndian()), 6183 BCE(BCE) {} 6184 6185 bool visit(const APValue &Val, QualType Ty) { 6186 return visit(Val, Ty, CharUnits::fromQuantity(0)); 6187 } 6188 6189 // Write out Val with type Ty into Buffer starting at Offset. 6190 bool visit(const APValue &Val, QualType Ty, CharUnits Offset) { 6191 assert((size_t)Offset.getQuantity() <= Buffer.size()); 6192 6193 // As a special case, nullptr_t has an indeterminate value. 6194 if (Ty->isNullPtrType()) 6195 return true; 6196 6197 // Dig through Src to find the byte at SrcOffset. 6198 switch (Val.getKind()) { 6199 case APValue::Indeterminate: 6200 case APValue::None: 6201 return true; 6202 6203 case APValue::Int: 6204 return visitInt(Val.getInt(), Ty, Offset); 6205 case APValue::Float: 6206 return visitFloat(Val.getFloat(), Ty, Offset); 6207 case APValue::Array: 6208 return visitArray(Val, Ty, Offset); 6209 case APValue::Struct: 6210 return visitRecord(Val, Ty, Offset); 6211 6212 case APValue::ComplexInt: 6213 case APValue::ComplexFloat: 6214 case APValue::Vector: 6215 case APValue::FixedPoint: 6216 // FIXME: We should support these. 6217 6218 case APValue::Union: 6219 case APValue::MemberPointer: 6220 case APValue::AddrLabelDiff: { 6221 Info.FFDiag(BCE->getBeginLoc(), 6222 diag::note_constexpr_bit_cast_unsupported_type) 6223 << Ty; 6224 return false; 6225 } 6226 6227 case APValue::LValue: 6228 llvm_unreachable("LValue subobject in bit_cast?"); 6229 } 6230 llvm_unreachable("Unhandled APValue::ValueKind"); 6231 } 6232 6233 bool visitRecord(const APValue &Val, QualType Ty, CharUnits Offset) { 6234 const RecordDecl *RD = Ty->getAsRecordDecl(); 6235 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 6236 6237 // Visit the base classes. 6238 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) { 6239 for (size_t I = 0, E = CXXRD->getNumBases(); I != E; ++I) { 6240 const CXXBaseSpecifier &BS = CXXRD->bases_begin()[I]; 6241 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl(); 6242 6243 if (!visitRecord(Val.getStructBase(I), BS.getType(), 6244 Layout.getBaseClassOffset(BaseDecl) + Offset)) 6245 return false; 6246 } 6247 } 6248 6249 // Visit the fields. 6250 unsigned FieldIdx = 0; 6251 for (FieldDecl *FD : RD->fields()) { 6252 if (FD->isBitField()) { 6253 Info.FFDiag(BCE->getBeginLoc(), 6254 diag::note_constexpr_bit_cast_unsupported_bitfield); 6255 return false; 6256 } 6257 6258 uint64_t FieldOffsetBits = Layout.getFieldOffset(FieldIdx); 6259 6260 assert(FieldOffsetBits % Info.Ctx.getCharWidth() == 0 && 6261 "only bit-fields can have sub-char alignment"); 6262 CharUnits FieldOffset = 6263 Info.Ctx.toCharUnitsFromBits(FieldOffsetBits) + Offset; 6264 QualType FieldTy = FD->getType(); 6265 if (!visit(Val.getStructField(FieldIdx), FieldTy, FieldOffset)) 6266 return false; 6267 ++FieldIdx; 6268 } 6269 6270 return true; 6271 } 6272 6273 bool visitArray(const APValue &Val, QualType Ty, CharUnits Offset) { 6274 const auto *CAT = 6275 dyn_cast_or_null<ConstantArrayType>(Ty->getAsArrayTypeUnsafe()); 6276 if (!CAT) 6277 return false; 6278 6279 CharUnits ElemWidth = Info.Ctx.getTypeSizeInChars(CAT->getElementType()); 6280 unsigned NumInitializedElts = Val.getArrayInitializedElts(); 6281 unsigned ArraySize = Val.getArraySize(); 6282 // First, initialize the initialized elements. 6283 for (unsigned I = 0; I != NumInitializedElts; ++I) { 6284 const APValue &SubObj = Val.getArrayInitializedElt(I); 6285 if (!visit(SubObj, CAT->getElementType(), Offset + I * ElemWidth)) 6286 return false; 6287 } 6288 6289 // Next, initialize the rest of the array using the filler. 6290 if (Val.hasArrayFiller()) { 6291 const APValue &Filler = Val.getArrayFiller(); 6292 for (unsigned I = NumInitializedElts; I != ArraySize; ++I) { 6293 if (!visit(Filler, CAT->getElementType(), Offset + I * ElemWidth)) 6294 return false; 6295 } 6296 } 6297 6298 return true; 6299 } 6300 6301 bool visitInt(const APSInt &Val, QualType Ty, CharUnits Offset) { 6302 CharUnits Width = Info.Ctx.getTypeSizeInChars(Ty); 6303 SmallVector<unsigned char, 8> Bytes(Width.getQuantity()); 6304 llvm::StoreIntToMemory(Val, &*Bytes.begin(), Width.getQuantity()); 6305 Buffer.writeObject(Offset, Bytes); 6306 return true; 6307 } 6308 6309 bool visitFloat(const APFloat &Val, QualType Ty, CharUnits Offset) { 6310 APSInt AsInt(Val.bitcastToAPInt()); 6311 return visitInt(AsInt, Ty, Offset); 6312 } 6313 6314 public: 6315 static Optional<BitCastBuffer> convert(EvalInfo &Info, const APValue &Src, 6316 const CastExpr *BCE) { 6317 CharUnits DstSize = Info.Ctx.getTypeSizeInChars(BCE->getType()); 6318 APValueToBufferConverter Converter(Info, DstSize, BCE); 6319 if (!Converter.visit(Src, BCE->getSubExpr()->getType())) 6320 return None; 6321 return Converter.Buffer; 6322 } 6323 }; 6324 6325 /// Write an BitCastBuffer into an APValue. 6326 class BufferToAPValueConverter { 6327 EvalInfo &Info; 6328 const BitCastBuffer &Buffer; 6329 const CastExpr *BCE; 6330 6331 BufferToAPValueConverter(EvalInfo &Info, const BitCastBuffer &Buffer, 6332 const CastExpr *BCE) 6333 : Info(Info), Buffer(Buffer), BCE(BCE) {} 6334 6335 // Emit an unsupported bit_cast type error. Sema refuses to build a bit_cast 6336 // with an invalid type, so anything left is a deficiency on our part (FIXME). 6337 // Ideally this will be unreachable. 6338 llvm::NoneType unsupportedType(QualType Ty) { 6339 Info.FFDiag(BCE->getBeginLoc(), 6340 diag::note_constexpr_bit_cast_unsupported_type) 6341 << Ty; 6342 return None; 6343 } 6344 6345 Optional<APValue> visit(const BuiltinType *T, CharUnits Offset, 6346 const EnumType *EnumSugar = nullptr) { 6347 if (T->isNullPtrType()) { 6348 uint64_t NullValue = Info.Ctx.getTargetNullPointerValue(QualType(T, 0)); 6349 return APValue((Expr *)nullptr, 6350 /*Offset=*/CharUnits::fromQuantity(NullValue), 6351 APValue::NoLValuePath{}, /*IsNullPtr=*/true); 6352 } 6353 6354 CharUnits SizeOf = Info.Ctx.getTypeSizeInChars(T); 6355 SmallVector<uint8_t, 8> Bytes; 6356 if (!Buffer.readObject(Offset, SizeOf, Bytes)) { 6357 // If this is std::byte or unsigned char, then its okay to store an 6358 // indeterminate value. 6359 bool IsStdByte = EnumSugar && EnumSugar->isStdByteType(); 6360 bool IsUChar = 6361 !EnumSugar && (T->isSpecificBuiltinType(BuiltinType::UChar) || 6362 T->isSpecificBuiltinType(BuiltinType::Char_U)); 6363 if (!IsStdByte && !IsUChar) { 6364 QualType DisplayType(EnumSugar ? (const Type *)EnumSugar : T, 0); 6365 Info.FFDiag(BCE->getExprLoc(), 6366 diag::note_constexpr_bit_cast_indet_dest) 6367 << DisplayType << Info.Ctx.getLangOpts().CharIsSigned; 6368 return None; 6369 } 6370 6371 return APValue::IndeterminateValue(); 6372 } 6373 6374 APSInt Val(SizeOf.getQuantity() * Info.Ctx.getCharWidth(), true); 6375 llvm::LoadIntFromMemory(Val, &*Bytes.begin(), Bytes.size()); 6376 6377 if (T->isIntegralOrEnumerationType()) { 6378 Val.setIsSigned(T->isSignedIntegerOrEnumerationType()); 6379 return APValue(Val); 6380 } 6381 6382 if (T->isRealFloatingType()) { 6383 const llvm::fltSemantics &Semantics = 6384 Info.Ctx.getFloatTypeSemantics(QualType(T, 0)); 6385 return APValue(APFloat(Semantics, Val)); 6386 } 6387 6388 return unsupportedType(QualType(T, 0)); 6389 } 6390 6391 Optional<APValue> visit(const RecordType *RTy, CharUnits Offset) { 6392 const RecordDecl *RD = RTy->getAsRecordDecl(); 6393 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 6394 6395 unsigned NumBases = 0; 6396 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) 6397 NumBases = CXXRD->getNumBases(); 6398 6399 APValue ResultVal(APValue::UninitStruct(), NumBases, 6400 std::distance(RD->field_begin(), RD->field_end())); 6401 6402 // Visit the base classes. 6403 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) { 6404 for (size_t I = 0, E = CXXRD->getNumBases(); I != E; ++I) { 6405 const CXXBaseSpecifier &BS = CXXRD->bases_begin()[I]; 6406 CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl(); 6407 if (BaseDecl->isEmpty() || 6408 Info.Ctx.getASTRecordLayout(BaseDecl).getNonVirtualSize().isZero()) 6409 continue; 6410 6411 Optional<APValue> SubObj = visitType( 6412 BS.getType(), Layout.getBaseClassOffset(BaseDecl) + Offset); 6413 if (!SubObj) 6414 return None; 6415 ResultVal.getStructBase(I) = *SubObj; 6416 } 6417 } 6418 6419 // Visit the fields. 6420 unsigned FieldIdx = 0; 6421 for (FieldDecl *FD : RD->fields()) { 6422 // FIXME: We don't currently support bit-fields. A lot of the logic for 6423 // this is in CodeGen, so we need to factor it around. 6424 if (FD->isBitField()) { 6425 Info.FFDiag(BCE->getBeginLoc(), 6426 diag::note_constexpr_bit_cast_unsupported_bitfield); 6427 return None; 6428 } 6429 6430 uint64_t FieldOffsetBits = Layout.getFieldOffset(FieldIdx); 6431 assert(FieldOffsetBits % Info.Ctx.getCharWidth() == 0); 6432 6433 CharUnits FieldOffset = 6434 CharUnits::fromQuantity(FieldOffsetBits / Info.Ctx.getCharWidth()) + 6435 Offset; 6436 QualType FieldTy = FD->getType(); 6437 Optional<APValue> SubObj = visitType(FieldTy, FieldOffset); 6438 if (!SubObj) 6439 return None; 6440 ResultVal.getStructField(FieldIdx) = *SubObj; 6441 ++FieldIdx; 6442 } 6443 6444 return ResultVal; 6445 } 6446 6447 Optional<APValue> visit(const EnumType *Ty, CharUnits Offset) { 6448 QualType RepresentationType = Ty->getDecl()->getIntegerType(); 6449 assert(!RepresentationType.isNull() && 6450 "enum forward decl should be caught by Sema"); 6451 const auto *AsBuiltin = 6452 RepresentationType.getCanonicalType()->castAs<BuiltinType>(); 6453 // Recurse into the underlying type. Treat std::byte transparently as 6454 // unsigned char. 6455 return visit(AsBuiltin, Offset, /*EnumTy=*/Ty); 6456 } 6457 6458 Optional<APValue> visit(const ConstantArrayType *Ty, CharUnits Offset) { 6459 size_t Size = Ty->getSize().getLimitedValue(); 6460 CharUnits ElementWidth = Info.Ctx.getTypeSizeInChars(Ty->getElementType()); 6461 6462 APValue ArrayValue(APValue::UninitArray(), Size, Size); 6463 for (size_t I = 0; I != Size; ++I) { 6464 Optional<APValue> ElementValue = 6465 visitType(Ty->getElementType(), Offset + I * ElementWidth); 6466 if (!ElementValue) 6467 return None; 6468 ArrayValue.getArrayInitializedElt(I) = std::move(*ElementValue); 6469 } 6470 6471 return ArrayValue; 6472 } 6473 6474 Optional<APValue> visit(const Type *Ty, CharUnits Offset) { 6475 return unsupportedType(QualType(Ty, 0)); 6476 } 6477 6478 Optional<APValue> visitType(QualType Ty, CharUnits Offset) { 6479 QualType Can = Ty.getCanonicalType(); 6480 6481 switch (Can->getTypeClass()) { 6482 #define TYPE(Class, Base) \ 6483 case Type::Class: \ 6484 return visit(cast<Class##Type>(Can.getTypePtr()), Offset); 6485 #define ABSTRACT_TYPE(Class, Base) 6486 #define NON_CANONICAL_TYPE(Class, Base) \ 6487 case Type::Class: \ 6488 llvm_unreachable("non-canonical type should be impossible!"); 6489 #define DEPENDENT_TYPE(Class, Base) \ 6490 case Type::Class: \ 6491 llvm_unreachable( \ 6492 "dependent types aren't supported in the constant evaluator!"); 6493 #define NON_CANONICAL_UNLESS_DEPENDENT(Class, Base) \ 6494 case Type::Class: \ 6495 llvm_unreachable("either dependent or not canonical!"); 6496 #include "clang/AST/TypeNodes.inc" 6497 } 6498 llvm_unreachable("Unhandled Type::TypeClass"); 6499 } 6500 6501 public: 6502 // Pull out a full value of type DstType. 6503 static Optional<APValue> convert(EvalInfo &Info, BitCastBuffer &Buffer, 6504 const CastExpr *BCE) { 6505 BufferToAPValueConverter Converter(Info, Buffer, BCE); 6506 return Converter.visitType(BCE->getType(), CharUnits::fromQuantity(0)); 6507 } 6508 }; 6509 6510 static bool checkBitCastConstexprEligibilityType(SourceLocation Loc, 6511 QualType Ty, EvalInfo *Info, 6512 const ASTContext &Ctx, 6513 bool CheckingDest) { 6514 Ty = Ty.getCanonicalType(); 6515 6516 auto diag = [&](int Reason) { 6517 if (Info) 6518 Info->FFDiag(Loc, diag::note_constexpr_bit_cast_invalid_type) 6519 << CheckingDest << (Reason == 4) << Reason; 6520 return false; 6521 }; 6522 auto note = [&](int Construct, QualType NoteTy, SourceLocation NoteLoc) { 6523 if (Info) 6524 Info->Note(NoteLoc, diag::note_constexpr_bit_cast_invalid_subtype) 6525 << NoteTy << Construct << Ty; 6526 return false; 6527 }; 6528 6529 if (Ty->isUnionType()) 6530 return diag(0); 6531 if (Ty->isPointerType()) 6532 return diag(1); 6533 if (Ty->isMemberPointerType()) 6534 return diag(2); 6535 if (Ty.isVolatileQualified()) 6536 return diag(3); 6537 6538 if (RecordDecl *Record = Ty->getAsRecordDecl()) { 6539 if (auto *CXXRD = dyn_cast<CXXRecordDecl>(Record)) { 6540 for (CXXBaseSpecifier &BS : CXXRD->bases()) 6541 if (!checkBitCastConstexprEligibilityType(Loc, BS.getType(), Info, Ctx, 6542 CheckingDest)) 6543 return note(1, BS.getType(), BS.getBeginLoc()); 6544 } 6545 for (FieldDecl *FD : Record->fields()) { 6546 if (FD->getType()->isReferenceType()) 6547 return diag(4); 6548 if (!checkBitCastConstexprEligibilityType(Loc, FD->getType(), Info, Ctx, 6549 CheckingDest)) 6550 return note(0, FD->getType(), FD->getBeginLoc()); 6551 } 6552 } 6553 6554 if (Ty->isArrayType() && 6555 !checkBitCastConstexprEligibilityType(Loc, Ctx.getBaseElementType(Ty), 6556 Info, Ctx, CheckingDest)) 6557 return false; 6558 6559 return true; 6560 } 6561 6562 static bool checkBitCastConstexprEligibility(EvalInfo *Info, 6563 const ASTContext &Ctx, 6564 const CastExpr *BCE) { 6565 bool DestOK = checkBitCastConstexprEligibilityType( 6566 BCE->getBeginLoc(), BCE->getType(), Info, Ctx, true); 6567 bool SourceOK = DestOK && checkBitCastConstexprEligibilityType( 6568 BCE->getBeginLoc(), 6569 BCE->getSubExpr()->getType(), Info, Ctx, false); 6570 return SourceOK; 6571 } 6572 6573 static bool handleLValueToRValueBitCast(EvalInfo &Info, APValue &DestValue, 6574 APValue &SourceValue, 6575 const CastExpr *BCE) { 6576 assert(CHAR_BIT == 8 && Info.Ctx.getTargetInfo().getCharWidth() == 8 && 6577 "no host or target supports non 8-bit chars"); 6578 assert(SourceValue.isLValue() && 6579 "LValueToRValueBitcast requires an lvalue operand!"); 6580 6581 if (!checkBitCastConstexprEligibility(&Info, Info.Ctx, BCE)) 6582 return false; 6583 6584 LValue SourceLValue; 6585 APValue SourceRValue; 6586 SourceLValue.setFrom(Info.Ctx, SourceValue); 6587 if (!handleLValueToRValueConversion( 6588 Info, BCE, BCE->getSubExpr()->getType().withConst(), SourceLValue, 6589 SourceRValue, /*WantObjectRepresentation=*/true)) 6590 return false; 6591 6592 // Read out SourceValue into a char buffer. 6593 Optional<BitCastBuffer> Buffer = 6594 APValueToBufferConverter::convert(Info, SourceRValue, BCE); 6595 if (!Buffer) 6596 return false; 6597 6598 // Write out the buffer into a new APValue. 6599 Optional<APValue> MaybeDestValue = 6600 BufferToAPValueConverter::convert(Info, *Buffer, BCE); 6601 if (!MaybeDestValue) 6602 return false; 6603 6604 DestValue = std::move(*MaybeDestValue); 6605 return true; 6606 } 6607 6608 template <class Derived> 6609 class ExprEvaluatorBase 6610 : public ConstStmtVisitor<Derived, bool> { 6611 private: 6612 Derived &getDerived() { return static_cast<Derived&>(*this); } 6613 bool DerivedSuccess(const APValue &V, const Expr *E) { 6614 return getDerived().Success(V, E); 6615 } 6616 bool DerivedZeroInitialization(const Expr *E) { 6617 return getDerived().ZeroInitialization(E); 6618 } 6619 6620 // Check whether a conditional operator with a non-constant condition is a 6621 // potential constant expression. If neither arm is a potential constant 6622 // expression, then the conditional operator is not either. 6623 template<typename ConditionalOperator> 6624 void CheckPotentialConstantConditional(const ConditionalOperator *E) { 6625 assert(Info.checkingPotentialConstantExpression()); 6626 6627 // Speculatively evaluate both arms. 6628 SmallVector<PartialDiagnosticAt, 8> Diag; 6629 { 6630 SpeculativeEvaluationRAII Speculate(Info, &Diag); 6631 StmtVisitorTy::Visit(E->getFalseExpr()); 6632 if (Diag.empty()) 6633 return; 6634 } 6635 6636 { 6637 SpeculativeEvaluationRAII Speculate(Info, &Diag); 6638 Diag.clear(); 6639 StmtVisitorTy::Visit(E->getTrueExpr()); 6640 if (Diag.empty()) 6641 return; 6642 } 6643 6644 Error(E, diag::note_constexpr_conditional_never_const); 6645 } 6646 6647 6648 template<typename ConditionalOperator> 6649 bool HandleConditionalOperator(const ConditionalOperator *E) { 6650 bool BoolResult; 6651 if (!EvaluateAsBooleanCondition(E->getCond(), BoolResult, Info)) { 6652 if (Info.checkingPotentialConstantExpression() && Info.noteFailure()) { 6653 CheckPotentialConstantConditional(E); 6654 return false; 6655 } 6656 if (Info.noteFailure()) { 6657 StmtVisitorTy::Visit(E->getTrueExpr()); 6658 StmtVisitorTy::Visit(E->getFalseExpr()); 6659 } 6660 return false; 6661 } 6662 6663 Expr *EvalExpr = BoolResult ? E->getTrueExpr() : E->getFalseExpr(); 6664 return StmtVisitorTy::Visit(EvalExpr); 6665 } 6666 6667 protected: 6668 EvalInfo &Info; 6669 typedef ConstStmtVisitor<Derived, bool> StmtVisitorTy; 6670 typedef ExprEvaluatorBase ExprEvaluatorBaseTy; 6671 6672 OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) { 6673 return Info.CCEDiag(E, D); 6674 } 6675 6676 bool ZeroInitialization(const Expr *E) { return Error(E); } 6677 6678 public: 6679 ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {} 6680 6681 EvalInfo &getEvalInfo() { return Info; } 6682 6683 /// Report an evaluation error. This should only be called when an error is 6684 /// first discovered. When propagating an error, just return false. 6685 bool Error(const Expr *E, diag::kind D) { 6686 Info.FFDiag(E, D); 6687 return false; 6688 } 6689 bool Error(const Expr *E) { 6690 return Error(E, diag::note_invalid_subexpr_in_const_expr); 6691 } 6692 6693 bool VisitStmt(const Stmt *) { 6694 llvm_unreachable("Expression evaluator should not be called on stmts"); 6695 } 6696 bool VisitExpr(const Expr *E) { 6697 return Error(E); 6698 } 6699 6700 bool VisitConstantExpr(const ConstantExpr *E) 6701 { return StmtVisitorTy::Visit(E->getSubExpr()); } 6702 bool VisitParenExpr(const ParenExpr *E) 6703 { return StmtVisitorTy::Visit(E->getSubExpr()); } 6704 bool VisitUnaryExtension(const UnaryOperator *E) 6705 { return StmtVisitorTy::Visit(E->getSubExpr()); } 6706 bool VisitUnaryPlus(const UnaryOperator *E) 6707 { return StmtVisitorTy::Visit(E->getSubExpr()); } 6708 bool VisitChooseExpr(const ChooseExpr *E) 6709 { return StmtVisitorTy::Visit(E->getChosenSubExpr()); } 6710 bool VisitGenericSelectionExpr(const GenericSelectionExpr *E) 6711 { return StmtVisitorTy::Visit(E->getResultExpr()); } 6712 bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E) 6713 { return StmtVisitorTy::Visit(E->getReplacement()); } 6714 bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) { 6715 TempVersionRAII RAII(*Info.CurrentCall); 6716 SourceLocExprScopeGuard Guard(E, Info.CurrentCall->CurSourceLocExprScope); 6717 return StmtVisitorTy::Visit(E->getExpr()); 6718 } 6719 bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) { 6720 TempVersionRAII RAII(*Info.CurrentCall); 6721 // The initializer may not have been parsed yet, or might be erroneous. 6722 if (!E->getExpr()) 6723 return Error(E); 6724 SourceLocExprScopeGuard Guard(E, Info.CurrentCall->CurSourceLocExprScope); 6725 return StmtVisitorTy::Visit(E->getExpr()); 6726 } 6727 6728 bool VisitExprWithCleanups(const ExprWithCleanups *E) { 6729 FullExpressionRAII Scope(Info); 6730 return StmtVisitorTy::Visit(E->getSubExpr()) && Scope.destroy(); 6731 } 6732 6733 // Temporaries are registered when created, so we don't care about 6734 // CXXBindTemporaryExpr. 6735 bool VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E) { 6736 return StmtVisitorTy::Visit(E->getSubExpr()); 6737 } 6738 6739 bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) { 6740 CCEDiag(E, diag::note_constexpr_invalid_cast) << 0; 6741 return static_cast<Derived*>(this)->VisitCastExpr(E); 6742 } 6743 bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) { 6744 if (!Info.Ctx.getLangOpts().CPlusPlus2a) 6745 CCEDiag(E, diag::note_constexpr_invalid_cast) << 1; 6746 return static_cast<Derived*>(this)->VisitCastExpr(E); 6747 } 6748 bool VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E) { 6749 return static_cast<Derived*>(this)->VisitCastExpr(E); 6750 } 6751 6752 bool VisitBinaryOperator(const BinaryOperator *E) { 6753 switch (E->getOpcode()) { 6754 default: 6755 return Error(E); 6756 6757 case BO_Comma: 6758 VisitIgnoredValue(E->getLHS()); 6759 return StmtVisitorTy::Visit(E->getRHS()); 6760 6761 case BO_PtrMemD: 6762 case BO_PtrMemI: { 6763 LValue Obj; 6764 if (!HandleMemberPointerAccess(Info, E, Obj)) 6765 return false; 6766 APValue Result; 6767 if (!handleLValueToRValueConversion(Info, E, E->getType(), Obj, Result)) 6768 return false; 6769 return DerivedSuccess(Result, E); 6770 } 6771 } 6772 } 6773 6774 bool VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *E) { 6775 return StmtVisitorTy::Visit(E->getSemanticForm()); 6776 } 6777 6778 bool VisitBinaryConditionalOperator(const BinaryConditionalOperator *E) { 6779 // Evaluate and cache the common expression. We treat it as a temporary, 6780 // even though it's not quite the same thing. 6781 LValue CommonLV; 6782 if (!Evaluate(Info.CurrentCall->createTemporary( 6783 E->getOpaqueValue(), 6784 getStorageType(Info.Ctx, E->getOpaqueValue()), false, 6785 CommonLV), 6786 Info, E->getCommon())) 6787 return false; 6788 6789 return HandleConditionalOperator(E); 6790 } 6791 6792 bool VisitConditionalOperator(const ConditionalOperator *E) { 6793 bool IsBcpCall = false; 6794 // If the condition (ignoring parens) is a __builtin_constant_p call, 6795 // the result is a constant expression if it can be folded without 6796 // side-effects. This is an important GNU extension. See GCC PR38377 6797 // for discussion. 6798 if (const CallExpr *CallCE = 6799 dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts())) 6800 if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p) 6801 IsBcpCall = true; 6802 6803 // Always assume __builtin_constant_p(...) ? ... : ... is a potential 6804 // constant expression; we can't check whether it's potentially foldable. 6805 // FIXME: We should instead treat __builtin_constant_p as non-constant if 6806 // it would return 'false' in this mode. 6807 if (Info.checkingPotentialConstantExpression() && IsBcpCall) 6808 return false; 6809 6810 FoldConstant Fold(Info, IsBcpCall); 6811 if (!HandleConditionalOperator(E)) { 6812 Fold.keepDiagnostics(); 6813 return false; 6814 } 6815 6816 return true; 6817 } 6818 6819 bool VisitOpaqueValueExpr(const OpaqueValueExpr *E) { 6820 if (APValue *Value = Info.CurrentCall->getCurrentTemporary(E)) 6821 return DerivedSuccess(*Value, E); 6822 6823 const Expr *Source = E->getSourceExpr(); 6824 if (!Source) 6825 return Error(E); 6826 if (Source == E) { // sanity checking. 6827 assert(0 && "OpaqueValueExpr recursively refers to itself"); 6828 return Error(E); 6829 } 6830 return StmtVisitorTy::Visit(Source); 6831 } 6832 6833 bool VisitPseudoObjectExpr(const PseudoObjectExpr *E) { 6834 for (const Expr *SemE : E->semantics()) { 6835 if (auto *OVE = dyn_cast<OpaqueValueExpr>(SemE)) { 6836 // FIXME: We can't handle the case where an OpaqueValueExpr is also the 6837 // result expression: there could be two different LValues that would 6838 // refer to the same object in that case, and we can't model that. 6839 if (SemE == E->getResultExpr()) 6840 return Error(E); 6841 6842 // Unique OVEs get evaluated if and when we encounter them when 6843 // emitting the rest of the semantic form, rather than eagerly. 6844 if (OVE->isUnique()) 6845 continue; 6846 6847 LValue LV; 6848 if (!Evaluate(Info.CurrentCall->createTemporary( 6849 OVE, getStorageType(Info.Ctx, OVE), false, LV), 6850 Info, OVE->getSourceExpr())) 6851 return false; 6852 } else if (SemE == E->getResultExpr()) { 6853 if (!StmtVisitorTy::Visit(SemE)) 6854 return false; 6855 } else { 6856 if (!EvaluateIgnoredValue(Info, SemE)) 6857 return false; 6858 } 6859 } 6860 return true; 6861 } 6862 6863 bool VisitCallExpr(const CallExpr *E) { 6864 APValue Result; 6865 if (!handleCallExpr(E, Result, nullptr)) 6866 return false; 6867 return DerivedSuccess(Result, E); 6868 } 6869 6870 bool handleCallExpr(const CallExpr *E, APValue &Result, 6871 const LValue *ResultSlot) { 6872 const Expr *Callee = E->getCallee()->IgnoreParens(); 6873 QualType CalleeType = Callee->getType(); 6874 6875 const FunctionDecl *FD = nullptr; 6876 LValue *This = nullptr, ThisVal; 6877 auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs()); 6878 bool HasQualifier = false; 6879 6880 // Extract function decl and 'this' pointer from the callee. 6881 if (CalleeType->isSpecificBuiltinType(BuiltinType::BoundMember)) { 6882 const CXXMethodDecl *Member = nullptr; 6883 if (const MemberExpr *ME = dyn_cast<MemberExpr>(Callee)) { 6884 // Explicit bound member calls, such as x.f() or p->g(); 6885 if (!EvaluateObjectArgument(Info, ME->getBase(), ThisVal)) 6886 return false; 6887 Member = dyn_cast<CXXMethodDecl>(ME->getMemberDecl()); 6888 if (!Member) 6889 return Error(Callee); 6890 This = &ThisVal; 6891 HasQualifier = ME->hasQualifier(); 6892 } else if (const BinaryOperator *BE = dyn_cast<BinaryOperator>(Callee)) { 6893 // Indirect bound member calls ('.*' or '->*'). 6894 const ValueDecl *D = 6895 HandleMemberPointerAccess(Info, BE, ThisVal, false); 6896 if (!D) 6897 return false; 6898 Member = dyn_cast<CXXMethodDecl>(D); 6899 if (!Member) 6900 return Error(Callee); 6901 This = &ThisVal; 6902 } else if (const auto *PDE = dyn_cast<CXXPseudoDestructorExpr>(Callee)) { 6903 if (!Info.getLangOpts().CPlusPlus2a) 6904 Info.CCEDiag(PDE, diag::note_constexpr_pseudo_destructor); 6905 // FIXME: If pseudo-destructor calls ever start ending the lifetime of 6906 // their callee, we should start calling HandleDestruction here. 6907 // For now, we just evaluate the object argument and discard it. 6908 return EvaluateObjectArgument(Info, PDE->getBase(), ThisVal); 6909 } else 6910 return Error(Callee); 6911 FD = Member; 6912 } else if (CalleeType->isFunctionPointerType()) { 6913 LValue Call; 6914 if (!EvaluatePointer(Callee, Call, Info)) 6915 return false; 6916 6917 if (!Call.getLValueOffset().isZero()) 6918 return Error(Callee); 6919 FD = dyn_cast_or_null<FunctionDecl>( 6920 Call.getLValueBase().dyn_cast<const ValueDecl*>()); 6921 if (!FD) 6922 return Error(Callee); 6923 // Don't call function pointers which have been cast to some other type. 6924 // Per DR (no number yet), the caller and callee can differ in noexcept. 6925 if (!Info.Ctx.hasSameFunctionTypeIgnoringExceptionSpec( 6926 CalleeType->getPointeeType(), FD->getType())) { 6927 return Error(E); 6928 } 6929 6930 // Overloaded operator calls to member functions are represented as normal 6931 // calls with '*this' as the first argument. 6932 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 6933 if (MD && !MD->isStatic()) { 6934 // FIXME: When selecting an implicit conversion for an overloaded 6935 // operator delete, we sometimes try to evaluate calls to conversion 6936 // operators without a 'this' parameter! 6937 if (Args.empty()) 6938 return Error(E); 6939 6940 if (!EvaluateObjectArgument(Info, Args[0], ThisVal)) 6941 return false; 6942 This = &ThisVal; 6943 Args = Args.slice(1); 6944 } else if (MD && MD->isLambdaStaticInvoker()) { 6945 // Map the static invoker for the lambda back to the call operator. 6946 // Conveniently, we don't have to slice out the 'this' argument (as is 6947 // being done for the non-static case), since a static member function 6948 // doesn't have an implicit argument passed in. 6949 const CXXRecordDecl *ClosureClass = MD->getParent(); 6950 assert( 6951 ClosureClass->captures_begin() == ClosureClass->captures_end() && 6952 "Number of captures must be zero for conversion to function-ptr"); 6953 6954 const CXXMethodDecl *LambdaCallOp = 6955 ClosureClass->getLambdaCallOperator(); 6956 6957 // Set 'FD', the function that will be called below, to the call 6958 // operator. If the closure object represents a generic lambda, find 6959 // the corresponding specialization of the call operator. 6960 6961 if (ClosureClass->isGenericLambda()) { 6962 assert(MD->isFunctionTemplateSpecialization() && 6963 "A generic lambda's static-invoker function must be a " 6964 "template specialization"); 6965 const TemplateArgumentList *TAL = MD->getTemplateSpecializationArgs(); 6966 FunctionTemplateDecl *CallOpTemplate = 6967 LambdaCallOp->getDescribedFunctionTemplate(); 6968 void *InsertPos = nullptr; 6969 FunctionDecl *CorrespondingCallOpSpecialization = 6970 CallOpTemplate->findSpecialization(TAL->asArray(), InsertPos); 6971 assert(CorrespondingCallOpSpecialization && 6972 "We must always have a function call operator specialization " 6973 "that corresponds to our static invoker specialization"); 6974 FD = cast<CXXMethodDecl>(CorrespondingCallOpSpecialization); 6975 } else 6976 FD = LambdaCallOp; 6977 } else if (FD->isReplaceableGlobalAllocationFunction()) { 6978 if (FD->getDeclName().getCXXOverloadedOperator() == OO_New || 6979 FD->getDeclName().getCXXOverloadedOperator() == OO_Array_New) { 6980 LValue Ptr; 6981 if (!HandleOperatorNewCall(Info, E, Ptr)) 6982 return false; 6983 Ptr.moveInto(Result); 6984 return true; 6985 } else { 6986 return HandleOperatorDeleteCall(Info, E); 6987 } 6988 } 6989 } else 6990 return Error(E); 6991 6992 SmallVector<QualType, 4> CovariantAdjustmentPath; 6993 if (This) { 6994 auto *NamedMember = dyn_cast<CXXMethodDecl>(FD); 6995 if (NamedMember && NamedMember->isVirtual() && !HasQualifier) { 6996 // Perform virtual dispatch, if necessary. 6997 FD = HandleVirtualDispatch(Info, E, *This, NamedMember, 6998 CovariantAdjustmentPath); 6999 if (!FD) 7000 return false; 7001 } else { 7002 // Check that the 'this' pointer points to an object of the right type. 7003 // FIXME: If this is an assignment operator call, we may need to change 7004 // the active union member before we check this. 7005 if (!checkNonVirtualMemberCallThisPointer(Info, E, *This, NamedMember)) 7006 return false; 7007 } 7008 } 7009 7010 // Destructor calls are different enough that they have their own codepath. 7011 if (auto *DD = dyn_cast<CXXDestructorDecl>(FD)) { 7012 assert(This && "no 'this' pointer for destructor call"); 7013 return HandleDestruction(Info, E, *This, 7014 Info.Ctx.getRecordType(DD->getParent())); 7015 } 7016 7017 const FunctionDecl *Definition = nullptr; 7018 Stmt *Body = FD->getBody(Definition); 7019 7020 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body) || 7021 !HandleFunctionCall(E->getExprLoc(), Definition, This, Args, Body, Info, 7022 Result, ResultSlot)) 7023 return false; 7024 7025 if (!CovariantAdjustmentPath.empty() && 7026 !HandleCovariantReturnAdjustment(Info, E, Result, 7027 CovariantAdjustmentPath)) 7028 return false; 7029 7030 return true; 7031 } 7032 7033 bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) { 7034 return StmtVisitorTy::Visit(E->getInitializer()); 7035 } 7036 bool VisitInitListExpr(const InitListExpr *E) { 7037 if (E->getNumInits() == 0) 7038 return DerivedZeroInitialization(E); 7039 if (E->getNumInits() == 1) 7040 return StmtVisitorTy::Visit(E->getInit(0)); 7041 return Error(E); 7042 } 7043 bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 7044 return DerivedZeroInitialization(E); 7045 } 7046 bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) { 7047 return DerivedZeroInitialization(E); 7048 } 7049 bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 7050 return DerivedZeroInitialization(E); 7051 } 7052 7053 /// A member expression where the object is a prvalue is itself a prvalue. 7054 bool VisitMemberExpr(const MemberExpr *E) { 7055 assert(!Info.Ctx.getLangOpts().CPlusPlus11 && 7056 "missing temporary materialization conversion"); 7057 assert(!E->isArrow() && "missing call to bound member function?"); 7058 7059 APValue Val; 7060 if (!Evaluate(Val, Info, E->getBase())) 7061 return false; 7062 7063 QualType BaseTy = E->getBase()->getType(); 7064 7065 const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl()); 7066 if (!FD) return Error(E); 7067 assert(!FD->getType()->isReferenceType() && "prvalue reference?"); 7068 assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() == 7069 FD->getParent()->getCanonicalDecl() && "record / field mismatch"); 7070 7071 // Note: there is no lvalue base here. But this case should only ever 7072 // happen in C or in C++98, where we cannot be evaluating a constexpr 7073 // constructor, which is the only case the base matters. 7074 CompleteObject Obj(APValue::LValueBase(), &Val, BaseTy); 7075 SubobjectDesignator Designator(BaseTy); 7076 Designator.addDeclUnchecked(FD); 7077 7078 APValue Result; 7079 return extractSubobject(Info, E, Obj, Designator, Result) && 7080 DerivedSuccess(Result, E); 7081 } 7082 7083 bool VisitCastExpr(const CastExpr *E) { 7084 switch (E->getCastKind()) { 7085 default: 7086 break; 7087 7088 case CK_AtomicToNonAtomic: { 7089 APValue AtomicVal; 7090 // This does not need to be done in place even for class/array types: 7091 // atomic-to-non-atomic conversion implies copying the object 7092 // representation. 7093 if (!Evaluate(AtomicVal, Info, E->getSubExpr())) 7094 return false; 7095 return DerivedSuccess(AtomicVal, E); 7096 } 7097 7098 case CK_NoOp: 7099 case CK_UserDefinedConversion: 7100 return StmtVisitorTy::Visit(E->getSubExpr()); 7101 7102 case CK_LValueToRValue: { 7103 LValue LVal; 7104 if (!EvaluateLValue(E->getSubExpr(), LVal, Info)) 7105 return false; 7106 APValue RVal; 7107 // Note, we use the subexpression's type in order to retain cv-qualifiers. 7108 if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(), 7109 LVal, RVal)) 7110 return false; 7111 return DerivedSuccess(RVal, E); 7112 } 7113 case CK_LValueToRValueBitCast: { 7114 APValue DestValue, SourceValue; 7115 if (!Evaluate(SourceValue, Info, E->getSubExpr())) 7116 return false; 7117 if (!handleLValueToRValueBitCast(Info, DestValue, SourceValue, E)) 7118 return false; 7119 return DerivedSuccess(DestValue, E); 7120 } 7121 7122 case CK_AddressSpaceConversion: { 7123 APValue Value; 7124 if (!Evaluate(Value, Info, E->getSubExpr())) 7125 return false; 7126 return DerivedSuccess(Value, E); 7127 } 7128 } 7129 7130 return Error(E); 7131 } 7132 7133 bool VisitUnaryPostInc(const UnaryOperator *UO) { 7134 return VisitUnaryPostIncDec(UO); 7135 } 7136 bool VisitUnaryPostDec(const UnaryOperator *UO) { 7137 return VisitUnaryPostIncDec(UO); 7138 } 7139 bool VisitUnaryPostIncDec(const UnaryOperator *UO) { 7140 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure()) 7141 return Error(UO); 7142 7143 LValue LVal; 7144 if (!EvaluateLValue(UO->getSubExpr(), LVal, Info)) 7145 return false; 7146 APValue RVal; 7147 if (!handleIncDec(this->Info, UO, LVal, UO->getSubExpr()->getType(), 7148 UO->isIncrementOp(), &RVal)) 7149 return false; 7150 return DerivedSuccess(RVal, UO); 7151 } 7152 7153 bool VisitStmtExpr(const StmtExpr *E) { 7154 // We will have checked the full-expressions inside the statement expression 7155 // when they were completed, and don't need to check them again now. 7156 if (Info.checkingForUndefinedBehavior()) 7157 return Error(E); 7158 7159 const CompoundStmt *CS = E->getSubStmt(); 7160 if (CS->body_empty()) 7161 return true; 7162 7163 BlockScopeRAII Scope(Info); 7164 for (CompoundStmt::const_body_iterator BI = CS->body_begin(), 7165 BE = CS->body_end(); 7166 /**/; ++BI) { 7167 if (BI + 1 == BE) { 7168 const Expr *FinalExpr = dyn_cast<Expr>(*BI); 7169 if (!FinalExpr) { 7170 Info.FFDiag((*BI)->getBeginLoc(), 7171 diag::note_constexpr_stmt_expr_unsupported); 7172 return false; 7173 } 7174 return this->Visit(FinalExpr) && Scope.destroy(); 7175 } 7176 7177 APValue ReturnValue; 7178 StmtResult Result = { ReturnValue, nullptr }; 7179 EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI); 7180 if (ESR != ESR_Succeeded) { 7181 // FIXME: If the statement-expression terminated due to 'return', 7182 // 'break', or 'continue', it would be nice to propagate that to 7183 // the outer statement evaluation rather than bailing out. 7184 if (ESR != ESR_Failed) 7185 Info.FFDiag((*BI)->getBeginLoc(), 7186 diag::note_constexpr_stmt_expr_unsupported); 7187 return false; 7188 } 7189 } 7190 7191 llvm_unreachable("Return from function from the loop above."); 7192 } 7193 7194 /// Visit a value which is evaluated, but whose value is ignored. 7195 void VisitIgnoredValue(const Expr *E) { 7196 EvaluateIgnoredValue(Info, E); 7197 } 7198 7199 /// Potentially visit a MemberExpr's base expression. 7200 void VisitIgnoredBaseExpression(const Expr *E) { 7201 // While MSVC doesn't evaluate the base expression, it does diagnose the 7202 // presence of side-effecting behavior. 7203 if (Info.getLangOpts().MSVCCompat && !E->HasSideEffects(Info.Ctx)) 7204 return; 7205 VisitIgnoredValue(E); 7206 } 7207 }; 7208 7209 } // namespace 7210 7211 //===----------------------------------------------------------------------===// 7212 // Common base class for lvalue and temporary evaluation. 7213 //===----------------------------------------------------------------------===// 7214 namespace { 7215 template<class Derived> 7216 class LValueExprEvaluatorBase 7217 : public ExprEvaluatorBase<Derived> { 7218 protected: 7219 LValue &Result; 7220 bool InvalidBaseOK; 7221 typedef LValueExprEvaluatorBase LValueExprEvaluatorBaseTy; 7222 typedef ExprEvaluatorBase<Derived> ExprEvaluatorBaseTy; 7223 7224 bool Success(APValue::LValueBase B) { 7225 Result.set(B); 7226 return true; 7227 } 7228 7229 bool evaluatePointer(const Expr *E, LValue &Result) { 7230 return EvaluatePointer(E, Result, this->Info, InvalidBaseOK); 7231 } 7232 7233 public: 7234 LValueExprEvaluatorBase(EvalInfo &Info, LValue &Result, bool InvalidBaseOK) 7235 : ExprEvaluatorBaseTy(Info), Result(Result), 7236 InvalidBaseOK(InvalidBaseOK) {} 7237 7238 bool Success(const APValue &V, const Expr *E) { 7239 Result.setFrom(this->Info.Ctx, V); 7240 return true; 7241 } 7242 7243 bool VisitMemberExpr(const MemberExpr *E) { 7244 // Handle non-static data members. 7245 QualType BaseTy; 7246 bool EvalOK; 7247 if (E->isArrow()) { 7248 EvalOK = evaluatePointer(E->getBase(), Result); 7249 BaseTy = E->getBase()->getType()->castAs<PointerType>()->getPointeeType(); 7250 } else if (E->getBase()->isRValue()) { 7251 assert(E->getBase()->getType()->isRecordType()); 7252 EvalOK = EvaluateTemporary(E->getBase(), Result, this->Info); 7253 BaseTy = E->getBase()->getType(); 7254 } else { 7255 EvalOK = this->Visit(E->getBase()); 7256 BaseTy = E->getBase()->getType(); 7257 } 7258 if (!EvalOK) { 7259 if (!InvalidBaseOK) 7260 return false; 7261 Result.setInvalid(E); 7262 return true; 7263 } 7264 7265 const ValueDecl *MD = E->getMemberDecl(); 7266 if (const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) { 7267 assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() == 7268 FD->getParent()->getCanonicalDecl() && "record / field mismatch"); 7269 (void)BaseTy; 7270 if (!HandleLValueMember(this->Info, E, Result, FD)) 7271 return false; 7272 } else if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(MD)) { 7273 if (!HandleLValueIndirectMember(this->Info, E, Result, IFD)) 7274 return false; 7275 } else 7276 return this->Error(E); 7277 7278 if (MD->getType()->isReferenceType()) { 7279 APValue RefValue; 7280 if (!handleLValueToRValueConversion(this->Info, E, MD->getType(), Result, 7281 RefValue)) 7282 return false; 7283 return Success(RefValue, E); 7284 } 7285 return true; 7286 } 7287 7288 bool VisitBinaryOperator(const BinaryOperator *E) { 7289 switch (E->getOpcode()) { 7290 default: 7291 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 7292 7293 case BO_PtrMemD: 7294 case BO_PtrMemI: 7295 return HandleMemberPointerAccess(this->Info, E, Result); 7296 } 7297 } 7298 7299 bool VisitCastExpr(const CastExpr *E) { 7300 switch (E->getCastKind()) { 7301 default: 7302 return ExprEvaluatorBaseTy::VisitCastExpr(E); 7303 7304 case CK_DerivedToBase: 7305 case CK_UncheckedDerivedToBase: 7306 if (!this->Visit(E->getSubExpr())) 7307 return false; 7308 7309 // Now figure out the necessary offset to add to the base LV to get from 7310 // the derived class to the base class. 7311 return HandleLValueBasePath(this->Info, E, E->getSubExpr()->getType(), 7312 Result); 7313 } 7314 } 7315 }; 7316 } 7317 7318 //===----------------------------------------------------------------------===// 7319 // LValue Evaluation 7320 // 7321 // This is used for evaluating lvalues (in C and C++), xvalues (in C++11), 7322 // function designators (in C), decl references to void objects (in C), and 7323 // temporaries (if building with -Wno-address-of-temporary). 7324 // 7325 // LValue evaluation produces values comprising a base expression of one of the 7326 // following types: 7327 // - Declarations 7328 // * VarDecl 7329 // * FunctionDecl 7330 // - Literals 7331 // * CompoundLiteralExpr in C (and in global scope in C++) 7332 // * StringLiteral 7333 // * PredefinedExpr 7334 // * ObjCStringLiteralExpr 7335 // * ObjCEncodeExpr 7336 // * AddrLabelExpr 7337 // * BlockExpr 7338 // * CallExpr for a MakeStringConstant builtin 7339 // - typeid(T) expressions, as TypeInfoLValues 7340 // - Locals and temporaries 7341 // * MaterializeTemporaryExpr 7342 // * Any Expr, with a CallIndex indicating the function in which the temporary 7343 // was evaluated, for cases where the MaterializeTemporaryExpr is missing 7344 // from the AST (FIXME). 7345 // * A MaterializeTemporaryExpr that has static storage duration, with no 7346 // CallIndex, for a lifetime-extended temporary. 7347 // plus an offset in bytes. 7348 //===----------------------------------------------------------------------===// 7349 namespace { 7350 class LValueExprEvaluator 7351 : public LValueExprEvaluatorBase<LValueExprEvaluator> { 7352 public: 7353 LValueExprEvaluator(EvalInfo &Info, LValue &Result, bool InvalidBaseOK) : 7354 LValueExprEvaluatorBaseTy(Info, Result, InvalidBaseOK) {} 7355 7356 bool VisitVarDecl(const Expr *E, const VarDecl *VD); 7357 bool VisitUnaryPreIncDec(const UnaryOperator *UO); 7358 7359 bool VisitDeclRefExpr(const DeclRefExpr *E); 7360 bool VisitPredefinedExpr(const PredefinedExpr *E) { return Success(E); } 7361 bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E); 7362 bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E); 7363 bool VisitMemberExpr(const MemberExpr *E); 7364 bool VisitStringLiteral(const StringLiteral *E) { return Success(E); } 7365 bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { return Success(E); } 7366 bool VisitCXXTypeidExpr(const CXXTypeidExpr *E); 7367 bool VisitCXXUuidofExpr(const CXXUuidofExpr *E); 7368 bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E); 7369 bool VisitUnaryDeref(const UnaryOperator *E); 7370 bool VisitUnaryReal(const UnaryOperator *E); 7371 bool VisitUnaryImag(const UnaryOperator *E); 7372 bool VisitUnaryPreInc(const UnaryOperator *UO) { 7373 return VisitUnaryPreIncDec(UO); 7374 } 7375 bool VisitUnaryPreDec(const UnaryOperator *UO) { 7376 return VisitUnaryPreIncDec(UO); 7377 } 7378 bool VisitBinAssign(const BinaryOperator *BO); 7379 bool VisitCompoundAssignOperator(const CompoundAssignOperator *CAO); 7380 7381 bool VisitCastExpr(const CastExpr *E) { 7382 switch (E->getCastKind()) { 7383 default: 7384 return LValueExprEvaluatorBaseTy::VisitCastExpr(E); 7385 7386 case CK_LValueBitCast: 7387 this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2; 7388 if (!Visit(E->getSubExpr())) 7389 return false; 7390 Result.Designator.setInvalid(); 7391 return true; 7392 7393 case CK_BaseToDerived: 7394 if (!Visit(E->getSubExpr())) 7395 return false; 7396 return HandleBaseToDerivedCast(Info, E, Result); 7397 7398 case CK_Dynamic: 7399 if (!Visit(E->getSubExpr())) 7400 return false; 7401 return HandleDynamicCast(Info, cast<ExplicitCastExpr>(E), Result); 7402 } 7403 } 7404 }; 7405 } // end anonymous namespace 7406 7407 /// Evaluate an expression as an lvalue. This can be legitimately called on 7408 /// expressions which are not glvalues, in three cases: 7409 /// * function designators in C, and 7410 /// * "extern void" objects 7411 /// * @selector() expressions in Objective-C 7412 static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info, 7413 bool InvalidBaseOK) { 7414 assert(E->isGLValue() || E->getType()->isFunctionType() || 7415 E->getType()->isVoidType() || isa<ObjCSelectorExpr>(E)); 7416 return LValueExprEvaluator(Info, Result, InvalidBaseOK).Visit(E); 7417 } 7418 7419 bool LValueExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) { 7420 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(E->getDecl())) 7421 return Success(FD); 7422 if (const VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) 7423 return VisitVarDecl(E, VD); 7424 if (const BindingDecl *BD = dyn_cast<BindingDecl>(E->getDecl())) 7425 return Visit(BD->getBinding()); 7426 return Error(E); 7427 } 7428 7429 7430 bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) { 7431 7432 // If we are within a lambda's call operator, check whether the 'VD' referred 7433 // to within 'E' actually represents a lambda-capture that maps to a 7434 // data-member/field within the closure object, and if so, evaluate to the 7435 // field or what the field refers to. 7436 if (Info.CurrentCall && isLambdaCallOperator(Info.CurrentCall->Callee) && 7437 isa<DeclRefExpr>(E) && 7438 cast<DeclRefExpr>(E)->refersToEnclosingVariableOrCapture()) { 7439 // We don't always have a complete capture-map when checking or inferring if 7440 // the function call operator meets the requirements of a constexpr function 7441 // - but we don't need to evaluate the captures to determine constexprness 7442 // (dcl.constexpr C++17). 7443 if (Info.checkingPotentialConstantExpression()) 7444 return false; 7445 7446 if (auto *FD = Info.CurrentCall->LambdaCaptureFields.lookup(VD)) { 7447 // Start with 'Result' referring to the complete closure object... 7448 Result = *Info.CurrentCall->This; 7449 // ... then update it to refer to the field of the closure object 7450 // that represents the capture. 7451 if (!HandleLValueMember(Info, E, Result, FD)) 7452 return false; 7453 // And if the field is of reference type, update 'Result' to refer to what 7454 // the field refers to. 7455 if (FD->getType()->isReferenceType()) { 7456 APValue RVal; 7457 if (!handleLValueToRValueConversion(Info, E, FD->getType(), Result, 7458 RVal)) 7459 return false; 7460 Result.setFrom(Info.Ctx, RVal); 7461 } 7462 return true; 7463 } 7464 } 7465 CallStackFrame *Frame = nullptr; 7466 if (VD->hasLocalStorage() && Info.CurrentCall->Index > 1) { 7467 // Only if a local variable was declared in the function currently being 7468 // evaluated, do we expect to be able to find its value in the current 7469 // frame. (Otherwise it was likely declared in an enclosing context and 7470 // could either have a valid evaluatable value (for e.g. a constexpr 7471 // variable) or be ill-formed (and trigger an appropriate evaluation 7472 // diagnostic)). 7473 if (Info.CurrentCall->Callee && 7474 Info.CurrentCall->Callee->Equals(VD->getDeclContext())) { 7475 Frame = Info.CurrentCall; 7476 } 7477 } 7478 7479 if (!VD->getType()->isReferenceType()) { 7480 if (Frame) { 7481 Result.set({VD, Frame->Index, 7482 Info.CurrentCall->getCurrentTemporaryVersion(VD)}); 7483 return true; 7484 } 7485 return Success(VD); 7486 } 7487 7488 APValue *V; 7489 if (!evaluateVarDeclInit(Info, E, VD, Frame, V, nullptr)) 7490 return false; 7491 if (!V->hasValue()) { 7492 // FIXME: Is it possible for V to be indeterminate here? If so, we should 7493 // adjust the diagnostic to say that. 7494 if (!Info.checkingPotentialConstantExpression()) 7495 Info.FFDiag(E, diag::note_constexpr_use_uninit_reference); 7496 return false; 7497 } 7498 return Success(*V, E); 7499 } 7500 7501 bool LValueExprEvaluator::VisitMaterializeTemporaryExpr( 7502 const MaterializeTemporaryExpr *E) { 7503 // Walk through the expression to find the materialized temporary itself. 7504 SmallVector<const Expr *, 2> CommaLHSs; 7505 SmallVector<SubobjectAdjustment, 2> Adjustments; 7506 const Expr *Inner = 7507 E->getSubExpr()->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments); 7508 7509 // If we passed any comma operators, evaluate their LHSs. 7510 for (unsigned I = 0, N = CommaLHSs.size(); I != N; ++I) 7511 if (!EvaluateIgnoredValue(Info, CommaLHSs[I])) 7512 return false; 7513 7514 // A materialized temporary with static storage duration can appear within the 7515 // result of a constant expression evaluation, so we need to preserve its 7516 // value for use outside this evaluation. 7517 APValue *Value; 7518 if (E->getStorageDuration() == SD_Static) { 7519 Value = E->getOrCreateValue(true); 7520 *Value = APValue(); 7521 Result.set(E); 7522 } else { 7523 Value = &Info.CurrentCall->createTemporary( 7524 E, E->getType(), E->getStorageDuration() == SD_Automatic, Result); 7525 } 7526 7527 QualType Type = Inner->getType(); 7528 7529 // Materialize the temporary itself. 7530 if (!EvaluateInPlace(*Value, Info, Result, Inner)) { 7531 *Value = APValue(); 7532 return false; 7533 } 7534 7535 // Adjust our lvalue to refer to the desired subobject. 7536 for (unsigned I = Adjustments.size(); I != 0; /**/) { 7537 --I; 7538 switch (Adjustments[I].Kind) { 7539 case SubobjectAdjustment::DerivedToBaseAdjustment: 7540 if (!HandleLValueBasePath(Info, Adjustments[I].DerivedToBase.BasePath, 7541 Type, Result)) 7542 return false; 7543 Type = Adjustments[I].DerivedToBase.BasePath->getType(); 7544 break; 7545 7546 case SubobjectAdjustment::FieldAdjustment: 7547 if (!HandleLValueMember(Info, E, Result, Adjustments[I].Field)) 7548 return false; 7549 Type = Adjustments[I].Field->getType(); 7550 break; 7551 7552 case SubobjectAdjustment::MemberPointerAdjustment: 7553 if (!HandleMemberPointerAccess(this->Info, Type, Result, 7554 Adjustments[I].Ptr.RHS)) 7555 return false; 7556 Type = Adjustments[I].Ptr.MPT->getPointeeType(); 7557 break; 7558 } 7559 } 7560 7561 return true; 7562 } 7563 7564 bool 7565 LValueExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) { 7566 assert((!Info.getLangOpts().CPlusPlus || E->isFileScope()) && 7567 "lvalue compound literal in c++?"); 7568 // Defer visiting the literal until the lvalue-to-rvalue conversion. We can 7569 // only see this when folding in C, so there's no standard to follow here. 7570 return Success(E); 7571 } 7572 7573 bool LValueExprEvaluator::VisitCXXTypeidExpr(const CXXTypeidExpr *E) { 7574 TypeInfoLValue TypeInfo; 7575 7576 if (!E->isPotentiallyEvaluated()) { 7577 if (E->isTypeOperand()) 7578 TypeInfo = TypeInfoLValue(E->getTypeOperand(Info.Ctx).getTypePtr()); 7579 else 7580 TypeInfo = TypeInfoLValue(E->getExprOperand()->getType().getTypePtr()); 7581 } else { 7582 if (!Info.Ctx.getLangOpts().CPlusPlus2a) { 7583 Info.CCEDiag(E, diag::note_constexpr_typeid_polymorphic) 7584 << E->getExprOperand()->getType() 7585 << E->getExprOperand()->getSourceRange(); 7586 } 7587 7588 if (!Visit(E->getExprOperand())) 7589 return false; 7590 7591 Optional<DynamicType> DynType = 7592 ComputeDynamicType(Info, E, Result, AK_TypeId); 7593 if (!DynType) 7594 return false; 7595 7596 TypeInfo = 7597 TypeInfoLValue(Info.Ctx.getRecordType(DynType->Type).getTypePtr()); 7598 } 7599 7600 return Success(APValue::LValueBase::getTypeInfo(TypeInfo, E->getType())); 7601 } 7602 7603 bool LValueExprEvaluator::VisitCXXUuidofExpr(const CXXUuidofExpr *E) { 7604 return Success(E); 7605 } 7606 7607 bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) { 7608 // Handle static data members. 7609 if (const VarDecl *VD = dyn_cast<VarDecl>(E->getMemberDecl())) { 7610 VisitIgnoredBaseExpression(E->getBase()); 7611 return VisitVarDecl(E, VD); 7612 } 7613 7614 // Handle static member functions. 7615 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) { 7616 if (MD->isStatic()) { 7617 VisitIgnoredBaseExpression(E->getBase()); 7618 return Success(MD); 7619 } 7620 } 7621 7622 // Handle non-static data members. 7623 return LValueExprEvaluatorBaseTy::VisitMemberExpr(E); 7624 } 7625 7626 bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) { 7627 // FIXME: Deal with vectors as array subscript bases. 7628 if (E->getBase()->getType()->isVectorType()) 7629 return Error(E); 7630 7631 bool Success = true; 7632 if (!evaluatePointer(E->getBase(), Result)) { 7633 if (!Info.noteFailure()) 7634 return false; 7635 Success = false; 7636 } 7637 7638 APSInt Index; 7639 if (!EvaluateInteger(E->getIdx(), Index, Info)) 7640 return false; 7641 7642 return Success && 7643 HandleLValueArrayAdjustment(Info, E, Result, E->getType(), Index); 7644 } 7645 7646 bool LValueExprEvaluator::VisitUnaryDeref(const UnaryOperator *E) { 7647 return evaluatePointer(E->getSubExpr(), Result); 7648 } 7649 7650 bool LValueExprEvaluator::VisitUnaryReal(const UnaryOperator *E) { 7651 if (!Visit(E->getSubExpr())) 7652 return false; 7653 // __real is a no-op on scalar lvalues. 7654 if (E->getSubExpr()->getType()->isAnyComplexType()) 7655 HandleLValueComplexElement(Info, E, Result, E->getType(), false); 7656 return true; 7657 } 7658 7659 bool LValueExprEvaluator::VisitUnaryImag(const UnaryOperator *E) { 7660 assert(E->getSubExpr()->getType()->isAnyComplexType() && 7661 "lvalue __imag__ on scalar?"); 7662 if (!Visit(E->getSubExpr())) 7663 return false; 7664 HandleLValueComplexElement(Info, E, Result, E->getType(), true); 7665 return true; 7666 } 7667 7668 bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) { 7669 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure()) 7670 return Error(UO); 7671 7672 if (!this->Visit(UO->getSubExpr())) 7673 return false; 7674 7675 return handleIncDec( 7676 this->Info, UO, Result, UO->getSubExpr()->getType(), 7677 UO->isIncrementOp(), nullptr); 7678 } 7679 7680 bool LValueExprEvaluator::VisitCompoundAssignOperator( 7681 const CompoundAssignOperator *CAO) { 7682 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure()) 7683 return Error(CAO); 7684 7685 APValue RHS; 7686 7687 // The overall lvalue result is the result of evaluating the LHS. 7688 if (!this->Visit(CAO->getLHS())) { 7689 if (Info.noteFailure()) 7690 Evaluate(RHS, this->Info, CAO->getRHS()); 7691 return false; 7692 } 7693 7694 if (!Evaluate(RHS, this->Info, CAO->getRHS())) 7695 return false; 7696 7697 return handleCompoundAssignment( 7698 this->Info, CAO, 7699 Result, CAO->getLHS()->getType(), CAO->getComputationLHSType(), 7700 CAO->getOpForCompoundAssignment(CAO->getOpcode()), RHS); 7701 } 7702 7703 bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) { 7704 if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure()) 7705 return Error(E); 7706 7707 APValue NewVal; 7708 7709 if (!this->Visit(E->getLHS())) { 7710 if (Info.noteFailure()) 7711 Evaluate(NewVal, this->Info, E->getRHS()); 7712 return false; 7713 } 7714 7715 if (!Evaluate(NewVal, this->Info, E->getRHS())) 7716 return false; 7717 7718 if (Info.getLangOpts().CPlusPlus2a && 7719 !HandleUnionActiveMemberChange(Info, E->getLHS(), Result)) 7720 return false; 7721 7722 return handleAssignment(this->Info, E, Result, E->getLHS()->getType(), 7723 NewVal); 7724 } 7725 7726 //===----------------------------------------------------------------------===// 7727 // Pointer Evaluation 7728 //===----------------------------------------------------------------------===// 7729 7730 /// Attempts to compute the number of bytes available at the pointer 7731 /// returned by a function with the alloc_size attribute. Returns true if we 7732 /// were successful. Places an unsigned number into `Result`. 7733 /// 7734 /// This expects the given CallExpr to be a call to a function with an 7735 /// alloc_size attribute. 7736 static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx, 7737 const CallExpr *Call, 7738 llvm::APInt &Result) { 7739 const AllocSizeAttr *AllocSize = getAllocSizeAttr(Call); 7740 7741 assert(AllocSize && AllocSize->getElemSizeParam().isValid()); 7742 unsigned SizeArgNo = AllocSize->getElemSizeParam().getASTIndex(); 7743 unsigned BitsInSizeT = Ctx.getTypeSize(Ctx.getSizeType()); 7744 if (Call->getNumArgs() <= SizeArgNo) 7745 return false; 7746 7747 auto EvaluateAsSizeT = [&](const Expr *E, APSInt &Into) { 7748 Expr::EvalResult ExprResult; 7749 if (!E->EvaluateAsInt(ExprResult, Ctx, Expr::SE_AllowSideEffects)) 7750 return false; 7751 Into = ExprResult.Val.getInt(); 7752 if (Into.isNegative() || !Into.isIntN(BitsInSizeT)) 7753 return false; 7754 Into = Into.zextOrSelf(BitsInSizeT); 7755 return true; 7756 }; 7757 7758 APSInt SizeOfElem; 7759 if (!EvaluateAsSizeT(Call->getArg(SizeArgNo), SizeOfElem)) 7760 return false; 7761 7762 if (!AllocSize->getNumElemsParam().isValid()) { 7763 Result = std::move(SizeOfElem); 7764 return true; 7765 } 7766 7767 APSInt NumberOfElems; 7768 unsigned NumArgNo = AllocSize->getNumElemsParam().getASTIndex(); 7769 if (!EvaluateAsSizeT(Call->getArg(NumArgNo), NumberOfElems)) 7770 return false; 7771 7772 bool Overflow; 7773 llvm::APInt BytesAvailable = SizeOfElem.umul_ov(NumberOfElems, Overflow); 7774 if (Overflow) 7775 return false; 7776 7777 Result = std::move(BytesAvailable); 7778 return true; 7779 } 7780 7781 /// Convenience function. LVal's base must be a call to an alloc_size 7782 /// function. 7783 static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx, 7784 const LValue &LVal, 7785 llvm::APInt &Result) { 7786 assert(isBaseAnAllocSizeCall(LVal.getLValueBase()) && 7787 "Can't get the size of a non alloc_size function"); 7788 const auto *Base = LVal.getLValueBase().get<const Expr *>(); 7789 const CallExpr *CE = tryUnwrapAllocSizeCall(Base); 7790 return getBytesReturnedByAllocSizeCall(Ctx, CE, Result); 7791 } 7792 7793 /// Attempts to evaluate the given LValueBase as the result of a call to 7794 /// a function with the alloc_size attribute. If it was possible to do so, this 7795 /// function will return true, make Result's Base point to said function call, 7796 /// and mark Result's Base as invalid. 7797 static bool evaluateLValueAsAllocSize(EvalInfo &Info, APValue::LValueBase Base, 7798 LValue &Result) { 7799 if (Base.isNull()) 7800 return false; 7801 7802 // Because we do no form of static analysis, we only support const variables. 7803 // 7804 // Additionally, we can't support parameters, nor can we support static 7805 // variables (in the latter case, use-before-assign isn't UB; in the former, 7806 // we have no clue what they'll be assigned to). 7807 const auto *VD = 7808 dyn_cast_or_null<VarDecl>(Base.dyn_cast<const ValueDecl *>()); 7809 if (!VD || !VD->isLocalVarDecl() || !VD->getType().isConstQualified()) 7810 return false; 7811 7812 const Expr *Init = VD->getAnyInitializer(); 7813 if (!Init) 7814 return false; 7815 7816 const Expr *E = Init->IgnoreParens(); 7817 if (!tryUnwrapAllocSizeCall(E)) 7818 return false; 7819 7820 // Store E instead of E unwrapped so that the type of the LValue's base is 7821 // what the user wanted. 7822 Result.setInvalid(E); 7823 7824 QualType Pointee = E->getType()->castAs<PointerType>()->getPointeeType(); 7825 Result.addUnsizedArray(Info, E, Pointee); 7826 return true; 7827 } 7828 7829 namespace { 7830 class PointerExprEvaluator 7831 : public ExprEvaluatorBase<PointerExprEvaluator> { 7832 LValue &Result; 7833 bool InvalidBaseOK; 7834 7835 bool Success(const Expr *E) { 7836 Result.set(E); 7837 return true; 7838 } 7839 7840 bool evaluateLValue(const Expr *E, LValue &Result) { 7841 return EvaluateLValue(E, Result, Info, InvalidBaseOK); 7842 } 7843 7844 bool evaluatePointer(const Expr *E, LValue &Result) { 7845 return EvaluatePointer(E, Result, Info, InvalidBaseOK); 7846 } 7847 7848 bool visitNonBuiltinCallExpr(const CallExpr *E); 7849 public: 7850 7851 PointerExprEvaluator(EvalInfo &info, LValue &Result, bool InvalidBaseOK) 7852 : ExprEvaluatorBaseTy(info), Result(Result), 7853 InvalidBaseOK(InvalidBaseOK) {} 7854 7855 bool Success(const APValue &V, const Expr *E) { 7856 Result.setFrom(Info.Ctx, V); 7857 return true; 7858 } 7859 bool ZeroInitialization(const Expr *E) { 7860 Result.setNull(Info.Ctx, E->getType()); 7861 return true; 7862 } 7863 7864 bool VisitBinaryOperator(const BinaryOperator *E); 7865 bool VisitCastExpr(const CastExpr* E); 7866 bool VisitUnaryAddrOf(const UnaryOperator *E); 7867 bool VisitObjCStringLiteral(const ObjCStringLiteral *E) 7868 { return Success(E); } 7869 bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E) { 7870 if (E->isExpressibleAsConstantInitializer()) 7871 return Success(E); 7872 if (Info.noteFailure()) 7873 EvaluateIgnoredValue(Info, E->getSubExpr()); 7874 return Error(E); 7875 } 7876 bool VisitAddrLabelExpr(const AddrLabelExpr *E) 7877 { return Success(E); } 7878 bool VisitCallExpr(const CallExpr *E); 7879 bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp); 7880 bool VisitBlockExpr(const BlockExpr *E) { 7881 if (!E->getBlockDecl()->hasCaptures()) 7882 return Success(E); 7883 return Error(E); 7884 } 7885 bool VisitCXXThisExpr(const CXXThisExpr *E) { 7886 // Can't look at 'this' when checking a potential constant expression. 7887 if (Info.checkingPotentialConstantExpression()) 7888 return false; 7889 if (!Info.CurrentCall->This) { 7890 if (Info.getLangOpts().CPlusPlus11) 7891 Info.FFDiag(E, diag::note_constexpr_this) << E->isImplicit(); 7892 else 7893 Info.FFDiag(E); 7894 return false; 7895 } 7896 Result = *Info.CurrentCall->This; 7897 // If we are inside a lambda's call operator, the 'this' expression refers 7898 // to the enclosing '*this' object (either by value or reference) which is 7899 // either copied into the closure object's field that represents the '*this' 7900 // or refers to '*this'. 7901 if (isLambdaCallOperator(Info.CurrentCall->Callee)) { 7902 // Ensure we actually have captured 'this'. (an error will have 7903 // been previously reported if not). 7904 if (!Info.CurrentCall->LambdaThisCaptureField) 7905 return false; 7906 7907 // Update 'Result' to refer to the data member/field of the closure object 7908 // that represents the '*this' capture. 7909 if (!HandleLValueMember(Info, E, Result, 7910 Info.CurrentCall->LambdaThisCaptureField)) 7911 return false; 7912 // If we captured '*this' by reference, replace the field with its referent. 7913 if (Info.CurrentCall->LambdaThisCaptureField->getType() 7914 ->isPointerType()) { 7915 APValue RVal; 7916 if (!handleLValueToRValueConversion(Info, E, E->getType(), Result, 7917 RVal)) 7918 return false; 7919 7920 Result.setFrom(Info.Ctx, RVal); 7921 } 7922 } 7923 return true; 7924 } 7925 7926 bool VisitCXXNewExpr(const CXXNewExpr *E); 7927 7928 bool VisitSourceLocExpr(const SourceLocExpr *E) { 7929 assert(E->isStringType() && "SourceLocExpr isn't a pointer type?"); 7930 APValue LValResult = E->EvaluateInContext( 7931 Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr()); 7932 Result.setFrom(Info.Ctx, LValResult); 7933 return true; 7934 } 7935 7936 // FIXME: Missing: @protocol, @selector 7937 }; 7938 } // end anonymous namespace 7939 7940 static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info, 7941 bool InvalidBaseOK) { 7942 assert(E->isRValue() && E->getType()->hasPointerRepresentation()); 7943 return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E); 7944 } 7945 7946 bool PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { 7947 if (E->getOpcode() != BO_Add && 7948 E->getOpcode() != BO_Sub) 7949 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 7950 7951 const Expr *PExp = E->getLHS(); 7952 const Expr *IExp = E->getRHS(); 7953 if (IExp->getType()->isPointerType()) 7954 std::swap(PExp, IExp); 7955 7956 bool EvalPtrOK = evaluatePointer(PExp, Result); 7957 if (!EvalPtrOK && !Info.noteFailure()) 7958 return false; 7959 7960 llvm::APSInt Offset; 7961 if (!EvaluateInteger(IExp, Offset, Info) || !EvalPtrOK) 7962 return false; 7963 7964 if (E->getOpcode() == BO_Sub) 7965 negateAsSigned(Offset); 7966 7967 QualType Pointee = PExp->getType()->castAs<PointerType>()->getPointeeType(); 7968 return HandleLValueArrayAdjustment(Info, E, Result, Pointee, Offset); 7969 } 7970 7971 bool PointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) { 7972 return evaluateLValue(E->getSubExpr(), Result); 7973 } 7974 7975 bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) { 7976 const Expr *SubExpr = E->getSubExpr(); 7977 7978 switch (E->getCastKind()) { 7979 default: 7980 break; 7981 case CK_BitCast: 7982 case CK_CPointerToObjCPointerCast: 7983 case CK_BlockPointerToObjCPointerCast: 7984 case CK_AnyPointerToBlockPointerCast: 7985 case CK_AddressSpaceConversion: 7986 if (!Visit(SubExpr)) 7987 return false; 7988 // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are 7989 // permitted in constant expressions in C++11. Bitcasts from cv void* are 7990 // also static_casts, but we disallow them as a resolution to DR1312. 7991 if (!E->getType()->isVoidPointerType()) { 7992 if (!Result.InvalidBase && !Result.Designator.Invalid && 7993 !Result.IsNullPtr && 7994 Info.Ctx.hasSameUnqualifiedType(Result.Designator.getType(Info.Ctx), 7995 E->getType()->getPointeeType()) && 7996 Info.getStdAllocatorCaller("allocate")) { 7997 // Inside a call to std::allocator::allocate and friends, we permit 7998 // casting from void* back to cv1 T* for a pointer that points to a 7999 // cv2 T. 8000 } else { 8001 Result.Designator.setInvalid(); 8002 if (SubExpr->getType()->isVoidPointerType()) 8003 CCEDiag(E, diag::note_constexpr_invalid_cast) 8004 << 3 << SubExpr->getType(); 8005 else 8006 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2; 8007 } 8008 } 8009 if (E->getCastKind() == CK_AddressSpaceConversion && Result.IsNullPtr) 8010 ZeroInitialization(E); 8011 return true; 8012 8013 case CK_DerivedToBase: 8014 case CK_UncheckedDerivedToBase: 8015 if (!evaluatePointer(E->getSubExpr(), Result)) 8016 return false; 8017 if (!Result.Base && Result.Offset.isZero()) 8018 return true; 8019 8020 // Now figure out the necessary offset to add to the base LV to get from 8021 // the derived class to the base class. 8022 return HandleLValueBasePath(Info, E, E->getSubExpr()->getType()-> 8023 castAs<PointerType>()->getPointeeType(), 8024 Result); 8025 8026 case CK_BaseToDerived: 8027 if (!Visit(E->getSubExpr())) 8028 return false; 8029 if (!Result.Base && Result.Offset.isZero()) 8030 return true; 8031 return HandleBaseToDerivedCast(Info, E, Result); 8032 8033 case CK_Dynamic: 8034 if (!Visit(E->getSubExpr())) 8035 return false; 8036 return HandleDynamicCast(Info, cast<ExplicitCastExpr>(E), Result); 8037 8038 case CK_NullToPointer: 8039 VisitIgnoredValue(E->getSubExpr()); 8040 return ZeroInitialization(E); 8041 8042 case CK_IntegralToPointer: { 8043 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2; 8044 8045 APValue Value; 8046 if (!EvaluateIntegerOrLValue(SubExpr, Value, Info)) 8047 break; 8048 8049 if (Value.isInt()) { 8050 unsigned Size = Info.Ctx.getTypeSize(E->getType()); 8051 uint64_t N = Value.getInt().extOrTrunc(Size).getZExtValue(); 8052 Result.Base = (Expr*)nullptr; 8053 Result.InvalidBase = false; 8054 Result.Offset = CharUnits::fromQuantity(N); 8055 Result.Designator.setInvalid(); 8056 Result.IsNullPtr = false; 8057 return true; 8058 } else { 8059 // Cast is of an lvalue, no need to change value. 8060 Result.setFrom(Info.Ctx, Value); 8061 return true; 8062 } 8063 } 8064 8065 case CK_ArrayToPointerDecay: { 8066 if (SubExpr->isGLValue()) { 8067 if (!evaluateLValue(SubExpr, Result)) 8068 return false; 8069 } else { 8070 APValue &Value = Info.CurrentCall->createTemporary( 8071 SubExpr, SubExpr->getType(), false, Result); 8072 if (!EvaluateInPlace(Value, Info, Result, SubExpr)) 8073 return false; 8074 } 8075 // The result is a pointer to the first element of the array. 8076 auto *AT = Info.Ctx.getAsArrayType(SubExpr->getType()); 8077 if (auto *CAT = dyn_cast<ConstantArrayType>(AT)) 8078 Result.addArray(Info, E, CAT); 8079 else 8080 Result.addUnsizedArray(Info, E, AT->getElementType()); 8081 return true; 8082 } 8083 8084 case CK_FunctionToPointerDecay: 8085 return evaluateLValue(SubExpr, Result); 8086 8087 case CK_LValueToRValue: { 8088 LValue LVal; 8089 if (!evaluateLValue(E->getSubExpr(), LVal)) 8090 return false; 8091 8092 APValue RVal; 8093 // Note, we use the subexpression's type in order to retain cv-qualifiers. 8094 if (!handleLValueToRValueConversion(Info, E, E->getSubExpr()->getType(), 8095 LVal, RVal)) 8096 return InvalidBaseOK && 8097 evaluateLValueAsAllocSize(Info, LVal.Base, Result); 8098 return Success(RVal, E); 8099 } 8100 } 8101 8102 return ExprEvaluatorBaseTy::VisitCastExpr(E); 8103 } 8104 8105 static CharUnits GetAlignOfType(EvalInfo &Info, QualType T, 8106 UnaryExprOrTypeTrait ExprKind) { 8107 // C++ [expr.alignof]p3: 8108 // When alignof is applied to a reference type, the result is the 8109 // alignment of the referenced type. 8110 if (const ReferenceType *Ref = T->getAs<ReferenceType>()) 8111 T = Ref->getPointeeType(); 8112 8113 if (T.getQualifiers().hasUnaligned()) 8114 return CharUnits::One(); 8115 8116 const bool AlignOfReturnsPreferred = 8117 Info.Ctx.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver7; 8118 8119 // __alignof is defined to return the preferred alignment. 8120 // Before 8, clang returned the preferred alignment for alignof and _Alignof 8121 // as well. 8122 if (ExprKind == UETT_PreferredAlignOf || AlignOfReturnsPreferred) 8123 return Info.Ctx.toCharUnitsFromBits( 8124 Info.Ctx.getPreferredTypeAlign(T.getTypePtr())); 8125 // alignof and _Alignof are defined to return the ABI alignment. 8126 else if (ExprKind == UETT_AlignOf) 8127 return Info.Ctx.getTypeAlignInChars(T.getTypePtr()); 8128 else 8129 llvm_unreachable("GetAlignOfType on a non-alignment ExprKind"); 8130 } 8131 8132 static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E, 8133 UnaryExprOrTypeTrait ExprKind) { 8134 E = E->IgnoreParens(); 8135 8136 // The kinds of expressions that we have special-case logic here for 8137 // should be kept up to date with the special checks for those 8138 // expressions in Sema. 8139 8140 // alignof decl is always accepted, even if it doesn't make sense: we default 8141 // to 1 in those cases. 8142 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 8143 return Info.Ctx.getDeclAlign(DRE->getDecl(), 8144 /*RefAsPointee*/true); 8145 8146 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) 8147 return Info.Ctx.getDeclAlign(ME->getMemberDecl(), 8148 /*RefAsPointee*/true); 8149 8150 return GetAlignOfType(Info, E->getType(), ExprKind); 8151 } 8152 8153 // To be clear: this happily visits unsupported builtins. Better name welcomed. 8154 bool PointerExprEvaluator::visitNonBuiltinCallExpr(const CallExpr *E) { 8155 if (ExprEvaluatorBaseTy::VisitCallExpr(E)) 8156 return true; 8157 8158 if (!(InvalidBaseOK && getAllocSizeAttr(E))) 8159 return false; 8160 8161 Result.setInvalid(E); 8162 QualType PointeeTy = E->getType()->castAs<PointerType>()->getPointeeType(); 8163 Result.addUnsizedArray(Info, E, PointeeTy); 8164 return true; 8165 } 8166 8167 bool PointerExprEvaluator::VisitCallExpr(const CallExpr *E) { 8168 if (IsStringLiteralCall(E)) 8169 return Success(E); 8170 8171 if (unsigned BuiltinOp = E->getBuiltinCallee()) 8172 return VisitBuiltinCallExpr(E, BuiltinOp); 8173 8174 return visitNonBuiltinCallExpr(E); 8175 } 8176 8177 bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, 8178 unsigned BuiltinOp) { 8179 switch (BuiltinOp) { 8180 case Builtin::BI__builtin_addressof: 8181 return evaluateLValue(E->getArg(0), Result); 8182 case Builtin::BI__builtin_assume_aligned: { 8183 // We need to be very careful here because: if the pointer does not have the 8184 // asserted alignment, then the behavior is undefined, and undefined 8185 // behavior is non-constant. 8186 if (!evaluatePointer(E->getArg(0), Result)) 8187 return false; 8188 8189 LValue OffsetResult(Result); 8190 APSInt Alignment; 8191 if (!EvaluateInteger(E->getArg(1), Alignment, Info)) 8192 return false; 8193 CharUnits Align = CharUnits::fromQuantity(Alignment.getZExtValue()); 8194 8195 if (E->getNumArgs() > 2) { 8196 APSInt Offset; 8197 if (!EvaluateInteger(E->getArg(2), Offset, Info)) 8198 return false; 8199 8200 int64_t AdditionalOffset = -Offset.getZExtValue(); 8201 OffsetResult.Offset += CharUnits::fromQuantity(AdditionalOffset); 8202 } 8203 8204 // If there is a base object, then it must have the correct alignment. 8205 if (OffsetResult.Base) { 8206 CharUnits BaseAlignment; 8207 if (const ValueDecl *VD = 8208 OffsetResult.Base.dyn_cast<const ValueDecl*>()) { 8209 BaseAlignment = Info.Ctx.getDeclAlign(VD); 8210 } else if (const Expr *E = OffsetResult.Base.dyn_cast<const Expr *>()) { 8211 BaseAlignment = GetAlignOfExpr(Info, E, UETT_AlignOf); 8212 } else { 8213 BaseAlignment = GetAlignOfType( 8214 Info, OffsetResult.Base.getTypeInfoType(), UETT_AlignOf); 8215 } 8216 8217 if (BaseAlignment < Align) { 8218 Result.Designator.setInvalid(); 8219 // FIXME: Add support to Diagnostic for long / long long. 8220 CCEDiag(E->getArg(0), 8221 diag::note_constexpr_baa_insufficient_alignment) << 0 8222 << (unsigned)BaseAlignment.getQuantity() 8223 << (unsigned)Align.getQuantity(); 8224 return false; 8225 } 8226 } 8227 8228 // The offset must also have the correct alignment. 8229 if (OffsetResult.Offset.alignTo(Align) != OffsetResult.Offset) { 8230 Result.Designator.setInvalid(); 8231 8232 (OffsetResult.Base 8233 ? CCEDiag(E->getArg(0), 8234 diag::note_constexpr_baa_insufficient_alignment) << 1 8235 : CCEDiag(E->getArg(0), 8236 diag::note_constexpr_baa_value_insufficient_alignment)) 8237 << (int)OffsetResult.Offset.getQuantity() 8238 << (unsigned)Align.getQuantity(); 8239 return false; 8240 } 8241 8242 return true; 8243 } 8244 case Builtin::BI__builtin_operator_new: 8245 return HandleOperatorNewCall(Info, E, Result); 8246 case Builtin::BI__builtin_launder: 8247 return evaluatePointer(E->getArg(0), Result); 8248 case Builtin::BIstrchr: 8249 case Builtin::BIwcschr: 8250 case Builtin::BImemchr: 8251 case Builtin::BIwmemchr: 8252 if (Info.getLangOpts().CPlusPlus11) 8253 Info.CCEDiag(E, diag::note_constexpr_invalid_function) 8254 << /*isConstexpr*/0 << /*isConstructor*/0 8255 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'"); 8256 else 8257 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr); 8258 LLVM_FALLTHROUGH; 8259 case Builtin::BI__builtin_strchr: 8260 case Builtin::BI__builtin_wcschr: 8261 case Builtin::BI__builtin_memchr: 8262 case Builtin::BI__builtin_char_memchr: 8263 case Builtin::BI__builtin_wmemchr: { 8264 if (!Visit(E->getArg(0))) 8265 return false; 8266 APSInt Desired; 8267 if (!EvaluateInteger(E->getArg(1), Desired, Info)) 8268 return false; 8269 uint64_t MaxLength = uint64_t(-1); 8270 if (BuiltinOp != Builtin::BIstrchr && 8271 BuiltinOp != Builtin::BIwcschr && 8272 BuiltinOp != Builtin::BI__builtin_strchr && 8273 BuiltinOp != Builtin::BI__builtin_wcschr) { 8274 APSInt N; 8275 if (!EvaluateInteger(E->getArg(2), N, Info)) 8276 return false; 8277 MaxLength = N.getExtValue(); 8278 } 8279 // We cannot find the value if there are no candidates to match against. 8280 if (MaxLength == 0u) 8281 return ZeroInitialization(E); 8282 if (!Result.checkNullPointerForFoldAccess(Info, E, AK_Read) || 8283 Result.Designator.Invalid) 8284 return false; 8285 QualType CharTy = Result.Designator.getType(Info.Ctx); 8286 bool IsRawByte = BuiltinOp == Builtin::BImemchr || 8287 BuiltinOp == Builtin::BI__builtin_memchr; 8288 assert(IsRawByte || 8289 Info.Ctx.hasSameUnqualifiedType( 8290 CharTy, E->getArg(0)->getType()->getPointeeType())); 8291 // Pointers to const void may point to objects of incomplete type. 8292 if (IsRawByte && CharTy->isIncompleteType()) { 8293 Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy; 8294 return false; 8295 } 8296 // Give up on byte-oriented matching against multibyte elements. 8297 // FIXME: We can compare the bytes in the correct order. 8298 if (IsRawByte && Info.Ctx.getTypeSizeInChars(CharTy) != CharUnits::One()) 8299 return false; 8300 // Figure out what value we're actually looking for (after converting to 8301 // the corresponding unsigned type if necessary). 8302 uint64_t DesiredVal; 8303 bool StopAtNull = false; 8304 switch (BuiltinOp) { 8305 case Builtin::BIstrchr: 8306 case Builtin::BI__builtin_strchr: 8307 // strchr compares directly to the passed integer, and therefore 8308 // always fails if given an int that is not a char. 8309 if (!APSInt::isSameValue(HandleIntToIntCast(Info, E, CharTy, 8310 E->getArg(1)->getType(), 8311 Desired), 8312 Desired)) 8313 return ZeroInitialization(E); 8314 StopAtNull = true; 8315 LLVM_FALLTHROUGH; 8316 case Builtin::BImemchr: 8317 case Builtin::BI__builtin_memchr: 8318 case Builtin::BI__builtin_char_memchr: 8319 // memchr compares by converting both sides to unsigned char. That's also 8320 // correct for strchr if we get this far (to cope with plain char being 8321 // unsigned in the strchr case). 8322 DesiredVal = Desired.trunc(Info.Ctx.getCharWidth()).getZExtValue(); 8323 break; 8324 8325 case Builtin::BIwcschr: 8326 case Builtin::BI__builtin_wcschr: 8327 StopAtNull = true; 8328 LLVM_FALLTHROUGH; 8329 case Builtin::BIwmemchr: 8330 case Builtin::BI__builtin_wmemchr: 8331 // wcschr and wmemchr are given a wchar_t to look for. Just use it. 8332 DesiredVal = Desired.getZExtValue(); 8333 break; 8334 } 8335 8336 for (; MaxLength; --MaxLength) { 8337 APValue Char; 8338 if (!handleLValueToRValueConversion(Info, E, CharTy, Result, Char) || 8339 !Char.isInt()) 8340 return false; 8341 if (Char.getInt().getZExtValue() == DesiredVal) 8342 return true; 8343 if (StopAtNull && !Char.getInt()) 8344 break; 8345 if (!HandleLValueArrayAdjustment(Info, E, Result, CharTy, 1)) 8346 return false; 8347 } 8348 // Not found: return nullptr. 8349 return ZeroInitialization(E); 8350 } 8351 8352 case Builtin::BImemcpy: 8353 case Builtin::BImemmove: 8354 case Builtin::BIwmemcpy: 8355 case Builtin::BIwmemmove: 8356 if (Info.getLangOpts().CPlusPlus11) 8357 Info.CCEDiag(E, diag::note_constexpr_invalid_function) 8358 << /*isConstexpr*/0 << /*isConstructor*/0 8359 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'"); 8360 else 8361 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr); 8362 LLVM_FALLTHROUGH; 8363 case Builtin::BI__builtin_memcpy: 8364 case Builtin::BI__builtin_memmove: 8365 case Builtin::BI__builtin_wmemcpy: 8366 case Builtin::BI__builtin_wmemmove: { 8367 bool WChar = BuiltinOp == Builtin::BIwmemcpy || 8368 BuiltinOp == Builtin::BIwmemmove || 8369 BuiltinOp == Builtin::BI__builtin_wmemcpy || 8370 BuiltinOp == Builtin::BI__builtin_wmemmove; 8371 bool Move = BuiltinOp == Builtin::BImemmove || 8372 BuiltinOp == Builtin::BIwmemmove || 8373 BuiltinOp == Builtin::BI__builtin_memmove || 8374 BuiltinOp == Builtin::BI__builtin_wmemmove; 8375 8376 // The result of mem* is the first argument. 8377 if (!Visit(E->getArg(0))) 8378 return false; 8379 LValue Dest = Result; 8380 8381 LValue Src; 8382 if (!EvaluatePointer(E->getArg(1), Src, Info)) 8383 return false; 8384 8385 APSInt N; 8386 if (!EvaluateInteger(E->getArg(2), N, Info)) 8387 return false; 8388 assert(!N.isSigned() && "memcpy and friends take an unsigned size"); 8389 8390 // If the size is zero, we treat this as always being a valid no-op. 8391 // (Even if one of the src and dest pointers is null.) 8392 if (!N) 8393 return true; 8394 8395 // Otherwise, if either of the operands is null, we can't proceed. Don't 8396 // try to determine the type of the copied objects, because there aren't 8397 // any. 8398 if (!Src.Base || !Dest.Base) { 8399 APValue Val; 8400 (!Src.Base ? Src : Dest).moveInto(Val); 8401 Info.FFDiag(E, diag::note_constexpr_memcpy_null) 8402 << Move << WChar << !!Src.Base 8403 << Val.getAsString(Info.Ctx, E->getArg(0)->getType()); 8404 return false; 8405 } 8406 if (Src.Designator.Invalid || Dest.Designator.Invalid) 8407 return false; 8408 8409 // We require that Src and Dest are both pointers to arrays of 8410 // trivially-copyable type. (For the wide version, the designator will be 8411 // invalid if the designated object is not a wchar_t.) 8412 QualType T = Dest.Designator.getType(Info.Ctx); 8413 QualType SrcT = Src.Designator.getType(Info.Ctx); 8414 if (!Info.Ctx.hasSameUnqualifiedType(T, SrcT)) { 8415 Info.FFDiag(E, diag::note_constexpr_memcpy_type_pun) << Move << SrcT << T; 8416 return false; 8417 } 8418 if (T->isIncompleteType()) { 8419 Info.FFDiag(E, diag::note_constexpr_memcpy_incomplete_type) << Move << T; 8420 return false; 8421 } 8422 if (!T.isTriviallyCopyableType(Info.Ctx)) { 8423 Info.FFDiag(E, diag::note_constexpr_memcpy_nontrivial) << Move << T; 8424 return false; 8425 } 8426 8427 // Figure out how many T's we're copying. 8428 uint64_t TSize = Info.Ctx.getTypeSizeInChars(T).getQuantity(); 8429 if (!WChar) { 8430 uint64_t Remainder; 8431 llvm::APInt OrigN = N; 8432 llvm::APInt::udivrem(OrigN, TSize, N, Remainder); 8433 if (Remainder) { 8434 Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported) 8435 << Move << WChar << 0 << T << OrigN.toString(10, /*Signed*/false) 8436 << (unsigned)TSize; 8437 return false; 8438 } 8439 } 8440 8441 // Check that the copying will remain within the arrays, just so that we 8442 // can give a more meaningful diagnostic. This implicitly also checks that 8443 // N fits into 64 bits. 8444 uint64_t RemainingSrcSize = Src.Designator.validIndexAdjustments().second; 8445 uint64_t RemainingDestSize = Dest.Designator.validIndexAdjustments().second; 8446 if (N.ugt(RemainingSrcSize) || N.ugt(RemainingDestSize)) { 8447 Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported) 8448 << Move << WChar << (N.ugt(RemainingSrcSize) ? 1 : 2) << T 8449 << N.toString(10, /*Signed*/false); 8450 return false; 8451 } 8452 uint64_t NElems = N.getZExtValue(); 8453 uint64_t NBytes = NElems * TSize; 8454 8455 // Check for overlap. 8456 int Direction = 1; 8457 if (HasSameBase(Src, Dest)) { 8458 uint64_t SrcOffset = Src.getLValueOffset().getQuantity(); 8459 uint64_t DestOffset = Dest.getLValueOffset().getQuantity(); 8460 if (DestOffset >= SrcOffset && DestOffset - SrcOffset < NBytes) { 8461 // Dest is inside the source region. 8462 if (!Move) { 8463 Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar; 8464 return false; 8465 } 8466 // For memmove and friends, copy backwards. 8467 if (!HandleLValueArrayAdjustment(Info, E, Src, T, NElems - 1) || 8468 !HandleLValueArrayAdjustment(Info, E, Dest, T, NElems - 1)) 8469 return false; 8470 Direction = -1; 8471 } else if (!Move && SrcOffset >= DestOffset && 8472 SrcOffset - DestOffset < NBytes) { 8473 // Src is inside the destination region for memcpy: invalid. 8474 Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar; 8475 return false; 8476 } 8477 } 8478 8479 while (true) { 8480 APValue Val; 8481 // FIXME: Set WantObjectRepresentation to true if we're copying a 8482 // char-like type? 8483 if (!handleLValueToRValueConversion(Info, E, T, Src, Val) || 8484 !handleAssignment(Info, E, Dest, T, Val)) 8485 return false; 8486 // Do not iterate past the last element; if we're copying backwards, that 8487 // might take us off the start of the array. 8488 if (--NElems == 0) 8489 return true; 8490 if (!HandleLValueArrayAdjustment(Info, E, Src, T, Direction) || 8491 !HandleLValueArrayAdjustment(Info, E, Dest, T, Direction)) 8492 return false; 8493 } 8494 } 8495 8496 default: 8497 break; 8498 } 8499 8500 return visitNonBuiltinCallExpr(E); 8501 } 8502 8503 static bool EvaluateArrayNewInitList(EvalInfo &Info, LValue &This, 8504 APValue &Result, const InitListExpr *ILE, 8505 QualType AllocType); 8506 8507 bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) { 8508 if (!Info.getLangOpts().CPlusPlus2a) 8509 Info.CCEDiag(E, diag::note_constexpr_new); 8510 8511 // We cannot speculatively evaluate a delete expression. 8512 if (Info.SpeculativeEvaluationDepth) 8513 return false; 8514 8515 FunctionDecl *OperatorNew = E->getOperatorNew(); 8516 8517 bool IsNothrow = false; 8518 bool IsPlacement = false; 8519 if (OperatorNew->isReservedGlobalPlacementOperator() && 8520 Info.CurrentCall->isStdFunction() && !E->isArray()) { 8521 // FIXME Support array placement new. 8522 assert(E->getNumPlacementArgs() == 1); 8523 if (!EvaluatePointer(E->getPlacementArg(0), Result, Info)) 8524 return false; 8525 if (Result.Designator.Invalid) 8526 return false; 8527 IsPlacement = true; 8528 } else if (!OperatorNew->isReplaceableGlobalAllocationFunction()) { 8529 Info.FFDiag(E, diag::note_constexpr_new_non_replaceable) 8530 << isa<CXXMethodDecl>(OperatorNew) << OperatorNew; 8531 return false; 8532 } else if (E->getNumPlacementArgs()) { 8533 // The only new-placement list we support is of the form (std::nothrow). 8534 // 8535 // FIXME: There is no restriction on this, but it's not clear that any 8536 // other form makes any sense. We get here for cases such as: 8537 // 8538 // new (std::align_val_t{N}) X(int) 8539 // 8540 // (which should presumably be valid only if N is a multiple of 8541 // alignof(int), and in any case can't be deallocated unless N is 8542 // alignof(X) and X has new-extended alignment). 8543 if (E->getNumPlacementArgs() != 1 || 8544 !E->getPlacementArg(0)->getType()->isNothrowT()) 8545 return Error(E, diag::note_constexpr_new_placement); 8546 8547 LValue Nothrow; 8548 if (!EvaluateLValue(E->getPlacementArg(0), Nothrow, Info)) 8549 return false; 8550 IsNothrow = true; 8551 } 8552 8553 const Expr *Init = E->getInitializer(); 8554 const InitListExpr *ResizedArrayILE = nullptr; 8555 8556 QualType AllocType = E->getAllocatedType(); 8557 if (Optional<const Expr*> ArraySize = E->getArraySize()) { 8558 const Expr *Stripped = *ArraySize; 8559 for (; auto *ICE = dyn_cast<ImplicitCastExpr>(Stripped); 8560 Stripped = ICE->getSubExpr()) 8561 if (ICE->getCastKind() != CK_NoOp && 8562 ICE->getCastKind() != CK_IntegralCast) 8563 break; 8564 8565 llvm::APSInt ArrayBound; 8566 if (!EvaluateInteger(Stripped, ArrayBound, Info)) 8567 return false; 8568 8569 // C++ [expr.new]p9: 8570 // The expression is erroneous if: 8571 // -- [...] its value before converting to size_t [or] applying the 8572 // second standard conversion sequence is less than zero 8573 if (ArrayBound.isSigned() && ArrayBound.isNegative()) { 8574 if (IsNothrow) 8575 return ZeroInitialization(E); 8576 8577 Info.FFDiag(*ArraySize, diag::note_constexpr_new_negative) 8578 << ArrayBound << (*ArraySize)->getSourceRange(); 8579 return false; 8580 } 8581 8582 // -- its value is such that the size of the allocated object would 8583 // exceed the implementation-defined limit 8584 if (ConstantArrayType::getNumAddressingBits(Info.Ctx, AllocType, 8585 ArrayBound) > 8586 ConstantArrayType::getMaxSizeBits(Info.Ctx)) { 8587 if (IsNothrow) 8588 return ZeroInitialization(E); 8589 8590 Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_large) 8591 << ArrayBound << (*ArraySize)->getSourceRange(); 8592 return false; 8593 } 8594 8595 // -- the new-initializer is a braced-init-list and the number of 8596 // array elements for which initializers are provided [...] 8597 // exceeds the number of elements to initialize 8598 if (Init) { 8599 auto *CAT = Info.Ctx.getAsConstantArrayType(Init->getType()); 8600 assert(CAT && "unexpected type for array initializer"); 8601 8602 unsigned Bits = 8603 std::max(CAT->getSize().getBitWidth(), ArrayBound.getBitWidth()); 8604 llvm::APInt InitBound = CAT->getSize().zextOrSelf(Bits); 8605 llvm::APInt AllocBound = ArrayBound.zextOrSelf(Bits); 8606 if (InitBound.ugt(AllocBound)) { 8607 if (IsNothrow) 8608 return ZeroInitialization(E); 8609 8610 Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_small) 8611 << AllocBound.toString(10, /*Signed=*/false) 8612 << InitBound.toString(10, /*Signed=*/false) 8613 << (*ArraySize)->getSourceRange(); 8614 return false; 8615 } 8616 8617 // If the sizes differ, we must have an initializer list, and we need 8618 // special handling for this case when we initialize. 8619 if (InitBound != AllocBound) 8620 ResizedArrayILE = cast<InitListExpr>(Init); 8621 } 8622 8623 AllocType = Info.Ctx.getConstantArrayType(AllocType, ArrayBound, nullptr, 8624 ArrayType::Normal, 0); 8625 } else { 8626 assert(!AllocType->isArrayType() && 8627 "array allocation with non-array new"); 8628 } 8629 8630 APValue *Val; 8631 if (IsPlacement) { 8632 AccessKinds AK = AK_Construct; 8633 struct FindObjectHandler { 8634 EvalInfo &Info; 8635 const Expr *E; 8636 QualType AllocType; 8637 const AccessKinds AccessKind; 8638 APValue *Value; 8639 8640 typedef bool result_type; 8641 bool failed() { return false; } 8642 bool found(APValue &Subobj, QualType SubobjType) { 8643 // FIXME: Reject the cases where [basic.life]p8 would not permit the 8644 // old name of the object to be used to name the new object. 8645 if (!Info.Ctx.hasSameUnqualifiedType(SubobjType, AllocType)) { 8646 Info.FFDiag(E, diag::note_constexpr_placement_new_wrong_type) << 8647 SubobjType << AllocType; 8648 return false; 8649 } 8650 Value = &Subobj; 8651 return true; 8652 } 8653 bool found(APSInt &Value, QualType SubobjType) { 8654 Info.FFDiag(E, diag::note_constexpr_construct_complex_elem); 8655 return false; 8656 } 8657 bool found(APFloat &Value, QualType SubobjType) { 8658 Info.FFDiag(E, diag::note_constexpr_construct_complex_elem); 8659 return false; 8660 } 8661 } Handler = {Info, E, AllocType, AK, nullptr}; 8662 8663 CompleteObject Obj = findCompleteObject(Info, E, AK, Result, AllocType); 8664 if (!Obj || !findSubobject(Info, E, Obj, Result.Designator, Handler)) 8665 return false; 8666 8667 Val = Handler.Value; 8668 8669 // [basic.life]p1: 8670 // The lifetime of an object o of type T ends when [...] the storage 8671 // which the object occupies is [...] reused by an object that is not 8672 // nested within o (6.6.2). 8673 *Val = APValue(); 8674 } else { 8675 // Perform the allocation and obtain a pointer to the resulting object. 8676 Val = Info.createHeapAlloc(E, AllocType, Result); 8677 if (!Val) 8678 return false; 8679 } 8680 8681 if (ResizedArrayILE) { 8682 if (!EvaluateArrayNewInitList(Info, Result, *Val, ResizedArrayILE, 8683 AllocType)) 8684 return false; 8685 } else if (Init) { 8686 if (!EvaluateInPlace(*Val, Info, Result, Init)) 8687 return false; 8688 } else { 8689 *Val = getDefaultInitValue(AllocType); 8690 } 8691 8692 // Array new returns a pointer to the first element, not a pointer to the 8693 // array. 8694 if (auto *AT = AllocType->getAsArrayTypeUnsafe()) 8695 Result.addArray(Info, E, cast<ConstantArrayType>(AT)); 8696 8697 return true; 8698 } 8699 //===----------------------------------------------------------------------===// 8700 // Member Pointer Evaluation 8701 //===----------------------------------------------------------------------===// 8702 8703 namespace { 8704 class MemberPointerExprEvaluator 8705 : public ExprEvaluatorBase<MemberPointerExprEvaluator> { 8706 MemberPtr &Result; 8707 8708 bool Success(const ValueDecl *D) { 8709 Result = MemberPtr(D); 8710 return true; 8711 } 8712 public: 8713 8714 MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result) 8715 : ExprEvaluatorBaseTy(Info), Result(Result) {} 8716 8717 bool Success(const APValue &V, const Expr *E) { 8718 Result.setFrom(V); 8719 return true; 8720 } 8721 bool ZeroInitialization(const Expr *E) { 8722 return Success((const ValueDecl*)nullptr); 8723 } 8724 8725 bool VisitCastExpr(const CastExpr *E); 8726 bool VisitUnaryAddrOf(const UnaryOperator *E); 8727 }; 8728 } // end anonymous namespace 8729 8730 static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result, 8731 EvalInfo &Info) { 8732 assert(E->isRValue() && E->getType()->isMemberPointerType()); 8733 return MemberPointerExprEvaluator(Info, Result).Visit(E); 8734 } 8735 8736 bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) { 8737 switch (E->getCastKind()) { 8738 default: 8739 return ExprEvaluatorBaseTy::VisitCastExpr(E); 8740 8741 case CK_NullToMemberPointer: 8742 VisitIgnoredValue(E->getSubExpr()); 8743 return ZeroInitialization(E); 8744 8745 case CK_BaseToDerivedMemberPointer: { 8746 if (!Visit(E->getSubExpr())) 8747 return false; 8748 if (E->path_empty()) 8749 return true; 8750 // Base-to-derived member pointer casts store the path in derived-to-base 8751 // order, so iterate backwards. The CXXBaseSpecifier also provides us with 8752 // the wrong end of the derived->base arc, so stagger the path by one class. 8753 typedef std::reverse_iterator<CastExpr::path_const_iterator> ReverseIter; 8754 for (ReverseIter PathI(E->path_end() - 1), PathE(E->path_begin()); 8755 PathI != PathE; ++PathI) { 8756 assert(!(*PathI)->isVirtual() && "memptr cast through vbase"); 8757 const CXXRecordDecl *Derived = (*PathI)->getType()->getAsCXXRecordDecl(); 8758 if (!Result.castToDerived(Derived)) 8759 return Error(E); 8760 } 8761 const Type *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass(); 8762 if (!Result.castToDerived(FinalTy->getAsCXXRecordDecl())) 8763 return Error(E); 8764 return true; 8765 } 8766 8767 case CK_DerivedToBaseMemberPointer: 8768 if (!Visit(E->getSubExpr())) 8769 return false; 8770 for (CastExpr::path_const_iterator PathI = E->path_begin(), 8771 PathE = E->path_end(); PathI != PathE; ++PathI) { 8772 assert(!(*PathI)->isVirtual() && "memptr cast through vbase"); 8773 const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl(); 8774 if (!Result.castToBase(Base)) 8775 return Error(E); 8776 } 8777 return true; 8778 } 8779 } 8780 8781 bool MemberPointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) { 8782 // C++11 [expr.unary.op]p3 has very strict rules on how the address of a 8783 // member can be formed. 8784 return Success(cast<DeclRefExpr>(E->getSubExpr())->getDecl()); 8785 } 8786 8787 //===----------------------------------------------------------------------===// 8788 // Record Evaluation 8789 //===----------------------------------------------------------------------===// 8790 8791 namespace { 8792 class RecordExprEvaluator 8793 : public ExprEvaluatorBase<RecordExprEvaluator> { 8794 const LValue &This; 8795 APValue &Result; 8796 public: 8797 8798 RecordExprEvaluator(EvalInfo &info, const LValue &This, APValue &Result) 8799 : ExprEvaluatorBaseTy(info), This(This), Result(Result) {} 8800 8801 bool Success(const APValue &V, const Expr *E) { 8802 Result = V; 8803 return true; 8804 } 8805 bool ZeroInitialization(const Expr *E) { 8806 return ZeroInitialization(E, E->getType()); 8807 } 8808 bool ZeroInitialization(const Expr *E, QualType T); 8809 8810 bool VisitCallExpr(const CallExpr *E) { 8811 return handleCallExpr(E, Result, &This); 8812 } 8813 bool VisitCastExpr(const CastExpr *E); 8814 bool VisitInitListExpr(const InitListExpr *E); 8815 bool VisitCXXConstructExpr(const CXXConstructExpr *E) { 8816 return VisitCXXConstructExpr(E, E->getType()); 8817 } 8818 bool VisitLambdaExpr(const LambdaExpr *E); 8819 bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E); 8820 bool VisitCXXConstructExpr(const CXXConstructExpr *E, QualType T); 8821 bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E); 8822 bool VisitBinCmp(const BinaryOperator *E); 8823 }; 8824 } 8825 8826 /// Perform zero-initialization on an object of non-union class type. 8827 /// C++11 [dcl.init]p5: 8828 /// To zero-initialize an object or reference of type T means: 8829 /// [...] 8830 /// -- if T is a (possibly cv-qualified) non-union class type, 8831 /// each non-static data member and each base-class subobject is 8832 /// zero-initialized 8833 static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E, 8834 const RecordDecl *RD, 8835 const LValue &This, APValue &Result) { 8836 assert(!RD->isUnion() && "Expected non-union class type"); 8837 const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD); 8838 Result = APValue(APValue::UninitStruct(), CD ? CD->getNumBases() : 0, 8839 std::distance(RD->field_begin(), RD->field_end())); 8840 8841 if (RD->isInvalidDecl()) return false; 8842 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 8843 8844 if (CD) { 8845 unsigned Index = 0; 8846 for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(), 8847 End = CD->bases_end(); I != End; ++I, ++Index) { 8848 const CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl(); 8849 LValue Subobject = This; 8850 if (!HandleLValueDirectBase(Info, E, Subobject, CD, Base, &Layout)) 8851 return false; 8852 if (!HandleClassZeroInitialization(Info, E, Base, Subobject, 8853 Result.getStructBase(Index))) 8854 return false; 8855 } 8856 } 8857 8858 for (const auto *I : RD->fields()) { 8859 // -- if T is a reference type, no initialization is performed. 8860 if (I->getType()->isReferenceType()) 8861 continue; 8862 8863 LValue Subobject = This; 8864 if (!HandleLValueMember(Info, E, Subobject, I, &Layout)) 8865 return false; 8866 8867 ImplicitValueInitExpr VIE(I->getType()); 8868 if (!EvaluateInPlace( 8869 Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE)) 8870 return false; 8871 } 8872 8873 return true; 8874 } 8875 8876 bool RecordExprEvaluator::ZeroInitialization(const Expr *E, QualType T) { 8877 const RecordDecl *RD = T->castAs<RecordType>()->getDecl(); 8878 if (RD->isInvalidDecl()) return false; 8879 if (RD->isUnion()) { 8880 // C++11 [dcl.init]p5: If T is a (possibly cv-qualified) union type, the 8881 // object's first non-static named data member is zero-initialized 8882 RecordDecl::field_iterator I = RD->field_begin(); 8883 if (I == RD->field_end()) { 8884 Result = APValue((const FieldDecl*)nullptr); 8885 return true; 8886 } 8887 8888 LValue Subobject = This; 8889 if (!HandleLValueMember(Info, E, Subobject, *I)) 8890 return false; 8891 Result = APValue(*I); 8892 ImplicitValueInitExpr VIE(I->getType()); 8893 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, &VIE); 8894 } 8895 8896 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->getNumVBases()) { 8897 Info.FFDiag(E, diag::note_constexpr_virtual_base) << RD; 8898 return false; 8899 } 8900 8901 return HandleClassZeroInitialization(Info, E, RD, This, Result); 8902 } 8903 8904 bool RecordExprEvaluator::VisitCastExpr(const CastExpr *E) { 8905 switch (E->getCastKind()) { 8906 default: 8907 return ExprEvaluatorBaseTy::VisitCastExpr(E); 8908 8909 case CK_ConstructorConversion: 8910 return Visit(E->getSubExpr()); 8911 8912 case CK_DerivedToBase: 8913 case CK_UncheckedDerivedToBase: { 8914 APValue DerivedObject; 8915 if (!Evaluate(DerivedObject, Info, E->getSubExpr())) 8916 return false; 8917 if (!DerivedObject.isStruct()) 8918 return Error(E->getSubExpr()); 8919 8920 // Derived-to-base rvalue conversion: just slice off the derived part. 8921 APValue *Value = &DerivedObject; 8922 const CXXRecordDecl *RD = E->getSubExpr()->getType()->getAsCXXRecordDecl(); 8923 for (CastExpr::path_const_iterator PathI = E->path_begin(), 8924 PathE = E->path_end(); PathI != PathE; ++PathI) { 8925 assert(!(*PathI)->isVirtual() && "record rvalue with virtual base"); 8926 const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl(); 8927 Value = &Value->getStructBase(getBaseIndex(RD, Base)); 8928 RD = Base; 8929 } 8930 Result = *Value; 8931 return true; 8932 } 8933 } 8934 } 8935 8936 bool RecordExprEvaluator::VisitInitListExpr(const InitListExpr *E) { 8937 if (E->isTransparent()) 8938 return Visit(E->getInit(0)); 8939 8940 const RecordDecl *RD = E->getType()->castAs<RecordType>()->getDecl(); 8941 if (RD->isInvalidDecl()) return false; 8942 const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD); 8943 auto *CXXRD = dyn_cast<CXXRecordDecl>(RD); 8944 8945 EvalInfo::EvaluatingConstructorRAII EvalObj( 8946 Info, 8947 ObjectUnderConstruction{This.getLValueBase(), This.Designator.Entries}, 8948 CXXRD && CXXRD->getNumBases()); 8949 8950 if (RD->isUnion()) { 8951 const FieldDecl *Field = E->getInitializedFieldInUnion(); 8952 Result = APValue(Field); 8953 if (!Field) 8954 return true; 8955 8956 // If the initializer list for a union does not contain any elements, the 8957 // first element of the union is value-initialized. 8958 // FIXME: The element should be initialized from an initializer list. 8959 // Is this difference ever observable for initializer lists which 8960 // we don't build? 8961 ImplicitValueInitExpr VIE(Field->getType()); 8962 const Expr *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE; 8963 8964 LValue Subobject = This; 8965 if (!HandleLValueMember(Info, InitExpr, Subobject, Field, &Layout)) 8966 return false; 8967 8968 // Temporarily override This, in case there's a CXXDefaultInitExpr in here. 8969 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This, 8970 isa<CXXDefaultInitExpr>(InitExpr)); 8971 8972 return EvaluateInPlace(Result.getUnionValue(), Info, Subobject, InitExpr); 8973 } 8974 8975 if (!Result.hasValue()) 8976 Result = APValue(APValue::UninitStruct(), CXXRD ? CXXRD->getNumBases() : 0, 8977 std::distance(RD->field_begin(), RD->field_end())); 8978 unsigned ElementNo = 0; 8979 bool Success = true; 8980 8981 // Initialize base classes. 8982 if (CXXRD && CXXRD->getNumBases()) { 8983 for (const auto &Base : CXXRD->bases()) { 8984 assert(ElementNo < E->getNumInits() && "missing init for base class"); 8985 const Expr *Init = E->getInit(ElementNo); 8986 8987 LValue Subobject = This; 8988 if (!HandleLValueBase(Info, Init, Subobject, CXXRD, &Base)) 8989 return false; 8990 8991 APValue &FieldVal = Result.getStructBase(ElementNo); 8992 if (!EvaluateInPlace(FieldVal, Info, Subobject, Init)) { 8993 if (!Info.noteFailure()) 8994 return false; 8995 Success = false; 8996 } 8997 ++ElementNo; 8998 } 8999 9000 EvalObj.finishedConstructingBases(); 9001 } 9002 9003 // Initialize members. 9004 for (const auto *Field : RD->fields()) { 9005 // Anonymous bit-fields are not considered members of the class for 9006 // purposes of aggregate initialization. 9007 if (Field->isUnnamedBitfield()) 9008 continue; 9009 9010 LValue Subobject = This; 9011 9012 bool HaveInit = ElementNo < E->getNumInits(); 9013 9014 // FIXME: Diagnostics here should point to the end of the initializer 9015 // list, not the start. 9016 if (!HandleLValueMember(Info, HaveInit ? E->getInit(ElementNo) : E, 9017 Subobject, Field, &Layout)) 9018 return false; 9019 9020 // Perform an implicit value-initialization for members beyond the end of 9021 // the initializer list. 9022 ImplicitValueInitExpr VIE(HaveInit ? Info.Ctx.IntTy : Field->getType()); 9023 const Expr *Init = HaveInit ? E->getInit(ElementNo++) : &VIE; 9024 9025 // Temporarily override This, in case there's a CXXDefaultInitExpr in here. 9026 ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This, 9027 isa<CXXDefaultInitExpr>(Init)); 9028 9029 APValue &FieldVal = Result.getStructField(Field->getFieldIndex()); 9030 if (!EvaluateInPlace(FieldVal, Info, Subobject, Init) || 9031 (Field->isBitField() && !truncateBitfieldValue(Info, Init, 9032 FieldVal, Field))) { 9033 if (!Info.noteFailure()) 9034 return false; 9035 Success = false; 9036 } 9037 } 9038 9039 return Success; 9040 } 9041 9042 bool RecordExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E, 9043 QualType T) { 9044 // Note that E's type is not necessarily the type of our class here; we might 9045 // be initializing an array element instead. 9046 const CXXConstructorDecl *FD = E->getConstructor(); 9047 if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl()) return false; 9048 9049 bool ZeroInit = E->requiresZeroInitialization(); 9050 if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) { 9051 // If we've already performed zero-initialization, we're already done. 9052 if (Result.hasValue()) 9053 return true; 9054 9055 if (ZeroInit) 9056 return ZeroInitialization(E, T); 9057 9058 Result = getDefaultInitValue(T); 9059 return true; 9060 } 9061 9062 const FunctionDecl *Definition = nullptr; 9063 auto Body = FD->getBody(Definition); 9064 9065 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body)) 9066 return false; 9067 9068 // Avoid materializing a temporary for an elidable copy/move constructor. 9069 if (E->isElidable() && !ZeroInit) 9070 if (const MaterializeTemporaryExpr *ME 9071 = dyn_cast<MaterializeTemporaryExpr>(E->getArg(0))) 9072 return Visit(ME->getSubExpr()); 9073 9074 if (ZeroInit && !ZeroInitialization(E, T)) 9075 return false; 9076 9077 auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs()); 9078 return HandleConstructorCall(E, This, Args, 9079 cast<CXXConstructorDecl>(Definition), Info, 9080 Result); 9081 } 9082 9083 bool RecordExprEvaluator::VisitCXXInheritedCtorInitExpr( 9084 const CXXInheritedCtorInitExpr *E) { 9085 if (!Info.CurrentCall) { 9086 assert(Info.checkingPotentialConstantExpression()); 9087 return false; 9088 } 9089 9090 const CXXConstructorDecl *FD = E->getConstructor(); 9091 if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl()) 9092 return false; 9093 9094 const FunctionDecl *Definition = nullptr; 9095 auto Body = FD->getBody(Definition); 9096 9097 if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body)) 9098 return false; 9099 9100 return HandleConstructorCall(E, This, Info.CurrentCall->Arguments, 9101 cast<CXXConstructorDecl>(Definition), Info, 9102 Result); 9103 } 9104 9105 bool RecordExprEvaluator::VisitCXXStdInitializerListExpr( 9106 const CXXStdInitializerListExpr *E) { 9107 const ConstantArrayType *ArrayType = 9108 Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType()); 9109 9110 LValue Array; 9111 if (!EvaluateLValue(E->getSubExpr(), Array, Info)) 9112 return false; 9113 9114 // Get a pointer to the first element of the array. 9115 Array.addArray(Info, E, ArrayType); 9116 9117 // FIXME: Perform the checks on the field types in SemaInit. 9118 RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl(); 9119 RecordDecl::field_iterator Field = Record->field_begin(); 9120 if (Field == Record->field_end()) 9121 return Error(E); 9122 9123 // Start pointer. 9124 if (!Field->getType()->isPointerType() || 9125 !Info.Ctx.hasSameType(Field->getType()->getPointeeType(), 9126 ArrayType->getElementType())) 9127 return Error(E); 9128 9129 // FIXME: What if the initializer_list type has base classes, etc? 9130 Result = APValue(APValue::UninitStruct(), 0, 2); 9131 Array.moveInto(Result.getStructField(0)); 9132 9133 if (++Field == Record->field_end()) 9134 return Error(E); 9135 9136 if (Field->getType()->isPointerType() && 9137 Info.Ctx.hasSameType(Field->getType()->getPointeeType(), 9138 ArrayType->getElementType())) { 9139 // End pointer. 9140 if (!HandleLValueArrayAdjustment(Info, E, Array, 9141 ArrayType->getElementType(), 9142 ArrayType->getSize().getZExtValue())) 9143 return false; 9144 Array.moveInto(Result.getStructField(1)); 9145 } else if (Info.Ctx.hasSameType(Field->getType(), Info.Ctx.getSizeType())) 9146 // Length. 9147 Result.getStructField(1) = APValue(APSInt(ArrayType->getSize())); 9148 else 9149 return Error(E); 9150 9151 if (++Field != Record->field_end()) 9152 return Error(E); 9153 9154 return true; 9155 } 9156 9157 bool RecordExprEvaluator::VisitLambdaExpr(const LambdaExpr *E) { 9158 const CXXRecordDecl *ClosureClass = E->getLambdaClass(); 9159 if (ClosureClass->isInvalidDecl()) 9160 return false; 9161 9162 const size_t NumFields = 9163 std::distance(ClosureClass->field_begin(), ClosureClass->field_end()); 9164 9165 assert(NumFields == (size_t)std::distance(E->capture_init_begin(), 9166 E->capture_init_end()) && 9167 "The number of lambda capture initializers should equal the number of " 9168 "fields within the closure type"); 9169 9170 Result = APValue(APValue::UninitStruct(), /*NumBases*/0, NumFields); 9171 // Iterate through all the lambda's closure object's fields and initialize 9172 // them. 9173 auto *CaptureInitIt = E->capture_init_begin(); 9174 const LambdaCapture *CaptureIt = ClosureClass->captures_begin(); 9175 bool Success = true; 9176 for (const auto *Field : ClosureClass->fields()) { 9177 assert(CaptureInitIt != E->capture_init_end()); 9178 // Get the initializer for this field 9179 Expr *const CurFieldInit = *CaptureInitIt++; 9180 9181 // If there is no initializer, either this is a VLA or an error has 9182 // occurred. 9183 if (!CurFieldInit) 9184 return Error(E); 9185 9186 APValue &FieldVal = Result.getStructField(Field->getFieldIndex()); 9187 if (!EvaluateInPlace(FieldVal, Info, This, CurFieldInit)) { 9188 if (!Info.keepEvaluatingAfterFailure()) 9189 return false; 9190 Success = false; 9191 } 9192 ++CaptureIt; 9193 } 9194 return Success; 9195 } 9196 9197 static bool EvaluateRecord(const Expr *E, const LValue &This, 9198 APValue &Result, EvalInfo &Info) { 9199 assert(E->isRValue() && E->getType()->isRecordType() && 9200 "can't evaluate expression as a record rvalue"); 9201 return RecordExprEvaluator(Info, This, Result).Visit(E); 9202 } 9203 9204 //===----------------------------------------------------------------------===// 9205 // Temporary Evaluation 9206 // 9207 // Temporaries are represented in the AST as rvalues, but generally behave like 9208 // lvalues. The full-object of which the temporary is a subobject is implicitly 9209 // materialized so that a reference can bind to it. 9210 //===----------------------------------------------------------------------===// 9211 namespace { 9212 class TemporaryExprEvaluator 9213 : public LValueExprEvaluatorBase<TemporaryExprEvaluator> { 9214 public: 9215 TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) : 9216 LValueExprEvaluatorBaseTy(Info, Result, false) {} 9217 9218 /// Visit an expression which constructs the value of this temporary. 9219 bool VisitConstructExpr(const Expr *E) { 9220 APValue &Value = 9221 Info.CurrentCall->createTemporary(E, E->getType(), false, Result); 9222 return EvaluateInPlace(Value, Info, Result, E); 9223 } 9224 9225 bool VisitCastExpr(const CastExpr *E) { 9226 switch (E->getCastKind()) { 9227 default: 9228 return LValueExprEvaluatorBaseTy::VisitCastExpr(E); 9229 9230 case CK_ConstructorConversion: 9231 return VisitConstructExpr(E->getSubExpr()); 9232 } 9233 } 9234 bool VisitInitListExpr(const InitListExpr *E) { 9235 return VisitConstructExpr(E); 9236 } 9237 bool VisitCXXConstructExpr(const CXXConstructExpr *E) { 9238 return VisitConstructExpr(E); 9239 } 9240 bool VisitCallExpr(const CallExpr *E) { 9241 return VisitConstructExpr(E); 9242 } 9243 bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E) { 9244 return VisitConstructExpr(E); 9245 } 9246 bool VisitLambdaExpr(const LambdaExpr *E) { 9247 return VisitConstructExpr(E); 9248 } 9249 }; 9250 } // end anonymous namespace 9251 9252 /// Evaluate an expression of record type as a temporary. 9253 static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) { 9254 assert(E->isRValue() && E->getType()->isRecordType()); 9255 return TemporaryExprEvaluator(Info, Result).Visit(E); 9256 } 9257 9258 //===----------------------------------------------------------------------===// 9259 // Vector Evaluation 9260 //===----------------------------------------------------------------------===// 9261 9262 namespace { 9263 class VectorExprEvaluator 9264 : public ExprEvaluatorBase<VectorExprEvaluator> { 9265 APValue &Result; 9266 public: 9267 9268 VectorExprEvaluator(EvalInfo &info, APValue &Result) 9269 : ExprEvaluatorBaseTy(info), Result(Result) {} 9270 9271 bool Success(ArrayRef<APValue> V, const Expr *E) { 9272 assert(V.size() == E->getType()->castAs<VectorType>()->getNumElements()); 9273 // FIXME: remove this APValue copy. 9274 Result = APValue(V.data(), V.size()); 9275 return true; 9276 } 9277 bool Success(const APValue &V, const Expr *E) { 9278 assert(V.isVector()); 9279 Result = V; 9280 return true; 9281 } 9282 bool ZeroInitialization(const Expr *E); 9283 9284 bool VisitUnaryReal(const UnaryOperator *E) 9285 { return Visit(E->getSubExpr()); } 9286 bool VisitCastExpr(const CastExpr* E); 9287 bool VisitInitListExpr(const InitListExpr *E); 9288 bool VisitUnaryImag(const UnaryOperator *E); 9289 // FIXME: Missing: unary -, unary ~, binary add/sub/mul/div, 9290 // binary comparisons, binary and/or/xor, 9291 // shufflevector, ExtVectorElementExpr 9292 }; 9293 } // end anonymous namespace 9294 9295 static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) { 9296 assert(E->isRValue() && E->getType()->isVectorType() &&"not a vector rvalue"); 9297 return VectorExprEvaluator(Info, Result).Visit(E); 9298 } 9299 9300 bool VectorExprEvaluator::VisitCastExpr(const CastExpr *E) { 9301 const VectorType *VTy = E->getType()->castAs<VectorType>(); 9302 unsigned NElts = VTy->getNumElements(); 9303 9304 const Expr *SE = E->getSubExpr(); 9305 QualType SETy = SE->getType(); 9306 9307 switch (E->getCastKind()) { 9308 case CK_VectorSplat: { 9309 APValue Val = APValue(); 9310 if (SETy->isIntegerType()) { 9311 APSInt IntResult; 9312 if (!EvaluateInteger(SE, IntResult, Info)) 9313 return false; 9314 Val = APValue(std::move(IntResult)); 9315 } else if (SETy->isRealFloatingType()) { 9316 APFloat FloatResult(0.0); 9317 if (!EvaluateFloat(SE, FloatResult, Info)) 9318 return false; 9319 Val = APValue(std::move(FloatResult)); 9320 } else { 9321 return Error(E); 9322 } 9323 9324 // Splat and create vector APValue. 9325 SmallVector<APValue, 4> Elts(NElts, Val); 9326 return Success(Elts, E); 9327 } 9328 case CK_BitCast: { 9329 // Evaluate the operand into an APInt we can extract from. 9330 llvm::APInt SValInt; 9331 if (!EvalAndBitcastToAPInt(Info, SE, SValInt)) 9332 return false; 9333 // Extract the elements 9334 QualType EltTy = VTy->getElementType(); 9335 unsigned EltSize = Info.Ctx.getTypeSize(EltTy); 9336 bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian(); 9337 SmallVector<APValue, 4> Elts; 9338 if (EltTy->isRealFloatingType()) { 9339 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(EltTy); 9340 unsigned FloatEltSize = EltSize; 9341 if (&Sem == &APFloat::x87DoubleExtended()) 9342 FloatEltSize = 80; 9343 for (unsigned i = 0; i < NElts; i++) { 9344 llvm::APInt Elt; 9345 if (BigEndian) 9346 Elt = SValInt.rotl(i*EltSize+FloatEltSize).trunc(FloatEltSize); 9347 else 9348 Elt = SValInt.rotr(i*EltSize).trunc(FloatEltSize); 9349 Elts.push_back(APValue(APFloat(Sem, Elt))); 9350 } 9351 } else if (EltTy->isIntegerType()) { 9352 for (unsigned i = 0; i < NElts; i++) { 9353 llvm::APInt Elt; 9354 if (BigEndian) 9355 Elt = SValInt.rotl(i*EltSize+EltSize).zextOrTrunc(EltSize); 9356 else 9357 Elt = SValInt.rotr(i*EltSize).zextOrTrunc(EltSize); 9358 Elts.push_back(APValue(APSInt(Elt, EltTy->isSignedIntegerType()))); 9359 } 9360 } else { 9361 return Error(E); 9362 } 9363 return Success(Elts, E); 9364 } 9365 default: 9366 return ExprEvaluatorBaseTy::VisitCastExpr(E); 9367 } 9368 } 9369 9370 bool 9371 VectorExprEvaluator::VisitInitListExpr(const InitListExpr *E) { 9372 const VectorType *VT = E->getType()->castAs<VectorType>(); 9373 unsigned NumInits = E->getNumInits(); 9374 unsigned NumElements = VT->getNumElements(); 9375 9376 QualType EltTy = VT->getElementType(); 9377 SmallVector<APValue, 4> Elements; 9378 9379 // The number of initializers can be less than the number of 9380 // vector elements. For OpenCL, this can be due to nested vector 9381 // initialization. For GCC compatibility, missing trailing elements 9382 // should be initialized with zeroes. 9383 unsigned CountInits = 0, CountElts = 0; 9384 while (CountElts < NumElements) { 9385 // Handle nested vector initialization. 9386 if (CountInits < NumInits 9387 && E->getInit(CountInits)->getType()->isVectorType()) { 9388 APValue v; 9389 if (!EvaluateVector(E->getInit(CountInits), v, Info)) 9390 return Error(E); 9391 unsigned vlen = v.getVectorLength(); 9392 for (unsigned j = 0; j < vlen; j++) 9393 Elements.push_back(v.getVectorElt(j)); 9394 CountElts += vlen; 9395 } else if (EltTy->isIntegerType()) { 9396 llvm::APSInt sInt(32); 9397 if (CountInits < NumInits) { 9398 if (!EvaluateInteger(E->getInit(CountInits), sInt, Info)) 9399 return false; 9400 } else // trailing integer zero. 9401 sInt = Info.Ctx.MakeIntValue(0, EltTy); 9402 Elements.push_back(APValue(sInt)); 9403 CountElts++; 9404 } else { 9405 llvm::APFloat f(0.0); 9406 if (CountInits < NumInits) { 9407 if (!EvaluateFloat(E->getInit(CountInits), f, Info)) 9408 return false; 9409 } else // trailing float zero. 9410 f = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy)); 9411 Elements.push_back(APValue(f)); 9412 CountElts++; 9413 } 9414 CountInits++; 9415 } 9416 return Success(Elements, E); 9417 } 9418 9419 bool 9420 VectorExprEvaluator::ZeroInitialization(const Expr *E) { 9421 const auto *VT = E->getType()->castAs<VectorType>(); 9422 QualType EltTy = VT->getElementType(); 9423 APValue ZeroElement; 9424 if (EltTy->isIntegerType()) 9425 ZeroElement = APValue(Info.Ctx.MakeIntValue(0, EltTy)); 9426 else 9427 ZeroElement = 9428 APValue(APFloat::getZero(Info.Ctx.getFloatTypeSemantics(EltTy))); 9429 9430 SmallVector<APValue, 4> Elements(VT->getNumElements(), ZeroElement); 9431 return Success(Elements, E); 9432 } 9433 9434 bool VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) { 9435 VisitIgnoredValue(E->getSubExpr()); 9436 return ZeroInitialization(E); 9437 } 9438 9439 //===----------------------------------------------------------------------===// 9440 // Array Evaluation 9441 //===----------------------------------------------------------------------===// 9442 9443 namespace { 9444 class ArrayExprEvaluator 9445 : public ExprEvaluatorBase<ArrayExprEvaluator> { 9446 const LValue &This; 9447 APValue &Result; 9448 public: 9449 9450 ArrayExprEvaluator(EvalInfo &Info, const LValue &This, APValue &Result) 9451 : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {} 9452 9453 bool Success(const APValue &V, const Expr *E) { 9454 assert(V.isArray() && "expected array"); 9455 Result = V; 9456 return true; 9457 } 9458 9459 bool ZeroInitialization(const Expr *E) { 9460 const ConstantArrayType *CAT = 9461 Info.Ctx.getAsConstantArrayType(E->getType()); 9462 if (!CAT) 9463 return Error(E); 9464 9465 Result = APValue(APValue::UninitArray(), 0, 9466 CAT->getSize().getZExtValue()); 9467 if (!Result.hasArrayFiller()) return true; 9468 9469 // Zero-initialize all elements. 9470 LValue Subobject = This; 9471 Subobject.addArray(Info, E, CAT); 9472 ImplicitValueInitExpr VIE(CAT->getElementType()); 9473 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE); 9474 } 9475 9476 bool VisitCallExpr(const CallExpr *E) { 9477 return handleCallExpr(E, Result, &This); 9478 } 9479 bool VisitInitListExpr(const InitListExpr *E, 9480 QualType AllocType = QualType()); 9481 bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E); 9482 bool VisitCXXConstructExpr(const CXXConstructExpr *E); 9483 bool VisitCXXConstructExpr(const CXXConstructExpr *E, 9484 const LValue &Subobject, 9485 APValue *Value, QualType Type); 9486 bool VisitStringLiteral(const StringLiteral *E, 9487 QualType AllocType = QualType()) { 9488 expandStringLiteral(Info, E, Result, AllocType); 9489 return true; 9490 } 9491 }; 9492 } // end anonymous namespace 9493 9494 static bool EvaluateArray(const Expr *E, const LValue &This, 9495 APValue &Result, EvalInfo &Info) { 9496 assert(E->isRValue() && E->getType()->isArrayType() && "not an array rvalue"); 9497 return ArrayExprEvaluator(Info, This, Result).Visit(E); 9498 } 9499 9500 static bool EvaluateArrayNewInitList(EvalInfo &Info, LValue &This, 9501 APValue &Result, const InitListExpr *ILE, 9502 QualType AllocType) { 9503 assert(ILE->isRValue() && ILE->getType()->isArrayType() && 9504 "not an array rvalue"); 9505 return ArrayExprEvaluator(Info, This, Result) 9506 .VisitInitListExpr(ILE, AllocType); 9507 } 9508 9509 // Return true iff the given array filler may depend on the element index. 9510 static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) { 9511 // For now, just whitelist non-class value-initialization and initialization 9512 // lists comprised of them. 9513 if (isa<ImplicitValueInitExpr>(FillerExpr)) 9514 return false; 9515 if (const InitListExpr *ILE = dyn_cast<InitListExpr>(FillerExpr)) { 9516 for (unsigned I = 0, E = ILE->getNumInits(); I != E; ++I) { 9517 if (MaybeElementDependentArrayFiller(ILE->getInit(I))) 9518 return true; 9519 } 9520 return false; 9521 } 9522 return true; 9523 } 9524 9525 bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E, 9526 QualType AllocType) { 9527 const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType( 9528 AllocType.isNull() ? E->getType() : AllocType); 9529 if (!CAT) 9530 return Error(E); 9531 9532 // C++11 [dcl.init.string]p1: A char array [...] can be initialized by [...] 9533 // an appropriately-typed string literal enclosed in braces. 9534 if (E->isStringLiteralInit()) { 9535 auto *SL = dyn_cast<StringLiteral>(E->getInit(0)->IgnoreParens()); 9536 // FIXME: Support ObjCEncodeExpr here once we support it in 9537 // ArrayExprEvaluator generally. 9538 if (!SL) 9539 return Error(E); 9540 return VisitStringLiteral(SL, AllocType); 9541 } 9542 9543 bool Success = true; 9544 9545 assert((!Result.isArray() || Result.getArrayInitializedElts() == 0) && 9546 "zero-initialized array shouldn't have any initialized elts"); 9547 APValue Filler; 9548 if (Result.isArray() && Result.hasArrayFiller()) 9549 Filler = Result.getArrayFiller(); 9550 9551 unsigned NumEltsToInit = E->getNumInits(); 9552 unsigned NumElts = CAT->getSize().getZExtValue(); 9553 const Expr *FillerExpr = E->hasArrayFiller() ? E->getArrayFiller() : nullptr; 9554 9555 // If the initializer might depend on the array index, run it for each 9556 // array element. 9557 if (NumEltsToInit != NumElts && MaybeElementDependentArrayFiller(FillerExpr)) 9558 NumEltsToInit = NumElts; 9559 9560 LLVM_DEBUG(llvm::dbgs() << "The number of elements to initialize: " 9561 << NumEltsToInit << ".\n"); 9562 9563 Result = APValue(APValue::UninitArray(), NumEltsToInit, NumElts); 9564 9565 // If the array was previously zero-initialized, preserve the 9566 // zero-initialized values. 9567 if (Filler.hasValue()) { 9568 for (unsigned I = 0, E = Result.getArrayInitializedElts(); I != E; ++I) 9569 Result.getArrayInitializedElt(I) = Filler; 9570 if (Result.hasArrayFiller()) 9571 Result.getArrayFiller() = Filler; 9572 } 9573 9574 LValue Subobject = This; 9575 Subobject.addArray(Info, E, CAT); 9576 for (unsigned Index = 0; Index != NumEltsToInit; ++Index) { 9577 const Expr *Init = 9578 Index < E->getNumInits() ? E->getInit(Index) : FillerExpr; 9579 if (!EvaluateInPlace(Result.getArrayInitializedElt(Index), 9580 Info, Subobject, Init) || 9581 !HandleLValueArrayAdjustment(Info, Init, Subobject, 9582 CAT->getElementType(), 1)) { 9583 if (!Info.noteFailure()) 9584 return false; 9585 Success = false; 9586 } 9587 } 9588 9589 if (!Result.hasArrayFiller()) 9590 return Success; 9591 9592 // If we get here, we have a trivial filler, which we can just evaluate 9593 // once and splat over the rest of the array elements. 9594 assert(FillerExpr && "no array filler for incomplete init list"); 9595 return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, 9596 FillerExpr) && Success; 9597 } 9598 9599 bool ArrayExprEvaluator::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) { 9600 LValue CommonLV; 9601 if (E->getCommonExpr() && 9602 !Evaluate(Info.CurrentCall->createTemporary( 9603 E->getCommonExpr(), 9604 getStorageType(Info.Ctx, E->getCommonExpr()), false, 9605 CommonLV), 9606 Info, E->getCommonExpr()->getSourceExpr())) 9607 return false; 9608 9609 auto *CAT = cast<ConstantArrayType>(E->getType()->castAsArrayTypeUnsafe()); 9610 9611 uint64_t Elements = CAT->getSize().getZExtValue(); 9612 Result = APValue(APValue::UninitArray(), Elements, Elements); 9613 9614 LValue Subobject = This; 9615 Subobject.addArray(Info, E, CAT); 9616 9617 bool Success = true; 9618 for (EvalInfo::ArrayInitLoopIndex Index(Info); Index != Elements; ++Index) { 9619 if (!EvaluateInPlace(Result.getArrayInitializedElt(Index), 9620 Info, Subobject, E->getSubExpr()) || 9621 !HandleLValueArrayAdjustment(Info, E, Subobject, 9622 CAT->getElementType(), 1)) { 9623 if (!Info.noteFailure()) 9624 return false; 9625 Success = false; 9626 } 9627 } 9628 9629 return Success; 9630 } 9631 9632 bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E) { 9633 return VisitCXXConstructExpr(E, This, &Result, E->getType()); 9634 } 9635 9636 bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E, 9637 const LValue &Subobject, 9638 APValue *Value, 9639 QualType Type) { 9640 bool HadZeroInit = Value->hasValue(); 9641 9642 if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(Type)) { 9643 unsigned N = CAT->getSize().getZExtValue(); 9644 9645 // Preserve the array filler if we had prior zero-initialization. 9646 APValue Filler = 9647 HadZeroInit && Value->hasArrayFiller() ? Value->getArrayFiller() 9648 : APValue(); 9649 9650 *Value = APValue(APValue::UninitArray(), N, N); 9651 9652 if (HadZeroInit) 9653 for (unsigned I = 0; I != N; ++I) 9654 Value->getArrayInitializedElt(I) = Filler; 9655 9656 // Initialize the elements. 9657 LValue ArrayElt = Subobject; 9658 ArrayElt.addArray(Info, E, CAT); 9659 for (unsigned I = 0; I != N; ++I) 9660 if (!VisitCXXConstructExpr(E, ArrayElt, &Value->getArrayInitializedElt(I), 9661 CAT->getElementType()) || 9662 !HandleLValueArrayAdjustment(Info, E, ArrayElt, 9663 CAT->getElementType(), 1)) 9664 return false; 9665 9666 return true; 9667 } 9668 9669 if (!Type->isRecordType()) 9670 return Error(E); 9671 9672 return RecordExprEvaluator(Info, Subobject, *Value) 9673 .VisitCXXConstructExpr(E, Type); 9674 } 9675 9676 //===----------------------------------------------------------------------===// 9677 // Integer Evaluation 9678 // 9679 // As a GNU extension, we support casting pointers to sufficiently-wide integer 9680 // types and back in constant folding. Integer values are thus represented 9681 // either as an integer-valued APValue, or as an lvalue-valued APValue. 9682 //===----------------------------------------------------------------------===// 9683 9684 namespace { 9685 class IntExprEvaluator 9686 : public ExprEvaluatorBase<IntExprEvaluator> { 9687 APValue &Result; 9688 public: 9689 IntExprEvaluator(EvalInfo &info, APValue &result) 9690 : ExprEvaluatorBaseTy(info), Result(result) {} 9691 9692 bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) { 9693 assert(E->getType()->isIntegralOrEnumerationType() && 9694 "Invalid evaluation result."); 9695 assert(SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType() && 9696 "Invalid evaluation result."); 9697 assert(SI.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) && 9698 "Invalid evaluation result."); 9699 Result = APValue(SI); 9700 return true; 9701 } 9702 bool Success(const llvm::APSInt &SI, const Expr *E) { 9703 return Success(SI, E, Result); 9704 } 9705 9706 bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) { 9707 assert(E->getType()->isIntegralOrEnumerationType() && 9708 "Invalid evaluation result."); 9709 assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) && 9710 "Invalid evaluation result."); 9711 Result = APValue(APSInt(I)); 9712 Result.getInt().setIsUnsigned( 9713 E->getType()->isUnsignedIntegerOrEnumerationType()); 9714 return true; 9715 } 9716 bool Success(const llvm::APInt &I, const Expr *E) { 9717 return Success(I, E, Result); 9718 } 9719 9720 bool Success(uint64_t Value, const Expr *E, APValue &Result) { 9721 assert(E->getType()->isIntegralOrEnumerationType() && 9722 "Invalid evaluation result."); 9723 Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType())); 9724 return true; 9725 } 9726 bool Success(uint64_t Value, const Expr *E) { 9727 return Success(Value, E, Result); 9728 } 9729 9730 bool Success(CharUnits Size, const Expr *E) { 9731 return Success(Size.getQuantity(), E); 9732 } 9733 9734 bool Success(const APValue &V, const Expr *E) { 9735 if (V.isLValue() || V.isAddrLabelDiff() || V.isIndeterminate()) { 9736 Result = V; 9737 return true; 9738 } 9739 return Success(V.getInt(), E); 9740 } 9741 9742 bool ZeroInitialization(const Expr *E) { return Success(0, E); } 9743 9744 //===--------------------------------------------------------------------===// 9745 // Visitor Methods 9746 //===--------------------------------------------------------------------===// 9747 9748 bool VisitConstantExpr(const ConstantExpr *E); 9749 9750 bool VisitIntegerLiteral(const IntegerLiteral *E) { 9751 return Success(E->getValue(), E); 9752 } 9753 bool VisitCharacterLiteral(const CharacterLiteral *E) { 9754 return Success(E->getValue(), E); 9755 } 9756 9757 bool CheckReferencedDecl(const Expr *E, const Decl *D); 9758 bool VisitDeclRefExpr(const DeclRefExpr *E) { 9759 if (CheckReferencedDecl(E, E->getDecl())) 9760 return true; 9761 9762 return ExprEvaluatorBaseTy::VisitDeclRefExpr(E); 9763 } 9764 bool VisitMemberExpr(const MemberExpr *E) { 9765 if (CheckReferencedDecl(E, E->getMemberDecl())) { 9766 VisitIgnoredBaseExpression(E->getBase()); 9767 return true; 9768 } 9769 9770 return ExprEvaluatorBaseTy::VisitMemberExpr(E); 9771 } 9772 9773 bool VisitCallExpr(const CallExpr *E); 9774 bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp); 9775 bool VisitBinaryOperator(const BinaryOperator *E); 9776 bool VisitOffsetOfExpr(const OffsetOfExpr *E); 9777 bool VisitUnaryOperator(const UnaryOperator *E); 9778 9779 bool VisitCastExpr(const CastExpr* E); 9780 bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E); 9781 9782 bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 9783 return Success(E->getValue(), E); 9784 } 9785 9786 bool VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) { 9787 return Success(E->getValue(), E); 9788 } 9789 9790 bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E) { 9791 if (Info.ArrayInitIndex == uint64_t(-1)) { 9792 // We were asked to evaluate this subexpression independent of the 9793 // enclosing ArrayInitLoopExpr. We can't do that. 9794 Info.FFDiag(E); 9795 return false; 9796 } 9797 return Success(Info.ArrayInitIndex, E); 9798 } 9799 9800 // Note, GNU defines __null as an integer, not a pointer. 9801 bool VisitGNUNullExpr(const GNUNullExpr *E) { 9802 return ZeroInitialization(E); 9803 } 9804 9805 bool VisitTypeTraitExpr(const TypeTraitExpr *E) { 9806 return Success(E->getValue(), E); 9807 } 9808 9809 bool VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) { 9810 return Success(E->getValue(), E); 9811 } 9812 9813 bool VisitExpressionTraitExpr(const ExpressionTraitExpr *E) { 9814 return Success(E->getValue(), E); 9815 } 9816 9817 bool VisitUnaryReal(const UnaryOperator *E); 9818 bool VisitUnaryImag(const UnaryOperator *E); 9819 9820 bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E); 9821 bool VisitSizeOfPackExpr(const SizeOfPackExpr *E); 9822 bool VisitSourceLocExpr(const SourceLocExpr *E); 9823 bool VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E); 9824 // FIXME: Missing: array subscript of vector, member of vector 9825 }; 9826 9827 class FixedPointExprEvaluator 9828 : public ExprEvaluatorBase<FixedPointExprEvaluator> { 9829 APValue &Result; 9830 9831 public: 9832 FixedPointExprEvaluator(EvalInfo &info, APValue &result) 9833 : ExprEvaluatorBaseTy(info), Result(result) {} 9834 9835 bool Success(const llvm::APInt &I, const Expr *E) { 9836 return Success( 9837 APFixedPoint(I, Info.Ctx.getFixedPointSemantics(E->getType())), E); 9838 } 9839 9840 bool Success(uint64_t Value, const Expr *E) { 9841 return Success( 9842 APFixedPoint(Value, Info.Ctx.getFixedPointSemantics(E->getType())), E); 9843 } 9844 9845 bool Success(const APValue &V, const Expr *E) { 9846 return Success(V.getFixedPoint(), E); 9847 } 9848 9849 bool Success(const APFixedPoint &V, const Expr *E) { 9850 assert(E->getType()->isFixedPointType() && "Invalid evaluation result."); 9851 assert(V.getWidth() == Info.Ctx.getIntWidth(E->getType()) && 9852 "Invalid evaluation result."); 9853 Result = APValue(V); 9854 return true; 9855 } 9856 9857 //===--------------------------------------------------------------------===// 9858 // Visitor Methods 9859 //===--------------------------------------------------------------------===// 9860 9861 bool VisitFixedPointLiteral(const FixedPointLiteral *E) { 9862 return Success(E->getValue(), E); 9863 } 9864 9865 bool VisitCastExpr(const CastExpr *E); 9866 bool VisitUnaryOperator(const UnaryOperator *E); 9867 bool VisitBinaryOperator(const BinaryOperator *E); 9868 }; 9869 } // end anonymous namespace 9870 9871 /// EvaluateIntegerOrLValue - Evaluate an rvalue integral-typed expression, and 9872 /// produce either the integer value or a pointer. 9873 /// 9874 /// GCC has a heinous extension which folds casts between pointer types and 9875 /// pointer-sized integral types. We support this by allowing the evaluation of 9876 /// an integer rvalue to produce a pointer (represented as an lvalue) instead. 9877 /// Some simple arithmetic on such values is supported (they are treated much 9878 /// like char*). 9879 static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result, 9880 EvalInfo &Info) { 9881 assert(E->isRValue() && E->getType()->isIntegralOrEnumerationType()); 9882 return IntExprEvaluator(Info, Result).Visit(E); 9883 } 9884 9885 static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) { 9886 APValue Val; 9887 if (!EvaluateIntegerOrLValue(E, Val, Info)) 9888 return false; 9889 if (!Val.isInt()) { 9890 // FIXME: It would be better to produce the diagnostic for casting 9891 // a pointer to an integer. 9892 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 9893 return false; 9894 } 9895 Result = Val.getInt(); 9896 return true; 9897 } 9898 9899 bool IntExprEvaluator::VisitSourceLocExpr(const SourceLocExpr *E) { 9900 APValue Evaluated = E->EvaluateInContext( 9901 Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr()); 9902 return Success(Evaluated, E); 9903 } 9904 9905 static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result, 9906 EvalInfo &Info) { 9907 if (E->getType()->isFixedPointType()) { 9908 APValue Val; 9909 if (!FixedPointExprEvaluator(Info, Val).Visit(E)) 9910 return false; 9911 if (!Val.isFixedPoint()) 9912 return false; 9913 9914 Result = Val.getFixedPoint(); 9915 return true; 9916 } 9917 return false; 9918 } 9919 9920 static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result, 9921 EvalInfo &Info) { 9922 if (E->getType()->isIntegerType()) { 9923 auto FXSema = Info.Ctx.getFixedPointSemantics(E->getType()); 9924 APSInt Val; 9925 if (!EvaluateInteger(E, Val, Info)) 9926 return false; 9927 Result = APFixedPoint(Val, FXSema); 9928 return true; 9929 } else if (E->getType()->isFixedPointType()) { 9930 return EvaluateFixedPoint(E, Result, Info); 9931 } 9932 return false; 9933 } 9934 9935 /// Check whether the given declaration can be directly converted to an integral 9936 /// rvalue. If not, no diagnostic is produced; there are other things we can 9937 /// try. 9938 bool IntExprEvaluator::CheckReferencedDecl(const Expr* E, const Decl* D) { 9939 // Enums are integer constant exprs. 9940 if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) { 9941 // Check for signedness/width mismatches between E type and ECD value. 9942 bool SameSign = (ECD->getInitVal().isSigned() 9943 == E->getType()->isSignedIntegerOrEnumerationType()); 9944 bool SameWidth = (ECD->getInitVal().getBitWidth() 9945 == Info.Ctx.getIntWidth(E->getType())); 9946 if (SameSign && SameWidth) 9947 return Success(ECD->getInitVal(), E); 9948 else { 9949 // Get rid of mismatch (otherwise Success assertions will fail) 9950 // by computing a new value matching the type of E. 9951 llvm::APSInt Val = ECD->getInitVal(); 9952 if (!SameSign) 9953 Val.setIsSigned(!ECD->getInitVal().isSigned()); 9954 if (!SameWidth) 9955 Val = Val.extOrTrunc(Info.Ctx.getIntWidth(E->getType())); 9956 return Success(Val, E); 9957 } 9958 } 9959 return false; 9960 } 9961 9962 /// Values returned by __builtin_classify_type, chosen to match the values 9963 /// produced by GCC's builtin. 9964 enum class GCCTypeClass { 9965 None = -1, 9966 Void = 0, 9967 Integer = 1, 9968 // GCC reserves 2 for character types, but instead classifies them as 9969 // integers. 9970 Enum = 3, 9971 Bool = 4, 9972 Pointer = 5, 9973 // GCC reserves 6 for references, but appears to never use it (because 9974 // expressions never have reference type, presumably). 9975 PointerToDataMember = 7, 9976 RealFloat = 8, 9977 Complex = 9, 9978 // GCC reserves 10 for functions, but does not use it since GCC version 6 due 9979 // to decay to pointer. (Prior to version 6 it was only used in C++ mode). 9980 // GCC claims to reserve 11 for pointers to member functions, but *actually* 9981 // uses 12 for that purpose, same as for a class or struct. Maybe it 9982 // internally implements a pointer to member as a struct? Who knows. 9983 PointerToMemberFunction = 12, // Not a bug, see above. 9984 ClassOrStruct = 12, 9985 Union = 13, 9986 // GCC reserves 14 for arrays, but does not use it since GCC version 6 due to 9987 // decay to pointer. (Prior to version 6 it was only used in C++ mode). 9988 // GCC reserves 15 for strings, but actually uses 5 (pointer) for string 9989 // literals. 9990 }; 9991 9992 /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way 9993 /// as GCC. 9994 static GCCTypeClass 9995 EvaluateBuiltinClassifyType(QualType T, const LangOptions &LangOpts) { 9996 assert(!T->isDependentType() && "unexpected dependent type"); 9997 9998 QualType CanTy = T.getCanonicalType(); 9999 const BuiltinType *BT = dyn_cast<BuiltinType>(CanTy); 10000 10001 switch (CanTy->getTypeClass()) { 10002 #define TYPE(ID, BASE) 10003 #define DEPENDENT_TYPE(ID, BASE) case Type::ID: 10004 #define NON_CANONICAL_TYPE(ID, BASE) case Type::ID: 10005 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(ID, BASE) case Type::ID: 10006 #include "clang/AST/TypeNodes.inc" 10007 case Type::Auto: 10008 case Type::DeducedTemplateSpecialization: 10009 llvm_unreachable("unexpected non-canonical or dependent type"); 10010 10011 case Type::Builtin: 10012 switch (BT->getKind()) { 10013 #define BUILTIN_TYPE(ID, SINGLETON_ID) 10014 #define SIGNED_TYPE(ID, SINGLETON_ID) \ 10015 case BuiltinType::ID: return GCCTypeClass::Integer; 10016 #define FLOATING_TYPE(ID, SINGLETON_ID) \ 10017 case BuiltinType::ID: return GCCTypeClass::RealFloat; 10018 #define PLACEHOLDER_TYPE(ID, SINGLETON_ID) \ 10019 case BuiltinType::ID: break; 10020 #include "clang/AST/BuiltinTypes.def" 10021 case BuiltinType::Void: 10022 return GCCTypeClass::Void; 10023 10024 case BuiltinType::Bool: 10025 return GCCTypeClass::Bool; 10026 10027 case BuiltinType::Char_U: 10028 case BuiltinType::UChar: 10029 case BuiltinType::WChar_U: 10030 case BuiltinType::Char8: 10031 case BuiltinType::Char16: 10032 case BuiltinType::Char32: 10033 case BuiltinType::UShort: 10034 case BuiltinType::UInt: 10035 case BuiltinType::ULong: 10036 case BuiltinType::ULongLong: 10037 case BuiltinType::UInt128: 10038 return GCCTypeClass::Integer; 10039 10040 case BuiltinType::UShortAccum: 10041 case BuiltinType::UAccum: 10042 case BuiltinType::ULongAccum: 10043 case BuiltinType::UShortFract: 10044 case BuiltinType::UFract: 10045 case BuiltinType::ULongFract: 10046 case BuiltinType::SatUShortAccum: 10047 case BuiltinType::SatUAccum: 10048 case BuiltinType::SatULongAccum: 10049 case BuiltinType::SatUShortFract: 10050 case BuiltinType::SatUFract: 10051 case BuiltinType::SatULongFract: 10052 return GCCTypeClass::None; 10053 10054 case BuiltinType::NullPtr: 10055 10056 case BuiltinType::ObjCId: 10057 case BuiltinType::ObjCClass: 10058 case BuiltinType::ObjCSel: 10059 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 10060 case BuiltinType::Id: 10061 #include "clang/Basic/OpenCLImageTypes.def" 10062 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 10063 case BuiltinType::Id: 10064 #include "clang/Basic/OpenCLExtensionTypes.def" 10065 case BuiltinType::OCLSampler: 10066 case BuiltinType::OCLEvent: 10067 case BuiltinType::OCLClkEvent: 10068 case BuiltinType::OCLQueue: 10069 case BuiltinType::OCLReserveID: 10070 #define SVE_TYPE(Name, Id, SingletonId) \ 10071 case BuiltinType::Id: 10072 #include "clang/Basic/AArch64SVEACLETypes.def" 10073 return GCCTypeClass::None; 10074 10075 case BuiltinType::Dependent: 10076 llvm_unreachable("unexpected dependent type"); 10077 }; 10078 llvm_unreachable("unexpected placeholder type"); 10079 10080 case Type::Enum: 10081 return LangOpts.CPlusPlus ? GCCTypeClass::Enum : GCCTypeClass::Integer; 10082 10083 case Type::Pointer: 10084 case Type::ConstantArray: 10085 case Type::VariableArray: 10086 case Type::IncompleteArray: 10087 case Type::FunctionNoProto: 10088 case Type::FunctionProto: 10089 return GCCTypeClass::Pointer; 10090 10091 case Type::MemberPointer: 10092 return CanTy->isMemberDataPointerType() 10093 ? GCCTypeClass::PointerToDataMember 10094 : GCCTypeClass::PointerToMemberFunction; 10095 10096 case Type::Complex: 10097 return GCCTypeClass::Complex; 10098 10099 case Type::Record: 10100 return CanTy->isUnionType() ? GCCTypeClass::Union 10101 : GCCTypeClass::ClassOrStruct; 10102 10103 case Type::Atomic: 10104 // GCC classifies _Atomic T the same as T. 10105 return EvaluateBuiltinClassifyType( 10106 CanTy->castAs<AtomicType>()->getValueType(), LangOpts); 10107 10108 case Type::BlockPointer: 10109 case Type::Vector: 10110 case Type::ExtVector: 10111 case Type::ObjCObject: 10112 case Type::ObjCInterface: 10113 case Type::ObjCObjectPointer: 10114 case Type::Pipe: 10115 // GCC classifies vectors as None. We follow its lead and classify all 10116 // other types that don't fit into the regular classification the same way. 10117 return GCCTypeClass::None; 10118 10119 case Type::LValueReference: 10120 case Type::RValueReference: 10121 llvm_unreachable("invalid type for expression"); 10122 } 10123 10124 llvm_unreachable("unexpected type class"); 10125 } 10126 10127 /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way 10128 /// as GCC. 10129 static GCCTypeClass 10130 EvaluateBuiltinClassifyType(const CallExpr *E, const LangOptions &LangOpts) { 10131 // If no argument was supplied, default to None. This isn't 10132 // ideal, however it is what gcc does. 10133 if (E->getNumArgs() == 0) 10134 return GCCTypeClass::None; 10135 10136 // FIXME: Bizarrely, GCC treats a call with more than one argument as not 10137 // being an ICE, but still folds it to a constant using the type of the first 10138 // argument. 10139 return EvaluateBuiltinClassifyType(E->getArg(0)->getType(), LangOpts); 10140 } 10141 10142 /// EvaluateBuiltinConstantPForLValue - Determine the result of 10143 /// __builtin_constant_p when applied to the given pointer. 10144 /// 10145 /// A pointer is only "constant" if it is null (or a pointer cast to integer) 10146 /// or it points to the first character of a string literal. 10147 static bool EvaluateBuiltinConstantPForLValue(const APValue &LV) { 10148 APValue::LValueBase Base = LV.getLValueBase(); 10149 if (Base.isNull()) { 10150 // A null base is acceptable. 10151 return true; 10152 } else if (const Expr *E = Base.dyn_cast<const Expr *>()) { 10153 if (!isa<StringLiteral>(E)) 10154 return false; 10155 return LV.getLValueOffset().isZero(); 10156 } else if (Base.is<TypeInfoLValue>()) { 10157 // Surprisingly, GCC considers __builtin_constant_p(&typeid(int)) to 10158 // evaluate to true. 10159 return true; 10160 } else { 10161 // Any other base is not constant enough for GCC. 10162 return false; 10163 } 10164 } 10165 10166 /// EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to 10167 /// GCC as we can manage. 10168 static bool EvaluateBuiltinConstantP(EvalInfo &Info, const Expr *Arg) { 10169 // This evaluation is not permitted to have side-effects, so evaluate it in 10170 // a speculative evaluation context. 10171 SpeculativeEvaluationRAII SpeculativeEval(Info); 10172 10173 // Constant-folding is always enabled for the operand of __builtin_constant_p 10174 // (even when the enclosing evaluation context otherwise requires a strict 10175 // language-specific constant expression). 10176 FoldConstant Fold(Info, true); 10177 10178 QualType ArgType = Arg->getType(); 10179 10180 // __builtin_constant_p always has one operand. The rules which gcc follows 10181 // are not precisely documented, but are as follows: 10182 // 10183 // - If the operand is of integral, floating, complex or enumeration type, 10184 // and can be folded to a known value of that type, it returns 1. 10185 // - If the operand can be folded to a pointer to the first character 10186 // of a string literal (or such a pointer cast to an integral type) 10187 // or to a null pointer or an integer cast to a pointer, it returns 1. 10188 // 10189 // Otherwise, it returns 0. 10190 // 10191 // FIXME: GCC also intends to return 1 for literals of aggregate types, but 10192 // its support for this did not work prior to GCC 9 and is not yet well 10193 // understood. 10194 if (ArgType->isIntegralOrEnumerationType() || ArgType->isFloatingType() || 10195 ArgType->isAnyComplexType() || ArgType->isPointerType() || 10196 ArgType->isNullPtrType()) { 10197 APValue V; 10198 if (!::EvaluateAsRValue(Info, Arg, V)) { 10199 Fold.keepDiagnostics(); 10200 return false; 10201 } 10202 10203 // For a pointer (possibly cast to integer), there are special rules. 10204 if (V.getKind() == APValue::LValue) 10205 return EvaluateBuiltinConstantPForLValue(V); 10206 10207 // Otherwise, any constant value is good enough. 10208 return V.hasValue(); 10209 } 10210 10211 // Anything else isn't considered to be sufficiently constant. 10212 return false; 10213 } 10214 10215 /// Retrieves the "underlying object type" of the given expression, 10216 /// as used by __builtin_object_size. 10217 static QualType getObjectType(APValue::LValueBase B) { 10218 if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) { 10219 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 10220 return VD->getType(); 10221 } else if (const Expr *E = B.get<const Expr*>()) { 10222 if (isa<CompoundLiteralExpr>(E)) 10223 return E->getType(); 10224 } else if (B.is<TypeInfoLValue>()) { 10225 return B.getTypeInfoType(); 10226 } else if (B.is<DynamicAllocLValue>()) { 10227 return B.getDynamicAllocType(); 10228 } 10229 10230 return QualType(); 10231 } 10232 10233 /// A more selective version of E->IgnoreParenCasts for 10234 /// tryEvaluateBuiltinObjectSize. This ignores some casts/parens that serve only 10235 /// to change the type of E. 10236 /// Ex. For E = `(short*)((char*)(&foo))`, returns `&foo` 10237 /// 10238 /// Always returns an RValue with a pointer representation. 10239 static const Expr *ignorePointerCastsAndParens(const Expr *E) { 10240 assert(E->isRValue() && E->getType()->hasPointerRepresentation()); 10241 10242 auto *NoParens = E->IgnoreParens(); 10243 auto *Cast = dyn_cast<CastExpr>(NoParens); 10244 if (Cast == nullptr) 10245 return NoParens; 10246 10247 // We only conservatively allow a few kinds of casts, because this code is 10248 // inherently a simple solution that seeks to support the common case. 10249 auto CastKind = Cast->getCastKind(); 10250 if (CastKind != CK_NoOp && CastKind != CK_BitCast && 10251 CastKind != CK_AddressSpaceConversion) 10252 return NoParens; 10253 10254 auto *SubExpr = Cast->getSubExpr(); 10255 if (!SubExpr->getType()->hasPointerRepresentation() || !SubExpr->isRValue()) 10256 return NoParens; 10257 return ignorePointerCastsAndParens(SubExpr); 10258 } 10259 10260 /// Checks to see if the given LValue's Designator is at the end of the LValue's 10261 /// record layout. e.g. 10262 /// struct { struct { int a, b; } fst, snd; } obj; 10263 /// obj.fst // no 10264 /// obj.snd // yes 10265 /// obj.fst.a // no 10266 /// obj.fst.b // no 10267 /// obj.snd.a // no 10268 /// obj.snd.b // yes 10269 /// 10270 /// Please note: this function is specialized for how __builtin_object_size 10271 /// views "objects". 10272 /// 10273 /// If this encounters an invalid RecordDecl or otherwise cannot determine the 10274 /// correct result, it will always return true. 10275 static bool isDesignatorAtObjectEnd(const ASTContext &Ctx, const LValue &LVal) { 10276 assert(!LVal.Designator.Invalid); 10277 10278 auto IsLastOrInvalidFieldDecl = [&Ctx](const FieldDecl *FD, bool &Invalid) { 10279 const RecordDecl *Parent = FD->getParent(); 10280 Invalid = Parent->isInvalidDecl(); 10281 if (Invalid || Parent->isUnion()) 10282 return true; 10283 const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(Parent); 10284 return FD->getFieldIndex() + 1 == Layout.getFieldCount(); 10285 }; 10286 10287 auto &Base = LVal.getLValueBase(); 10288 if (auto *ME = dyn_cast_or_null<MemberExpr>(Base.dyn_cast<const Expr *>())) { 10289 if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) { 10290 bool Invalid; 10291 if (!IsLastOrInvalidFieldDecl(FD, Invalid)) 10292 return Invalid; 10293 } else if (auto *IFD = dyn_cast<IndirectFieldDecl>(ME->getMemberDecl())) { 10294 for (auto *FD : IFD->chain()) { 10295 bool Invalid; 10296 if (!IsLastOrInvalidFieldDecl(cast<FieldDecl>(FD), Invalid)) 10297 return Invalid; 10298 } 10299 } 10300 } 10301 10302 unsigned I = 0; 10303 QualType BaseType = getType(Base); 10304 if (LVal.Designator.FirstEntryIsAnUnsizedArray) { 10305 // If we don't know the array bound, conservatively assume we're looking at 10306 // the final array element. 10307 ++I; 10308 if (BaseType->isIncompleteArrayType()) 10309 BaseType = Ctx.getAsArrayType(BaseType)->getElementType(); 10310 else 10311 BaseType = BaseType->castAs<PointerType>()->getPointeeType(); 10312 } 10313 10314 for (unsigned E = LVal.Designator.Entries.size(); I != E; ++I) { 10315 const auto &Entry = LVal.Designator.Entries[I]; 10316 if (BaseType->isArrayType()) { 10317 // Because __builtin_object_size treats arrays as objects, we can ignore 10318 // the index iff this is the last array in the Designator. 10319 if (I + 1 == E) 10320 return true; 10321 const auto *CAT = cast<ConstantArrayType>(Ctx.getAsArrayType(BaseType)); 10322 uint64_t Index = Entry.getAsArrayIndex(); 10323 if (Index + 1 != CAT->getSize()) 10324 return false; 10325 BaseType = CAT->getElementType(); 10326 } else if (BaseType->isAnyComplexType()) { 10327 const auto *CT = BaseType->castAs<ComplexType>(); 10328 uint64_t Index = Entry.getAsArrayIndex(); 10329 if (Index != 1) 10330 return false; 10331 BaseType = CT->getElementType(); 10332 } else if (auto *FD = getAsField(Entry)) { 10333 bool Invalid; 10334 if (!IsLastOrInvalidFieldDecl(FD, Invalid)) 10335 return Invalid; 10336 BaseType = FD->getType(); 10337 } else { 10338 assert(getAsBaseClass(Entry) && "Expecting cast to a base class"); 10339 return false; 10340 } 10341 } 10342 return true; 10343 } 10344 10345 /// Tests to see if the LValue has a user-specified designator (that isn't 10346 /// necessarily valid). Note that this always returns 'true' if the LValue has 10347 /// an unsized array as its first designator entry, because there's currently no 10348 /// way to tell if the user typed *foo or foo[0]. 10349 static bool refersToCompleteObject(const LValue &LVal) { 10350 if (LVal.Designator.Invalid) 10351 return false; 10352 10353 if (!LVal.Designator.Entries.empty()) 10354 return LVal.Designator.isMostDerivedAnUnsizedArray(); 10355 10356 if (!LVal.InvalidBase) 10357 return true; 10358 10359 // If `E` is a MemberExpr, then the first part of the designator is hiding in 10360 // the LValueBase. 10361 const auto *E = LVal.Base.dyn_cast<const Expr *>(); 10362 return !E || !isa<MemberExpr>(E); 10363 } 10364 10365 /// Attempts to detect a user writing into a piece of memory that's impossible 10366 /// to figure out the size of by just using types. 10367 static bool isUserWritingOffTheEnd(const ASTContext &Ctx, const LValue &LVal) { 10368 const SubobjectDesignator &Designator = LVal.Designator; 10369 // Notes: 10370 // - Users can only write off of the end when we have an invalid base. Invalid 10371 // bases imply we don't know where the memory came from. 10372 // - We used to be a bit more aggressive here; we'd only be conservative if 10373 // the array at the end was flexible, or if it had 0 or 1 elements. This 10374 // broke some common standard library extensions (PR30346), but was 10375 // otherwise seemingly fine. It may be useful to reintroduce this behavior 10376 // with some sort of whitelist. OTOH, it seems that GCC is always 10377 // conservative with the last element in structs (if it's an array), so our 10378 // current behavior is more compatible than a whitelisting approach would 10379 // be. 10380 return LVal.InvalidBase && 10381 Designator.Entries.size() == Designator.MostDerivedPathLength && 10382 Designator.MostDerivedIsArrayElement && 10383 isDesignatorAtObjectEnd(Ctx, LVal); 10384 } 10385 10386 /// Converts the given APInt to CharUnits, assuming the APInt is unsigned. 10387 /// Fails if the conversion would cause loss of precision. 10388 static bool convertUnsignedAPIntToCharUnits(const llvm::APInt &Int, 10389 CharUnits &Result) { 10390 auto CharUnitsMax = std::numeric_limits<CharUnits::QuantityType>::max(); 10391 if (Int.ugt(CharUnitsMax)) 10392 return false; 10393 Result = CharUnits::fromQuantity(Int.getZExtValue()); 10394 return true; 10395 } 10396 10397 /// Helper for tryEvaluateBuiltinObjectSize -- Given an LValue, this will 10398 /// determine how many bytes exist from the beginning of the object to either 10399 /// the end of the current subobject, or the end of the object itself, depending 10400 /// on what the LValue looks like + the value of Type. 10401 /// 10402 /// If this returns false, the value of Result is undefined. 10403 static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc, 10404 unsigned Type, const LValue &LVal, 10405 CharUnits &EndOffset) { 10406 bool DetermineForCompleteObject = refersToCompleteObject(LVal); 10407 10408 auto CheckedHandleSizeof = [&](QualType Ty, CharUnits &Result) { 10409 if (Ty.isNull() || Ty->isIncompleteType() || Ty->isFunctionType()) 10410 return false; 10411 return HandleSizeof(Info, ExprLoc, Ty, Result); 10412 }; 10413 10414 // We want to evaluate the size of the entire object. This is a valid fallback 10415 // for when Type=1 and the designator is invalid, because we're asked for an 10416 // upper-bound. 10417 if (!(Type & 1) || LVal.Designator.Invalid || DetermineForCompleteObject) { 10418 // Type=3 wants a lower bound, so we can't fall back to this. 10419 if (Type == 3 && !DetermineForCompleteObject) 10420 return false; 10421 10422 llvm::APInt APEndOffset; 10423 if (isBaseAnAllocSizeCall(LVal.getLValueBase()) && 10424 getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset)) 10425 return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset); 10426 10427 if (LVal.InvalidBase) 10428 return false; 10429 10430 QualType BaseTy = getObjectType(LVal.getLValueBase()); 10431 return CheckedHandleSizeof(BaseTy, EndOffset); 10432 } 10433 10434 // We want to evaluate the size of a subobject. 10435 const SubobjectDesignator &Designator = LVal.Designator; 10436 10437 // The following is a moderately common idiom in C: 10438 // 10439 // struct Foo { int a; char c[1]; }; 10440 // struct Foo *F = (struct Foo *)malloc(sizeof(struct Foo) + strlen(Bar)); 10441 // strcpy(&F->c[0], Bar); 10442 // 10443 // In order to not break too much legacy code, we need to support it. 10444 if (isUserWritingOffTheEnd(Info.Ctx, LVal)) { 10445 // If we can resolve this to an alloc_size call, we can hand that back, 10446 // because we know for certain how many bytes there are to write to. 10447 llvm::APInt APEndOffset; 10448 if (isBaseAnAllocSizeCall(LVal.getLValueBase()) && 10449 getBytesReturnedByAllocSizeCall(Info.Ctx, LVal, APEndOffset)) 10450 return convertUnsignedAPIntToCharUnits(APEndOffset, EndOffset); 10451 10452 // If we cannot determine the size of the initial allocation, then we can't 10453 // given an accurate upper-bound. However, we are still able to give 10454 // conservative lower-bounds for Type=3. 10455 if (Type == 1) 10456 return false; 10457 } 10458 10459 CharUnits BytesPerElem; 10460 if (!CheckedHandleSizeof(Designator.MostDerivedType, BytesPerElem)) 10461 return false; 10462 10463 // According to the GCC documentation, we want the size of the subobject 10464 // denoted by the pointer. But that's not quite right -- what we actually 10465 // want is the size of the immediately-enclosing array, if there is one. 10466 int64_t ElemsRemaining; 10467 if (Designator.MostDerivedIsArrayElement && 10468 Designator.Entries.size() == Designator.MostDerivedPathLength) { 10469 uint64_t ArraySize = Designator.getMostDerivedArraySize(); 10470 uint64_t ArrayIndex = Designator.Entries.back().getAsArrayIndex(); 10471 ElemsRemaining = ArraySize <= ArrayIndex ? 0 : ArraySize - ArrayIndex; 10472 } else { 10473 ElemsRemaining = Designator.isOnePastTheEnd() ? 0 : 1; 10474 } 10475 10476 EndOffset = LVal.getLValueOffset() + BytesPerElem * ElemsRemaining; 10477 return true; 10478 } 10479 10480 /// Tries to evaluate the __builtin_object_size for @p E. If successful, 10481 /// returns true and stores the result in @p Size. 10482 /// 10483 /// If @p WasError is non-null, this will report whether the failure to evaluate 10484 /// is to be treated as an Error in IntExprEvaluator. 10485 static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type, 10486 EvalInfo &Info, uint64_t &Size) { 10487 // Determine the denoted object. 10488 LValue LVal; 10489 { 10490 // The operand of __builtin_object_size is never evaluated for side-effects. 10491 // If there are any, but we can determine the pointed-to object anyway, then 10492 // ignore the side-effects. 10493 SpeculativeEvaluationRAII SpeculativeEval(Info); 10494 IgnoreSideEffectsRAII Fold(Info); 10495 10496 if (E->isGLValue()) { 10497 // It's possible for us to be given GLValues if we're called via 10498 // Expr::tryEvaluateObjectSize. 10499 APValue RVal; 10500 if (!EvaluateAsRValue(Info, E, RVal)) 10501 return false; 10502 LVal.setFrom(Info.Ctx, RVal); 10503 } else if (!EvaluatePointer(ignorePointerCastsAndParens(E), LVal, Info, 10504 /*InvalidBaseOK=*/true)) 10505 return false; 10506 } 10507 10508 // If we point to before the start of the object, there are no accessible 10509 // bytes. 10510 if (LVal.getLValueOffset().isNegative()) { 10511 Size = 0; 10512 return true; 10513 } 10514 10515 CharUnits EndOffset; 10516 if (!determineEndOffset(Info, E->getExprLoc(), Type, LVal, EndOffset)) 10517 return false; 10518 10519 // If we've fallen outside of the end offset, just pretend there's nothing to 10520 // write to/read from. 10521 if (EndOffset <= LVal.getLValueOffset()) 10522 Size = 0; 10523 else 10524 Size = (EndOffset - LVal.getLValueOffset()).getQuantity(); 10525 return true; 10526 } 10527 10528 bool IntExprEvaluator::VisitConstantExpr(const ConstantExpr *E) { 10529 llvm::SaveAndRestore<bool> InConstantContext(Info.InConstantContext, true); 10530 if (E->getResultAPValueKind() != APValue::None) 10531 return Success(E->getAPValueResult(), E); 10532 return ExprEvaluatorBaseTy::VisitConstantExpr(E); 10533 } 10534 10535 bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) { 10536 if (unsigned BuiltinOp = E->getBuiltinCallee()) 10537 return VisitBuiltinCallExpr(E, BuiltinOp); 10538 10539 return ExprEvaluatorBaseTy::VisitCallExpr(E); 10540 } 10541 10542 bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, 10543 unsigned BuiltinOp) { 10544 switch (unsigned BuiltinOp = E->getBuiltinCallee()) { 10545 default: 10546 return ExprEvaluatorBaseTy::VisitCallExpr(E); 10547 10548 case Builtin::BI__builtin_dynamic_object_size: 10549 case Builtin::BI__builtin_object_size: { 10550 // The type was checked when we built the expression. 10551 unsigned Type = 10552 E->getArg(1)->EvaluateKnownConstInt(Info.Ctx).getZExtValue(); 10553 assert(Type <= 3 && "unexpected type"); 10554 10555 uint64_t Size; 10556 if (tryEvaluateBuiltinObjectSize(E->getArg(0), Type, Info, Size)) 10557 return Success(Size, E); 10558 10559 if (E->getArg(0)->HasSideEffects(Info.Ctx)) 10560 return Success((Type & 2) ? 0 : -1, E); 10561 10562 // Expression had no side effects, but we couldn't statically determine the 10563 // size of the referenced object. 10564 switch (Info.EvalMode) { 10565 case EvalInfo::EM_ConstantExpression: 10566 case EvalInfo::EM_ConstantFold: 10567 case EvalInfo::EM_IgnoreSideEffects: 10568 // Leave it to IR generation. 10569 return Error(E); 10570 case EvalInfo::EM_ConstantExpressionUnevaluated: 10571 // Reduce it to a constant now. 10572 return Success((Type & 2) ? 0 : -1, E); 10573 } 10574 10575 llvm_unreachable("unexpected EvalMode"); 10576 } 10577 10578 case Builtin::BI__builtin_os_log_format_buffer_size: { 10579 analyze_os_log::OSLogBufferLayout Layout; 10580 analyze_os_log::computeOSLogBufferLayout(Info.Ctx, E, Layout); 10581 return Success(Layout.size().getQuantity(), E); 10582 } 10583 10584 case Builtin::BI__builtin_bswap16: 10585 case Builtin::BI__builtin_bswap32: 10586 case Builtin::BI__builtin_bswap64: { 10587 APSInt Val; 10588 if (!EvaluateInteger(E->getArg(0), Val, Info)) 10589 return false; 10590 10591 return Success(Val.byteSwap(), E); 10592 } 10593 10594 case Builtin::BI__builtin_classify_type: 10595 return Success((int)EvaluateBuiltinClassifyType(E, Info.getLangOpts()), E); 10596 10597 case Builtin::BI__builtin_clrsb: 10598 case Builtin::BI__builtin_clrsbl: 10599 case Builtin::BI__builtin_clrsbll: { 10600 APSInt Val; 10601 if (!EvaluateInteger(E->getArg(0), Val, Info)) 10602 return false; 10603 10604 return Success(Val.getBitWidth() - Val.getMinSignedBits(), E); 10605 } 10606 10607 case Builtin::BI__builtin_clz: 10608 case Builtin::BI__builtin_clzl: 10609 case Builtin::BI__builtin_clzll: 10610 case Builtin::BI__builtin_clzs: { 10611 APSInt Val; 10612 if (!EvaluateInteger(E->getArg(0), Val, Info)) 10613 return false; 10614 if (!Val) 10615 return Error(E); 10616 10617 return Success(Val.countLeadingZeros(), E); 10618 } 10619 10620 case Builtin::BI__builtin_constant_p: { 10621 const Expr *Arg = E->getArg(0); 10622 if (EvaluateBuiltinConstantP(Info, Arg)) 10623 return Success(true, E); 10624 if (Info.InConstantContext || Arg->HasSideEffects(Info.Ctx)) { 10625 // Outside a constant context, eagerly evaluate to false in the presence 10626 // of side-effects in order to avoid -Wunsequenced false-positives in 10627 // a branch on __builtin_constant_p(expr). 10628 return Success(false, E); 10629 } 10630 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 10631 return false; 10632 } 10633 10634 case Builtin::BI__builtin_is_constant_evaluated: { 10635 const auto *Callee = Info.CurrentCall->getCallee(); 10636 if (Info.InConstantContext && !Info.CheckingPotentialConstantExpression && 10637 (Info.CallStackDepth == 1 || 10638 (Info.CallStackDepth == 2 && Callee->isInStdNamespace() && 10639 Callee->getIdentifier() && 10640 Callee->getIdentifier()->isStr("is_constant_evaluated")))) { 10641 // FIXME: Find a better way to avoid duplicated diagnostics. 10642 if (Info.EvalStatus.Diag) 10643 Info.report((Info.CallStackDepth == 1) ? E->getExprLoc() 10644 : Info.CurrentCall->CallLoc, 10645 diag::warn_is_constant_evaluated_always_true_constexpr) 10646 << (Info.CallStackDepth == 1 ? "__builtin_is_constant_evaluated" 10647 : "std::is_constant_evaluated"); 10648 } 10649 10650 return Success(Info.InConstantContext, E); 10651 } 10652 10653 case Builtin::BI__builtin_ctz: 10654 case Builtin::BI__builtin_ctzl: 10655 case Builtin::BI__builtin_ctzll: 10656 case Builtin::BI__builtin_ctzs: { 10657 APSInt Val; 10658 if (!EvaluateInteger(E->getArg(0), Val, Info)) 10659 return false; 10660 if (!Val) 10661 return Error(E); 10662 10663 return Success(Val.countTrailingZeros(), E); 10664 } 10665 10666 case Builtin::BI__builtin_eh_return_data_regno: { 10667 int Operand = E->getArg(0)->EvaluateKnownConstInt(Info.Ctx).getZExtValue(); 10668 Operand = Info.Ctx.getTargetInfo().getEHDataRegisterNumber(Operand); 10669 return Success(Operand, E); 10670 } 10671 10672 case Builtin::BI__builtin_expect: 10673 return Visit(E->getArg(0)); 10674 10675 case Builtin::BI__builtin_ffs: 10676 case Builtin::BI__builtin_ffsl: 10677 case Builtin::BI__builtin_ffsll: { 10678 APSInt Val; 10679 if (!EvaluateInteger(E->getArg(0), Val, Info)) 10680 return false; 10681 10682 unsigned N = Val.countTrailingZeros(); 10683 return Success(N == Val.getBitWidth() ? 0 : N + 1, E); 10684 } 10685 10686 case Builtin::BI__builtin_fpclassify: { 10687 APFloat Val(0.0); 10688 if (!EvaluateFloat(E->getArg(5), Val, Info)) 10689 return false; 10690 unsigned Arg; 10691 switch (Val.getCategory()) { 10692 case APFloat::fcNaN: Arg = 0; break; 10693 case APFloat::fcInfinity: Arg = 1; break; 10694 case APFloat::fcNormal: Arg = Val.isDenormal() ? 3 : 2; break; 10695 case APFloat::fcZero: Arg = 4; break; 10696 } 10697 return Visit(E->getArg(Arg)); 10698 } 10699 10700 case Builtin::BI__builtin_isinf_sign: { 10701 APFloat Val(0.0); 10702 return EvaluateFloat(E->getArg(0), Val, Info) && 10703 Success(Val.isInfinity() ? (Val.isNegative() ? -1 : 1) : 0, E); 10704 } 10705 10706 case Builtin::BI__builtin_isinf: { 10707 APFloat Val(0.0); 10708 return EvaluateFloat(E->getArg(0), Val, Info) && 10709 Success(Val.isInfinity() ? 1 : 0, E); 10710 } 10711 10712 case Builtin::BI__builtin_isfinite: { 10713 APFloat Val(0.0); 10714 return EvaluateFloat(E->getArg(0), Val, Info) && 10715 Success(Val.isFinite() ? 1 : 0, E); 10716 } 10717 10718 case Builtin::BI__builtin_isnan: { 10719 APFloat Val(0.0); 10720 return EvaluateFloat(E->getArg(0), Val, Info) && 10721 Success(Val.isNaN() ? 1 : 0, E); 10722 } 10723 10724 case Builtin::BI__builtin_isnormal: { 10725 APFloat Val(0.0); 10726 return EvaluateFloat(E->getArg(0), Val, Info) && 10727 Success(Val.isNormal() ? 1 : 0, E); 10728 } 10729 10730 case Builtin::BI__builtin_parity: 10731 case Builtin::BI__builtin_parityl: 10732 case Builtin::BI__builtin_parityll: { 10733 APSInt Val; 10734 if (!EvaluateInteger(E->getArg(0), Val, Info)) 10735 return false; 10736 10737 return Success(Val.countPopulation() % 2, E); 10738 } 10739 10740 case Builtin::BI__builtin_popcount: 10741 case Builtin::BI__builtin_popcountl: 10742 case Builtin::BI__builtin_popcountll: { 10743 APSInt Val; 10744 if (!EvaluateInteger(E->getArg(0), Val, Info)) 10745 return false; 10746 10747 return Success(Val.countPopulation(), E); 10748 } 10749 10750 case Builtin::BIstrlen: 10751 case Builtin::BIwcslen: 10752 // A call to strlen is not a constant expression. 10753 if (Info.getLangOpts().CPlusPlus11) 10754 Info.CCEDiag(E, diag::note_constexpr_invalid_function) 10755 << /*isConstexpr*/0 << /*isConstructor*/0 10756 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'"); 10757 else 10758 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr); 10759 LLVM_FALLTHROUGH; 10760 case Builtin::BI__builtin_strlen: 10761 case Builtin::BI__builtin_wcslen: { 10762 // As an extension, we support __builtin_strlen() as a constant expression, 10763 // and support folding strlen() to a constant. 10764 LValue String; 10765 if (!EvaluatePointer(E->getArg(0), String, Info)) 10766 return false; 10767 10768 QualType CharTy = E->getArg(0)->getType()->getPointeeType(); 10769 10770 // Fast path: if it's a string literal, search the string value. 10771 if (const StringLiteral *S = dyn_cast_or_null<StringLiteral>( 10772 String.getLValueBase().dyn_cast<const Expr *>())) { 10773 // The string literal may have embedded null characters. Find the first 10774 // one and truncate there. 10775 StringRef Str = S->getBytes(); 10776 int64_t Off = String.Offset.getQuantity(); 10777 if (Off >= 0 && (uint64_t)Off <= (uint64_t)Str.size() && 10778 S->getCharByteWidth() == 1 && 10779 // FIXME: Add fast-path for wchar_t too. 10780 Info.Ctx.hasSameUnqualifiedType(CharTy, Info.Ctx.CharTy)) { 10781 Str = Str.substr(Off); 10782 10783 StringRef::size_type Pos = Str.find(0); 10784 if (Pos != StringRef::npos) 10785 Str = Str.substr(0, Pos); 10786 10787 return Success(Str.size(), E); 10788 } 10789 10790 // Fall through to slow path to issue appropriate diagnostic. 10791 } 10792 10793 // Slow path: scan the bytes of the string looking for the terminating 0. 10794 for (uint64_t Strlen = 0; /**/; ++Strlen) { 10795 APValue Char; 10796 if (!handleLValueToRValueConversion(Info, E, CharTy, String, Char) || 10797 !Char.isInt()) 10798 return false; 10799 if (!Char.getInt()) 10800 return Success(Strlen, E); 10801 if (!HandleLValueArrayAdjustment(Info, E, String, CharTy, 1)) 10802 return false; 10803 } 10804 } 10805 10806 case Builtin::BIstrcmp: 10807 case Builtin::BIwcscmp: 10808 case Builtin::BIstrncmp: 10809 case Builtin::BIwcsncmp: 10810 case Builtin::BImemcmp: 10811 case Builtin::BIbcmp: 10812 case Builtin::BIwmemcmp: 10813 // A call to strlen is not a constant expression. 10814 if (Info.getLangOpts().CPlusPlus11) 10815 Info.CCEDiag(E, diag::note_constexpr_invalid_function) 10816 << /*isConstexpr*/0 << /*isConstructor*/0 10817 << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'"); 10818 else 10819 Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr); 10820 LLVM_FALLTHROUGH; 10821 case Builtin::BI__builtin_strcmp: 10822 case Builtin::BI__builtin_wcscmp: 10823 case Builtin::BI__builtin_strncmp: 10824 case Builtin::BI__builtin_wcsncmp: 10825 case Builtin::BI__builtin_memcmp: 10826 case Builtin::BI__builtin_bcmp: 10827 case Builtin::BI__builtin_wmemcmp: { 10828 LValue String1, String2; 10829 if (!EvaluatePointer(E->getArg(0), String1, Info) || 10830 !EvaluatePointer(E->getArg(1), String2, Info)) 10831 return false; 10832 10833 uint64_t MaxLength = uint64_t(-1); 10834 if (BuiltinOp != Builtin::BIstrcmp && 10835 BuiltinOp != Builtin::BIwcscmp && 10836 BuiltinOp != Builtin::BI__builtin_strcmp && 10837 BuiltinOp != Builtin::BI__builtin_wcscmp) { 10838 APSInt N; 10839 if (!EvaluateInteger(E->getArg(2), N, Info)) 10840 return false; 10841 MaxLength = N.getExtValue(); 10842 } 10843 10844 // Empty substrings compare equal by definition. 10845 if (MaxLength == 0u) 10846 return Success(0, E); 10847 10848 if (!String1.checkNullPointerForFoldAccess(Info, E, AK_Read) || 10849 !String2.checkNullPointerForFoldAccess(Info, E, AK_Read) || 10850 String1.Designator.Invalid || String2.Designator.Invalid) 10851 return false; 10852 10853 QualType CharTy1 = String1.Designator.getType(Info.Ctx); 10854 QualType CharTy2 = String2.Designator.getType(Info.Ctx); 10855 10856 bool IsRawByte = BuiltinOp == Builtin::BImemcmp || 10857 BuiltinOp == Builtin::BIbcmp || 10858 BuiltinOp == Builtin::BI__builtin_memcmp || 10859 BuiltinOp == Builtin::BI__builtin_bcmp; 10860 10861 assert(IsRawByte || 10862 (Info.Ctx.hasSameUnqualifiedType( 10863 CharTy1, E->getArg(0)->getType()->getPointeeType()) && 10864 Info.Ctx.hasSameUnqualifiedType(CharTy1, CharTy2))); 10865 10866 const auto &ReadCurElems = [&](APValue &Char1, APValue &Char2) { 10867 return handleLValueToRValueConversion(Info, E, CharTy1, String1, Char1) && 10868 handleLValueToRValueConversion(Info, E, CharTy2, String2, Char2) && 10869 Char1.isInt() && Char2.isInt(); 10870 }; 10871 const auto &AdvanceElems = [&] { 10872 return HandleLValueArrayAdjustment(Info, E, String1, CharTy1, 1) && 10873 HandleLValueArrayAdjustment(Info, E, String2, CharTy2, 1); 10874 }; 10875 10876 if (IsRawByte) { 10877 uint64_t BytesRemaining = MaxLength; 10878 // Pointers to const void may point to objects of incomplete type. 10879 if (CharTy1->isIncompleteType()) { 10880 Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy1; 10881 return false; 10882 } 10883 if (CharTy2->isIncompleteType()) { 10884 Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy2; 10885 return false; 10886 } 10887 uint64_t CharTy1Width{Info.Ctx.getTypeSize(CharTy1)}; 10888 CharUnits CharTy1Size = Info.Ctx.toCharUnitsFromBits(CharTy1Width); 10889 // Give up on comparing between elements with disparate widths. 10890 if (CharTy1Size != Info.Ctx.getTypeSizeInChars(CharTy2)) 10891 return false; 10892 uint64_t BytesPerElement = CharTy1Size.getQuantity(); 10893 assert(BytesRemaining && "BytesRemaining should not be zero: the " 10894 "following loop considers at least one element"); 10895 while (true) { 10896 APValue Char1, Char2; 10897 if (!ReadCurElems(Char1, Char2)) 10898 return false; 10899 // We have compatible in-memory widths, but a possible type and 10900 // (for `bool`) internal representation mismatch. 10901 // Assuming two's complement representation, including 0 for `false` and 10902 // 1 for `true`, we can check an appropriate number of elements for 10903 // equality even if they are not byte-sized. 10904 APSInt Char1InMem = Char1.getInt().extOrTrunc(CharTy1Width); 10905 APSInt Char2InMem = Char2.getInt().extOrTrunc(CharTy1Width); 10906 if (Char1InMem.ne(Char2InMem)) { 10907 // If the elements are byte-sized, then we can produce a three-way 10908 // comparison result in a straightforward manner. 10909 if (BytesPerElement == 1u) { 10910 // memcmp always compares unsigned chars. 10911 return Success(Char1InMem.ult(Char2InMem) ? -1 : 1, E); 10912 } 10913 // The result is byte-order sensitive, and we have multibyte elements. 10914 // FIXME: We can compare the remaining bytes in the correct order. 10915 return false; 10916 } 10917 if (!AdvanceElems()) 10918 return false; 10919 if (BytesRemaining <= BytesPerElement) 10920 break; 10921 BytesRemaining -= BytesPerElement; 10922 } 10923 // Enough elements are equal to account for the memcmp limit. 10924 return Success(0, E); 10925 } 10926 10927 bool StopAtNull = 10928 (BuiltinOp != Builtin::BImemcmp && BuiltinOp != Builtin::BIbcmp && 10929 BuiltinOp != Builtin::BIwmemcmp && 10930 BuiltinOp != Builtin::BI__builtin_memcmp && 10931 BuiltinOp != Builtin::BI__builtin_bcmp && 10932 BuiltinOp != Builtin::BI__builtin_wmemcmp); 10933 bool IsWide = BuiltinOp == Builtin::BIwcscmp || 10934 BuiltinOp == Builtin::BIwcsncmp || 10935 BuiltinOp == Builtin::BIwmemcmp || 10936 BuiltinOp == Builtin::BI__builtin_wcscmp || 10937 BuiltinOp == Builtin::BI__builtin_wcsncmp || 10938 BuiltinOp == Builtin::BI__builtin_wmemcmp; 10939 10940 for (; MaxLength; --MaxLength) { 10941 APValue Char1, Char2; 10942 if (!ReadCurElems(Char1, Char2)) 10943 return false; 10944 if (Char1.getInt() != Char2.getInt()) { 10945 if (IsWide) // wmemcmp compares with wchar_t signedness. 10946 return Success(Char1.getInt() < Char2.getInt() ? -1 : 1, E); 10947 // memcmp always compares unsigned chars. 10948 return Success(Char1.getInt().ult(Char2.getInt()) ? -1 : 1, E); 10949 } 10950 if (StopAtNull && !Char1.getInt()) 10951 return Success(0, E); 10952 assert(!(StopAtNull && !Char2.getInt())); 10953 if (!AdvanceElems()) 10954 return false; 10955 } 10956 // We hit the strncmp / memcmp limit. 10957 return Success(0, E); 10958 } 10959 10960 case Builtin::BI__atomic_always_lock_free: 10961 case Builtin::BI__atomic_is_lock_free: 10962 case Builtin::BI__c11_atomic_is_lock_free: { 10963 APSInt SizeVal; 10964 if (!EvaluateInteger(E->getArg(0), SizeVal, Info)) 10965 return false; 10966 10967 // For __atomic_is_lock_free(sizeof(_Atomic(T))), if the size is a power 10968 // of two less than the maximum inline atomic width, we know it is 10969 // lock-free. If the size isn't a power of two, or greater than the 10970 // maximum alignment where we promote atomics, we know it is not lock-free 10971 // (at least not in the sense of atomic_is_lock_free). Otherwise, 10972 // the answer can only be determined at runtime; for example, 16-byte 10973 // atomics have lock-free implementations on some, but not all, 10974 // x86-64 processors. 10975 10976 // Check power-of-two. 10977 CharUnits Size = CharUnits::fromQuantity(SizeVal.getZExtValue()); 10978 if (Size.isPowerOfTwo()) { 10979 // Check against inlining width. 10980 unsigned InlineWidthBits = 10981 Info.Ctx.getTargetInfo().getMaxAtomicInlineWidth(); 10982 if (Size <= Info.Ctx.toCharUnitsFromBits(InlineWidthBits)) { 10983 if (BuiltinOp == Builtin::BI__c11_atomic_is_lock_free || 10984 Size == CharUnits::One() || 10985 E->getArg(1)->isNullPointerConstant(Info.Ctx, 10986 Expr::NPC_NeverValueDependent)) 10987 // OK, we will inline appropriately-aligned operations of this size, 10988 // and _Atomic(T) is appropriately-aligned. 10989 return Success(1, E); 10990 10991 QualType PointeeType = E->getArg(1)->IgnoreImpCasts()->getType()-> 10992 castAs<PointerType>()->getPointeeType(); 10993 if (!PointeeType->isIncompleteType() && 10994 Info.Ctx.getTypeAlignInChars(PointeeType) >= Size) { 10995 // OK, we will inline operations on this object. 10996 return Success(1, E); 10997 } 10998 } 10999 } 11000 11001 return BuiltinOp == Builtin::BI__atomic_always_lock_free ? 11002 Success(0, E) : Error(E); 11003 } 11004 case Builtin::BIomp_is_initial_device: 11005 // We can decide statically which value the runtime would return if called. 11006 return Success(Info.getLangOpts().OpenMPIsDevice ? 0 : 1, E); 11007 case Builtin::BI__builtin_add_overflow: 11008 case Builtin::BI__builtin_sub_overflow: 11009 case Builtin::BI__builtin_mul_overflow: 11010 case Builtin::BI__builtin_sadd_overflow: 11011 case Builtin::BI__builtin_uadd_overflow: 11012 case Builtin::BI__builtin_uaddl_overflow: 11013 case Builtin::BI__builtin_uaddll_overflow: 11014 case Builtin::BI__builtin_usub_overflow: 11015 case Builtin::BI__builtin_usubl_overflow: 11016 case Builtin::BI__builtin_usubll_overflow: 11017 case Builtin::BI__builtin_umul_overflow: 11018 case Builtin::BI__builtin_umull_overflow: 11019 case Builtin::BI__builtin_umulll_overflow: 11020 case Builtin::BI__builtin_saddl_overflow: 11021 case Builtin::BI__builtin_saddll_overflow: 11022 case Builtin::BI__builtin_ssub_overflow: 11023 case Builtin::BI__builtin_ssubl_overflow: 11024 case Builtin::BI__builtin_ssubll_overflow: 11025 case Builtin::BI__builtin_smul_overflow: 11026 case Builtin::BI__builtin_smull_overflow: 11027 case Builtin::BI__builtin_smulll_overflow: { 11028 LValue ResultLValue; 11029 APSInt LHS, RHS; 11030 11031 QualType ResultType = E->getArg(2)->getType()->getPointeeType(); 11032 if (!EvaluateInteger(E->getArg(0), LHS, Info) || 11033 !EvaluateInteger(E->getArg(1), RHS, Info) || 11034 !EvaluatePointer(E->getArg(2), ResultLValue, Info)) 11035 return false; 11036 11037 APSInt Result; 11038 bool DidOverflow = false; 11039 11040 // If the types don't have to match, enlarge all 3 to the largest of them. 11041 if (BuiltinOp == Builtin::BI__builtin_add_overflow || 11042 BuiltinOp == Builtin::BI__builtin_sub_overflow || 11043 BuiltinOp == Builtin::BI__builtin_mul_overflow) { 11044 bool IsSigned = LHS.isSigned() || RHS.isSigned() || 11045 ResultType->isSignedIntegerOrEnumerationType(); 11046 bool AllSigned = LHS.isSigned() && RHS.isSigned() && 11047 ResultType->isSignedIntegerOrEnumerationType(); 11048 uint64_t LHSSize = LHS.getBitWidth(); 11049 uint64_t RHSSize = RHS.getBitWidth(); 11050 uint64_t ResultSize = Info.Ctx.getTypeSize(ResultType); 11051 uint64_t MaxBits = std::max(std::max(LHSSize, RHSSize), ResultSize); 11052 11053 // Add an additional bit if the signedness isn't uniformly agreed to. We 11054 // could do this ONLY if there is a signed and an unsigned that both have 11055 // MaxBits, but the code to check that is pretty nasty. The issue will be 11056 // caught in the shrink-to-result later anyway. 11057 if (IsSigned && !AllSigned) 11058 ++MaxBits; 11059 11060 LHS = APSInt(LHS.extOrTrunc(MaxBits), !IsSigned); 11061 RHS = APSInt(RHS.extOrTrunc(MaxBits), !IsSigned); 11062 Result = APSInt(MaxBits, !IsSigned); 11063 } 11064 11065 // Find largest int. 11066 switch (BuiltinOp) { 11067 default: 11068 llvm_unreachable("Invalid value for BuiltinOp"); 11069 case Builtin::BI__builtin_add_overflow: 11070 case Builtin::BI__builtin_sadd_overflow: 11071 case Builtin::BI__builtin_saddl_overflow: 11072 case Builtin::BI__builtin_saddll_overflow: 11073 case Builtin::BI__builtin_uadd_overflow: 11074 case Builtin::BI__builtin_uaddl_overflow: 11075 case Builtin::BI__builtin_uaddll_overflow: 11076 Result = LHS.isSigned() ? LHS.sadd_ov(RHS, DidOverflow) 11077 : LHS.uadd_ov(RHS, DidOverflow); 11078 break; 11079 case Builtin::BI__builtin_sub_overflow: 11080 case Builtin::BI__builtin_ssub_overflow: 11081 case Builtin::BI__builtin_ssubl_overflow: 11082 case Builtin::BI__builtin_ssubll_overflow: 11083 case Builtin::BI__builtin_usub_overflow: 11084 case Builtin::BI__builtin_usubl_overflow: 11085 case Builtin::BI__builtin_usubll_overflow: 11086 Result = LHS.isSigned() ? LHS.ssub_ov(RHS, DidOverflow) 11087 : LHS.usub_ov(RHS, DidOverflow); 11088 break; 11089 case Builtin::BI__builtin_mul_overflow: 11090 case Builtin::BI__builtin_smul_overflow: 11091 case Builtin::BI__builtin_smull_overflow: 11092 case Builtin::BI__builtin_smulll_overflow: 11093 case Builtin::BI__builtin_umul_overflow: 11094 case Builtin::BI__builtin_umull_overflow: 11095 case Builtin::BI__builtin_umulll_overflow: 11096 Result = LHS.isSigned() ? LHS.smul_ov(RHS, DidOverflow) 11097 : LHS.umul_ov(RHS, DidOverflow); 11098 break; 11099 } 11100 11101 // In the case where multiple sizes are allowed, truncate and see if 11102 // the values are the same. 11103 if (BuiltinOp == Builtin::BI__builtin_add_overflow || 11104 BuiltinOp == Builtin::BI__builtin_sub_overflow || 11105 BuiltinOp == Builtin::BI__builtin_mul_overflow) { 11106 // APSInt doesn't have a TruncOrSelf, so we use extOrTrunc instead, 11107 // since it will give us the behavior of a TruncOrSelf in the case where 11108 // its parameter <= its size. We previously set Result to be at least the 11109 // type-size of the result, so getTypeSize(ResultType) <= Result.BitWidth 11110 // will work exactly like TruncOrSelf. 11111 APSInt Temp = Result.extOrTrunc(Info.Ctx.getTypeSize(ResultType)); 11112 Temp.setIsSigned(ResultType->isSignedIntegerOrEnumerationType()); 11113 11114 if (!APSInt::isSameValue(Temp, Result)) 11115 DidOverflow = true; 11116 Result = Temp; 11117 } 11118 11119 APValue APV{Result}; 11120 if (!handleAssignment(Info, E, ResultLValue, ResultType, APV)) 11121 return false; 11122 return Success(DidOverflow, E); 11123 } 11124 } 11125 } 11126 11127 /// Determine whether this is a pointer past the end of the complete 11128 /// object referred to by the lvalue. 11129 static bool isOnePastTheEndOfCompleteObject(const ASTContext &Ctx, 11130 const LValue &LV) { 11131 // A null pointer can be viewed as being "past the end" but we don't 11132 // choose to look at it that way here. 11133 if (!LV.getLValueBase()) 11134 return false; 11135 11136 // If the designator is valid and refers to a subobject, we're not pointing 11137 // past the end. 11138 if (!LV.getLValueDesignator().Invalid && 11139 !LV.getLValueDesignator().isOnePastTheEnd()) 11140 return false; 11141 11142 // A pointer to an incomplete type might be past-the-end if the type's size is 11143 // zero. We cannot tell because the type is incomplete. 11144 QualType Ty = getType(LV.getLValueBase()); 11145 if (Ty->isIncompleteType()) 11146 return true; 11147 11148 // We're a past-the-end pointer if we point to the byte after the object, 11149 // no matter what our type or path is. 11150 auto Size = Ctx.getTypeSizeInChars(Ty); 11151 return LV.getLValueOffset() == Size; 11152 } 11153 11154 namespace { 11155 11156 /// Data recursive integer evaluator of certain binary operators. 11157 /// 11158 /// We use a data recursive algorithm for binary operators so that we are able 11159 /// to handle extreme cases of chained binary operators without causing stack 11160 /// overflow. 11161 class DataRecursiveIntBinOpEvaluator { 11162 struct EvalResult { 11163 APValue Val; 11164 bool Failed; 11165 11166 EvalResult() : Failed(false) { } 11167 11168 void swap(EvalResult &RHS) { 11169 Val.swap(RHS.Val); 11170 Failed = RHS.Failed; 11171 RHS.Failed = false; 11172 } 11173 }; 11174 11175 struct Job { 11176 const Expr *E; 11177 EvalResult LHSResult; // meaningful only for binary operator expression. 11178 enum { AnyExprKind, BinOpKind, BinOpVisitedLHSKind } Kind; 11179 11180 Job() = default; 11181 Job(Job &&) = default; 11182 11183 void startSpeculativeEval(EvalInfo &Info) { 11184 SpecEvalRAII = SpeculativeEvaluationRAII(Info); 11185 } 11186 11187 private: 11188 SpeculativeEvaluationRAII SpecEvalRAII; 11189 }; 11190 11191 SmallVector<Job, 16> Queue; 11192 11193 IntExprEvaluator &IntEval; 11194 EvalInfo &Info; 11195 APValue &FinalResult; 11196 11197 public: 11198 DataRecursiveIntBinOpEvaluator(IntExprEvaluator &IntEval, APValue &Result) 11199 : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) { } 11200 11201 /// True if \param E is a binary operator that we are going to handle 11202 /// data recursively. 11203 /// We handle binary operators that are comma, logical, or that have operands 11204 /// with integral or enumeration type. 11205 static bool shouldEnqueue(const BinaryOperator *E) { 11206 return E->getOpcode() == BO_Comma || E->isLogicalOp() || 11207 (E->isRValue() && E->getType()->isIntegralOrEnumerationType() && 11208 E->getLHS()->getType()->isIntegralOrEnumerationType() && 11209 E->getRHS()->getType()->isIntegralOrEnumerationType()); 11210 } 11211 11212 bool Traverse(const BinaryOperator *E) { 11213 enqueue(E); 11214 EvalResult PrevResult; 11215 while (!Queue.empty()) 11216 process(PrevResult); 11217 11218 if (PrevResult.Failed) return false; 11219 11220 FinalResult.swap(PrevResult.Val); 11221 return true; 11222 } 11223 11224 private: 11225 bool Success(uint64_t Value, const Expr *E, APValue &Result) { 11226 return IntEval.Success(Value, E, Result); 11227 } 11228 bool Success(const APSInt &Value, const Expr *E, APValue &Result) { 11229 return IntEval.Success(Value, E, Result); 11230 } 11231 bool Error(const Expr *E) { 11232 return IntEval.Error(E); 11233 } 11234 bool Error(const Expr *E, diag::kind D) { 11235 return IntEval.Error(E, D); 11236 } 11237 11238 OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) { 11239 return Info.CCEDiag(E, D); 11240 } 11241 11242 // Returns true if visiting the RHS is necessary, false otherwise. 11243 bool VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E, 11244 bool &SuppressRHSDiags); 11245 11246 bool VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult, 11247 const BinaryOperator *E, APValue &Result); 11248 11249 void EvaluateExpr(const Expr *E, EvalResult &Result) { 11250 Result.Failed = !Evaluate(Result.Val, Info, E); 11251 if (Result.Failed) 11252 Result.Val = APValue(); 11253 } 11254 11255 void process(EvalResult &Result); 11256 11257 void enqueue(const Expr *E) { 11258 E = E->IgnoreParens(); 11259 Queue.resize(Queue.size()+1); 11260 Queue.back().E = E; 11261 Queue.back().Kind = Job::AnyExprKind; 11262 } 11263 }; 11264 11265 } 11266 11267 bool DataRecursiveIntBinOpEvaluator:: 11268 VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E, 11269 bool &SuppressRHSDiags) { 11270 if (E->getOpcode() == BO_Comma) { 11271 // Ignore LHS but note if we could not evaluate it. 11272 if (LHSResult.Failed) 11273 return Info.noteSideEffect(); 11274 return true; 11275 } 11276 11277 if (E->isLogicalOp()) { 11278 bool LHSAsBool; 11279 if (!LHSResult.Failed && HandleConversionToBool(LHSResult.Val, LHSAsBool)) { 11280 // We were able to evaluate the LHS, see if we can get away with not 11281 // evaluating the RHS: 0 && X -> 0, 1 || X -> 1 11282 if (LHSAsBool == (E->getOpcode() == BO_LOr)) { 11283 Success(LHSAsBool, E, LHSResult.Val); 11284 return false; // Ignore RHS 11285 } 11286 } else { 11287 LHSResult.Failed = true; 11288 11289 // Since we weren't able to evaluate the left hand side, it 11290 // might have had side effects. 11291 if (!Info.noteSideEffect()) 11292 return false; 11293 11294 // We can't evaluate the LHS; however, sometimes the result 11295 // is determined by the RHS: X && 0 -> 0, X || 1 -> 1. 11296 // Don't ignore RHS and suppress diagnostics from this arm. 11297 SuppressRHSDiags = true; 11298 } 11299 11300 return true; 11301 } 11302 11303 assert(E->getLHS()->getType()->isIntegralOrEnumerationType() && 11304 E->getRHS()->getType()->isIntegralOrEnumerationType()); 11305 11306 if (LHSResult.Failed && !Info.noteFailure()) 11307 return false; // Ignore RHS; 11308 11309 return true; 11310 } 11311 11312 static void addOrSubLValueAsInteger(APValue &LVal, const APSInt &Index, 11313 bool IsSub) { 11314 // Compute the new offset in the appropriate width, wrapping at 64 bits. 11315 // FIXME: When compiling for a 32-bit target, we should use 32-bit 11316 // offsets. 11317 assert(!LVal.hasLValuePath() && "have designator for integer lvalue"); 11318 CharUnits &Offset = LVal.getLValueOffset(); 11319 uint64_t Offset64 = Offset.getQuantity(); 11320 uint64_t Index64 = Index.extOrTrunc(64).getZExtValue(); 11321 Offset = CharUnits::fromQuantity(IsSub ? Offset64 - Index64 11322 : Offset64 + Index64); 11323 } 11324 11325 bool DataRecursiveIntBinOpEvaluator:: 11326 VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult, 11327 const BinaryOperator *E, APValue &Result) { 11328 if (E->getOpcode() == BO_Comma) { 11329 if (RHSResult.Failed) 11330 return false; 11331 Result = RHSResult.Val; 11332 return true; 11333 } 11334 11335 if (E->isLogicalOp()) { 11336 bool lhsResult, rhsResult; 11337 bool LHSIsOK = HandleConversionToBool(LHSResult.Val, lhsResult); 11338 bool RHSIsOK = HandleConversionToBool(RHSResult.Val, rhsResult); 11339 11340 if (LHSIsOK) { 11341 if (RHSIsOK) { 11342 if (E->getOpcode() == BO_LOr) 11343 return Success(lhsResult || rhsResult, E, Result); 11344 else 11345 return Success(lhsResult && rhsResult, E, Result); 11346 } 11347 } else { 11348 if (RHSIsOK) { 11349 // We can't evaluate the LHS; however, sometimes the result 11350 // is determined by the RHS: X && 0 -> 0, X || 1 -> 1. 11351 if (rhsResult == (E->getOpcode() == BO_LOr)) 11352 return Success(rhsResult, E, Result); 11353 } 11354 } 11355 11356 return false; 11357 } 11358 11359 assert(E->getLHS()->getType()->isIntegralOrEnumerationType() && 11360 E->getRHS()->getType()->isIntegralOrEnumerationType()); 11361 11362 if (LHSResult.Failed || RHSResult.Failed) 11363 return false; 11364 11365 const APValue &LHSVal = LHSResult.Val; 11366 const APValue &RHSVal = RHSResult.Val; 11367 11368 // Handle cases like (unsigned long)&a + 4. 11369 if (E->isAdditiveOp() && LHSVal.isLValue() && RHSVal.isInt()) { 11370 Result = LHSVal; 11371 addOrSubLValueAsInteger(Result, RHSVal.getInt(), E->getOpcode() == BO_Sub); 11372 return true; 11373 } 11374 11375 // Handle cases like 4 + (unsigned long)&a 11376 if (E->getOpcode() == BO_Add && 11377 RHSVal.isLValue() && LHSVal.isInt()) { 11378 Result = RHSVal; 11379 addOrSubLValueAsInteger(Result, LHSVal.getInt(), /*IsSub*/false); 11380 return true; 11381 } 11382 11383 if (E->getOpcode() == BO_Sub && LHSVal.isLValue() && RHSVal.isLValue()) { 11384 // Handle (intptr_t)&&A - (intptr_t)&&B. 11385 if (!LHSVal.getLValueOffset().isZero() || 11386 !RHSVal.getLValueOffset().isZero()) 11387 return false; 11388 const Expr *LHSExpr = LHSVal.getLValueBase().dyn_cast<const Expr*>(); 11389 const Expr *RHSExpr = RHSVal.getLValueBase().dyn_cast<const Expr*>(); 11390 if (!LHSExpr || !RHSExpr) 11391 return false; 11392 const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr); 11393 const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr); 11394 if (!LHSAddrExpr || !RHSAddrExpr) 11395 return false; 11396 // Make sure both labels come from the same function. 11397 if (LHSAddrExpr->getLabel()->getDeclContext() != 11398 RHSAddrExpr->getLabel()->getDeclContext()) 11399 return false; 11400 Result = APValue(LHSAddrExpr, RHSAddrExpr); 11401 return true; 11402 } 11403 11404 // All the remaining cases expect both operands to be an integer 11405 if (!LHSVal.isInt() || !RHSVal.isInt()) 11406 return Error(E); 11407 11408 // Set up the width and signedness manually, in case it can't be deduced 11409 // from the operation we're performing. 11410 // FIXME: Don't do this in the cases where we can deduce it. 11411 APSInt Value(Info.Ctx.getIntWidth(E->getType()), 11412 E->getType()->isUnsignedIntegerOrEnumerationType()); 11413 if (!handleIntIntBinOp(Info, E, LHSVal.getInt(), E->getOpcode(), 11414 RHSVal.getInt(), Value)) 11415 return false; 11416 return Success(Value, E, Result); 11417 } 11418 11419 void DataRecursiveIntBinOpEvaluator::process(EvalResult &Result) { 11420 Job &job = Queue.back(); 11421 11422 switch (job.Kind) { 11423 case Job::AnyExprKind: { 11424 if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(job.E)) { 11425 if (shouldEnqueue(Bop)) { 11426 job.Kind = Job::BinOpKind; 11427 enqueue(Bop->getLHS()); 11428 return; 11429 } 11430 } 11431 11432 EvaluateExpr(job.E, Result); 11433 Queue.pop_back(); 11434 return; 11435 } 11436 11437 case Job::BinOpKind: { 11438 const BinaryOperator *Bop = cast<BinaryOperator>(job.E); 11439 bool SuppressRHSDiags = false; 11440 if (!VisitBinOpLHSOnly(Result, Bop, SuppressRHSDiags)) { 11441 Queue.pop_back(); 11442 return; 11443 } 11444 if (SuppressRHSDiags) 11445 job.startSpeculativeEval(Info); 11446 job.LHSResult.swap(Result); 11447 job.Kind = Job::BinOpVisitedLHSKind; 11448 enqueue(Bop->getRHS()); 11449 return; 11450 } 11451 11452 case Job::BinOpVisitedLHSKind: { 11453 const BinaryOperator *Bop = cast<BinaryOperator>(job.E); 11454 EvalResult RHS; 11455 RHS.swap(Result); 11456 Result.Failed = !VisitBinOp(job.LHSResult, RHS, Bop, Result.Val); 11457 Queue.pop_back(); 11458 return; 11459 } 11460 } 11461 11462 llvm_unreachable("Invalid Job::Kind!"); 11463 } 11464 11465 namespace { 11466 /// Used when we determine that we should fail, but can keep evaluating prior to 11467 /// noting that we had a failure. 11468 class DelayedNoteFailureRAII { 11469 EvalInfo &Info; 11470 bool NoteFailure; 11471 11472 public: 11473 DelayedNoteFailureRAII(EvalInfo &Info, bool NoteFailure = true) 11474 : Info(Info), NoteFailure(NoteFailure) {} 11475 ~DelayedNoteFailureRAII() { 11476 if (NoteFailure) { 11477 bool ContinueAfterFailure = Info.noteFailure(); 11478 (void)ContinueAfterFailure; 11479 assert(ContinueAfterFailure && 11480 "Shouldn't have kept evaluating on failure."); 11481 } 11482 } 11483 }; 11484 } 11485 11486 template <class SuccessCB, class AfterCB> 11487 static bool 11488 EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E, 11489 SuccessCB &&Success, AfterCB &&DoAfter) { 11490 assert(E->isComparisonOp() && "expected comparison operator"); 11491 assert((E->getOpcode() == BO_Cmp || 11492 E->getType()->isIntegralOrEnumerationType()) && 11493 "unsupported binary expression evaluation"); 11494 auto Error = [&](const Expr *E) { 11495 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 11496 return false; 11497 }; 11498 11499 using CCR = ComparisonCategoryResult; 11500 bool IsRelational = E->isRelationalOp(); 11501 bool IsEquality = E->isEqualityOp(); 11502 if (E->getOpcode() == BO_Cmp) { 11503 const ComparisonCategoryInfo &CmpInfo = 11504 Info.Ctx.CompCategories.getInfoForType(E->getType()); 11505 IsRelational = CmpInfo.isOrdered(); 11506 IsEquality = CmpInfo.isEquality(); 11507 } 11508 11509 QualType LHSTy = E->getLHS()->getType(); 11510 QualType RHSTy = E->getRHS()->getType(); 11511 11512 if (LHSTy->isIntegralOrEnumerationType() && 11513 RHSTy->isIntegralOrEnumerationType()) { 11514 APSInt LHS, RHS; 11515 bool LHSOK = EvaluateInteger(E->getLHS(), LHS, Info); 11516 if (!LHSOK && !Info.noteFailure()) 11517 return false; 11518 if (!EvaluateInteger(E->getRHS(), RHS, Info) || !LHSOK) 11519 return false; 11520 if (LHS < RHS) 11521 return Success(CCR::Less, E); 11522 if (LHS > RHS) 11523 return Success(CCR::Greater, E); 11524 return Success(CCR::Equal, E); 11525 } 11526 11527 if (LHSTy->isFixedPointType() || RHSTy->isFixedPointType()) { 11528 APFixedPoint LHSFX(Info.Ctx.getFixedPointSemantics(LHSTy)); 11529 APFixedPoint RHSFX(Info.Ctx.getFixedPointSemantics(RHSTy)); 11530 11531 bool LHSOK = EvaluateFixedPointOrInteger(E->getLHS(), LHSFX, Info); 11532 if (!LHSOK && !Info.noteFailure()) 11533 return false; 11534 if (!EvaluateFixedPointOrInteger(E->getRHS(), RHSFX, Info) || !LHSOK) 11535 return false; 11536 if (LHSFX < RHSFX) 11537 return Success(CCR::Less, E); 11538 if (LHSFX > RHSFX) 11539 return Success(CCR::Greater, E); 11540 return Success(CCR::Equal, E); 11541 } 11542 11543 if (LHSTy->isAnyComplexType() || RHSTy->isAnyComplexType()) { 11544 ComplexValue LHS, RHS; 11545 bool LHSOK; 11546 if (E->isAssignmentOp()) { 11547 LValue LV; 11548 EvaluateLValue(E->getLHS(), LV, Info); 11549 LHSOK = false; 11550 } else if (LHSTy->isRealFloatingType()) { 11551 LHSOK = EvaluateFloat(E->getLHS(), LHS.FloatReal, Info); 11552 if (LHSOK) { 11553 LHS.makeComplexFloat(); 11554 LHS.FloatImag = APFloat(LHS.FloatReal.getSemantics()); 11555 } 11556 } else { 11557 LHSOK = EvaluateComplex(E->getLHS(), LHS, Info); 11558 } 11559 if (!LHSOK && !Info.noteFailure()) 11560 return false; 11561 11562 if (E->getRHS()->getType()->isRealFloatingType()) { 11563 if (!EvaluateFloat(E->getRHS(), RHS.FloatReal, Info) || !LHSOK) 11564 return false; 11565 RHS.makeComplexFloat(); 11566 RHS.FloatImag = APFloat(RHS.FloatReal.getSemantics()); 11567 } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK) 11568 return false; 11569 11570 if (LHS.isComplexFloat()) { 11571 APFloat::cmpResult CR_r = 11572 LHS.getComplexFloatReal().compare(RHS.getComplexFloatReal()); 11573 APFloat::cmpResult CR_i = 11574 LHS.getComplexFloatImag().compare(RHS.getComplexFloatImag()); 11575 bool IsEqual = CR_r == APFloat::cmpEqual && CR_i == APFloat::cmpEqual; 11576 return Success(IsEqual ? CCR::Equal : CCR::Nonequal, E); 11577 } else { 11578 assert(IsEquality && "invalid complex comparison"); 11579 bool IsEqual = LHS.getComplexIntReal() == RHS.getComplexIntReal() && 11580 LHS.getComplexIntImag() == RHS.getComplexIntImag(); 11581 return Success(IsEqual ? CCR::Equal : CCR::Nonequal, E); 11582 } 11583 } 11584 11585 if (LHSTy->isRealFloatingType() && 11586 RHSTy->isRealFloatingType()) { 11587 APFloat RHS(0.0), LHS(0.0); 11588 11589 bool LHSOK = EvaluateFloat(E->getRHS(), RHS, Info); 11590 if (!LHSOK && !Info.noteFailure()) 11591 return false; 11592 11593 if (!EvaluateFloat(E->getLHS(), LHS, Info) || !LHSOK) 11594 return false; 11595 11596 assert(E->isComparisonOp() && "Invalid binary operator!"); 11597 auto GetCmpRes = [&]() { 11598 switch (LHS.compare(RHS)) { 11599 case APFloat::cmpEqual: 11600 return CCR::Equal; 11601 case APFloat::cmpLessThan: 11602 return CCR::Less; 11603 case APFloat::cmpGreaterThan: 11604 return CCR::Greater; 11605 case APFloat::cmpUnordered: 11606 return CCR::Unordered; 11607 } 11608 llvm_unreachable("Unrecognised APFloat::cmpResult enum"); 11609 }; 11610 return Success(GetCmpRes(), E); 11611 } 11612 11613 if (LHSTy->isPointerType() && RHSTy->isPointerType()) { 11614 LValue LHSValue, RHSValue; 11615 11616 bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info); 11617 if (!LHSOK && !Info.noteFailure()) 11618 return false; 11619 11620 if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK) 11621 return false; 11622 11623 // Reject differing bases from the normal codepath; we special-case 11624 // comparisons to null. 11625 if (!HasSameBase(LHSValue, RHSValue)) { 11626 // Inequalities and subtractions between unrelated pointers have 11627 // unspecified or undefined behavior. 11628 if (!IsEquality) 11629 return Error(E); 11630 // A constant address may compare equal to the address of a symbol. 11631 // The one exception is that address of an object cannot compare equal 11632 // to a null pointer constant. 11633 if ((!LHSValue.Base && !LHSValue.Offset.isZero()) || 11634 (!RHSValue.Base && !RHSValue.Offset.isZero())) 11635 return Error(E); 11636 // It's implementation-defined whether distinct literals will have 11637 // distinct addresses. In clang, the result of such a comparison is 11638 // unspecified, so it is not a constant expression. However, we do know 11639 // that the address of a literal will be non-null. 11640 if ((IsLiteralLValue(LHSValue) || IsLiteralLValue(RHSValue)) && 11641 LHSValue.Base && RHSValue.Base) 11642 return Error(E); 11643 // We can't tell whether weak symbols will end up pointing to the same 11644 // object. 11645 if (IsWeakLValue(LHSValue) || IsWeakLValue(RHSValue)) 11646 return Error(E); 11647 // We can't compare the address of the start of one object with the 11648 // past-the-end address of another object, per C++ DR1652. 11649 if ((LHSValue.Base && LHSValue.Offset.isZero() && 11650 isOnePastTheEndOfCompleteObject(Info.Ctx, RHSValue)) || 11651 (RHSValue.Base && RHSValue.Offset.isZero() && 11652 isOnePastTheEndOfCompleteObject(Info.Ctx, LHSValue))) 11653 return Error(E); 11654 // We can't tell whether an object is at the same address as another 11655 // zero sized object. 11656 if ((RHSValue.Base && isZeroSized(LHSValue)) || 11657 (LHSValue.Base && isZeroSized(RHSValue))) 11658 return Error(E); 11659 return Success(CCR::Nonequal, E); 11660 } 11661 11662 const CharUnits &LHSOffset = LHSValue.getLValueOffset(); 11663 const CharUnits &RHSOffset = RHSValue.getLValueOffset(); 11664 11665 SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator(); 11666 SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator(); 11667 11668 // C++11 [expr.rel]p3: 11669 // Pointers to void (after pointer conversions) can be compared, with a 11670 // result defined as follows: If both pointers represent the same 11671 // address or are both the null pointer value, the result is true if the 11672 // operator is <= or >= and false otherwise; otherwise the result is 11673 // unspecified. 11674 // We interpret this as applying to pointers to *cv* void. 11675 if (LHSTy->isVoidPointerType() && LHSOffset != RHSOffset && IsRelational) 11676 Info.CCEDiag(E, diag::note_constexpr_void_comparison); 11677 11678 // C++11 [expr.rel]p2: 11679 // - If two pointers point to non-static data members of the same object, 11680 // or to subobjects or array elements fo such members, recursively, the 11681 // pointer to the later declared member compares greater provided the 11682 // two members have the same access control and provided their class is 11683 // not a union. 11684 // [...] 11685 // - Otherwise pointer comparisons are unspecified. 11686 if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && IsRelational) { 11687 bool WasArrayIndex; 11688 unsigned Mismatch = FindDesignatorMismatch( 11689 getType(LHSValue.Base), LHSDesignator, RHSDesignator, WasArrayIndex); 11690 // At the point where the designators diverge, the comparison has a 11691 // specified value if: 11692 // - we are comparing array indices 11693 // - we are comparing fields of a union, or fields with the same access 11694 // Otherwise, the result is unspecified and thus the comparison is not a 11695 // constant expression. 11696 if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() && 11697 Mismatch < RHSDesignator.Entries.size()) { 11698 const FieldDecl *LF = getAsField(LHSDesignator.Entries[Mismatch]); 11699 const FieldDecl *RF = getAsField(RHSDesignator.Entries[Mismatch]); 11700 if (!LF && !RF) 11701 Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes); 11702 else if (!LF) 11703 Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field) 11704 << getAsBaseClass(LHSDesignator.Entries[Mismatch]) 11705 << RF->getParent() << RF; 11706 else if (!RF) 11707 Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_field) 11708 << getAsBaseClass(RHSDesignator.Entries[Mismatch]) 11709 << LF->getParent() << LF; 11710 else if (!LF->getParent()->isUnion() && 11711 LF->getAccess() != RF->getAccess()) 11712 Info.CCEDiag(E, 11713 diag::note_constexpr_pointer_comparison_differing_access) 11714 << LF << LF->getAccess() << RF << RF->getAccess() 11715 << LF->getParent(); 11716 } 11717 } 11718 11719 // The comparison here must be unsigned, and performed with the same 11720 // width as the pointer. 11721 unsigned PtrSize = Info.Ctx.getTypeSize(LHSTy); 11722 uint64_t CompareLHS = LHSOffset.getQuantity(); 11723 uint64_t CompareRHS = RHSOffset.getQuantity(); 11724 assert(PtrSize <= 64 && "Unexpected pointer width"); 11725 uint64_t Mask = ~0ULL >> (64 - PtrSize); 11726 CompareLHS &= Mask; 11727 CompareRHS &= Mask; 11728 11729 // If there is a base and this is a relational operator, we can only 11730 // compare pointers within the object in question; otherwise, the result 11731 // depends on where the object is located in memory. 11732 if (!LHSValue.Base.isNull() && IsRelational) { 11733 QualType BaseTy = getType(LHSValue.Base); 11734 if (BaseTy->isIncompleteType()) 11735 return Error(E); 11736 CharUnits Size = Info.Ctx.getTypeSizeInChars(BaseTy); 11737 uint64_t OffsetLimit = Size.getQuantity(); 11738 if (CompareLHS > OffsetLimit || CompareRHS > OffsetLimit) 11739 return Error(E); 11740 } 11741 11742 if (CompareLHS < CompareRHS) 11743 return Success(CCR::Less, E); 11744 if (CompareLHS > CompareRHS) 11745 return Success(CCR::Greater, E); 11746 return Success(CCR::Equal, E); 11747 } 11748 11749 if (LHSTy->isMemberPointerType()) { 11750 assert(IsEquality && "unexpected member pointer operation"); 11751 assert(RHSTy->isMemberPointerType() && "invalid comparison"); 11752 11753 MemberPtr LHSValue, RHSValue; 11754 11755 bool LHSOK = EvaluateMemberPointer(E->getLHS(), LHSValue, Info); 11756 if (!LHSOK && !Info.noteFailure()) 11757 return false; 11758 11759 if (!EvaluateMemberPointer(E->getRHS(), RHSValue, Info) || !LHSOK) 11760 return false; 11761 11762 // C++11 [expr.eq]p2: 11763 // If both operands are null, they compare equal. Otherwise if only one is 11764 // null, they compare unequal. 11765 if (!LHSValue.getDecl() || !RHSValue.getDecl()) { 11766 bool Equal = !LHSValue.getDecl() && !RHSValue.getDecl(); 11767 return Success(Equal ? CCR::Equal : CCR::Nonequal, E); 11768 } 11769 11770 // Otherwise if either is a pointer to a virtual member function, the 11771 // result is unspecified. 11772 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl())) 11773 if (MD->isVirtual()) 11774 Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD; 11775 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl())) 11776 if (MD->isVirtual()) 11777 Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD; 11778 11779 // Otherwise they compare equal if and only if they would refer to the 11780 // same member of the same most derived object or the same subobject if 11781 // they were dereferenced with a hypothetical object of the associated 11782 // class type. 11783 bool Equal = LHSValue == RHSValue; 11784 return Success(Equal ? CCR::Equal : CCR::Nonequal, E); 11785 } 11786 11787 if (LHSTy->isNullPtrType()) { 11788 assert(E->isComparisonOp() && "unexpected nullptr operation"); 11789 assert(RHSTy->isNullPtrType() && "missing pointer conversion"); 11790 // C++11 [expr.rel]p4, [expr.eq]p3: If two operands of type std::nullptr_t 11791 // are compared, the result is true of the operator is <=, >= or ==, and 11792 // false otherwise. 11793 return Success(CCR::Equal, E); 11794 } 11795 11796 return DoAfter(); 11797 } 11798 11799 bool RecordExprEvaluator::VisitBinCmp(const BinaryOperator *E) { 11800 if (!CheckLiteralType(Info, E)) 11801 return false; 11802 11803 auto OnSuccess = [&](ComparisonCategoryResult ResKind, 11804 const BinaryOperator *E) { 11805 // Evaluation succeeded. Lookup the information for the comparison category 11806 // type and fetch the VarDecl for the result. 11807 const ComparisonCategoryInfo &CmpInfo = 11808 Info.Ctx.CompCategories.getInfoForType(E->getType()); 11809 const VarDecl *VD = 11810 CmpInfo.getValueInfo(CmpInfo.makeWeakResult(ResKind))->VD; 11811 // Check and evaluate the result as a constant expression. 11812 LValue LV; 11813 LV.set(VD); 11814 if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result)) 11815 return false; 11816 return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result); 11817 }; 11818 return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() { 11819 return ExprEvaluatorBaseTy::VisitBinCmp(E); 11820 }); 11821 } 11822 11823 bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { 11824 // We don't call noteFailure immediately because the assignment happens after 11825 // we evaluate LHS and RHS. 11826 if (!Info.keepEvaluatingAfterFailure() && E->isAssignmentOp()) 11827 return Error(E); 11828 11829 DelayedNoteFailureRAII MaybeNoteFailureLater(Info, E->isAssignmentOp()); 11830 if (DataRecursiveIntBinOpEvaluator::shouldEnqueue(E)) 11831 return DataRecursiveIntBinOpEvaluator(*this, Result).Traverse(E); 11832 11833 assert((!E->getLHS()->getType()->isIntegralOrEnumerationType() || 11834 !E->getRHS()->getType()->isIntegralOrEnumerationType()) && 11835 "DataRecursiveIntBinOpEvaluator should have handled integral types"); 11836 11837 if (E->isComparisonOp()) { 11838 // Evaluate builtin binary comparisons by evaluating them as C++2a three-way 11839 // comparisons and then translating the result. 11840 auto OnSuccess = [&](ComparisonCategoryResult ResKind, 11841 const BinaryOperator *E) { 11842 using CCR = ComparisonCategoryResult; 11843 bool IsEqual = ResKind == CCR::Equal, 11844 IsLess = ResKind == CCR::Less, 11845 IsGreater = ResKind == CCR::Greater; 11846 auto Op = E->getOpcode(); 11847 switch (Op) { 11848 default: 11849 llvm_unreachable("unsupported binary operator"); 11850 case BO_EQ: 11851 case BO_NE: 11852 return Success(IsEqual == (Op == BO_EQ), E); 11853 case BO_LT: return Success(IsLess, E); 11854 case BO_GT: return Success(IsGreater, E); 11855 case BO_LE: return Success(IsEqual || IsLess, E); 11856 case BO_GE: return Success(IsEqual || IsGreater, E); 11857 } 11858 }; 11859 return EvaluateComparisonBinaryOperator(Info, E, OnSuccess, [&]() { 11860 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 11861 }); 11862 } 11863 11864 QualType LHSTy = E->getLHS()->getType(); 11865 QualType RHSTy = E->getRHS()->getType(); 11866 11867 if (LHSTy->isPointerType() && RHSTy->isPointerType() && 11868 E->getOpcode() == BO_Sub) { 11869 LValue LHSValue, RHSValue; 11870 11871 bool LHSOK = EvaluatePointer(E->getLHS(), LHSValue, Info); 11872 if (!LHSOK && !Info.noteFailure()) 11873 return false; 11874 11875 if (!EvaluatePointer(E->getRHS(), RHSValue, Info) || !LHSOK) 11876 return false; 11877 11878 // Reject differing bases from the normal codepath; we special-case 11879 // comparisons to null. 11880 if (!HasSameBase(LHSValue, RHSValue)) { 11881 // Handle &&A - &&B. 11882 if (!LHSValue.Offset.isZero() || !RHSValue.Offset.isZero()) 11883 return Error(E); 11884 const Expr *LHSExpr = LHSValue.Base.dyn_cast<const Expr *>(); 11885 const Expr *RHSExpr = RHSValue.Base.dyn_cast<const Expr *>(); 11886 if (!LHSExpr || !RHSExpr) 11887 return Error(E); 11888 const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr); 11889 const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr); 11890 if (!LHSAddrExpr || !RHSAddrExpr) 11891 return Error(E); 11892 // Make sure both labels come from the same function. 11893 if (LHSAddrExpr->getLabel()->getDeclContext() != 11894 RHSAddrExpr->getLabel()->getDeclContext()) 11895 return Error(E); 11896 return Success(APValue(LHSAddrExpr, RHSAddrExpr), E); 11897 } 11898 const CharUnits &LHSOffset = LHSValue.getLValueOffset(); 11899 const CharUnits &RHSOffset = RHSValue.getLValueOffset(); 11900 11901 SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator(); 11902 SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator(); 11903 11904 // C++11 [expr.add]p6: 11905 // Unless both pointers point to elements of the same array object, or 11906 // one past the last element of the array object, the behavior is 11907 // undefined. 11908 if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && 11909 !AreElementsOfSameArray(getType(LHSValue.Base), LHSDesignator, 11910 RHSDesignator)) 11911 Info.CCEDiag(E, diag::note_constexpr_pointer_subtraction_not_same_array); 11912 11913 QualType Type = E->getLHS()->getType(); 11914 QualType ElementType = Type->castAs<PointerType>()->getPointeeType(); 11915 11916 CharUnits ElementSize; 11917 if (!HandleSizeof(Info, E->getExprLoc(), ElementType, ElementSize)) 11918 return false; 11919 11920 // As an extension, a type may have zero size (empty struct or union in 11921 // C, array of zero length). Pointer subtraction in such cases has 11922 // undefined behavior, so is not constant. 11923 if (ElementSize.isZero()) { 11924 Info.FFDiag(E, diag::note_constexpr_pointer_subtraction_zero_size) 11925 << ElementType; 11926 return false; 11927 } 11928 11929 // FIXME: LLVM and GCC both compute LHSOffset - RHSOffset at runtime, 11930 // and produce incorrect results when it overflows. Such behavior 11931 // appears to be non-conforming, but is common, so perhaps we should 11932 // assume the standard intended for such cases to be undefined behavior 11933 // and check for them. 11934 11935 // Compute (LHSOffset - RHSOffset) / Size carefully, checking for 11936 // overflow in the final conversion to ptrdiff_t. 11937 APSInt LHS(llvm::APInt(65, (int64_t)LHSOffset.getQuantity(), true), false); 11938 APSInt RHS(llvm::APInt(65, (int64_t)RHSOffset.getQuantity(), true), false); 11939 APSInt ElemSize(llvm::APInt(65, (int64_t)ElementSize.getQuantity(), true), 11940 false); 11941 APSInt TrueResult = (LHS - RHS) / ElemSize; 11942 APSInt Result = TrueResult.trunc(Info.Ctx.getIntWidth(E->getType())); 11943 11944 if (Result.extend(65) != TrueResult && 11945 !HandleOverflow(Info, E, TrueResult, E->getType())) 11946 return false; 11947 return Success(Result, E); 11948 } 11949 11950 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 11951 } 11952 11953 /// VisitUnaryExprOrTypeTraitExpr - Evaluate a sizeof, alignof or vec_step with 11954 /// a result as the expression's type. 11955 bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr( 11956 const UnaryExprOrTypeTraitExpr *E) { 11957 switch(E->getKind()) { 11958 case UETT_PreferredAlignOf: 11959 case UETT_AlignOf: { 11960 if (E->isArgumentType()) 11961 return Success(GetAlignOfType(Info, E->getArgumentType(), E->getKind()), 11962 E); 11963 else 11964 return Success(GetAlignOfExpr(Info, E->getArgumentExpr(), E->getKind()), 11965 E); 11966 } 11967 11968 case UETT_VecStep: { 11969 QualType Ty = E->getTypeOfArgument(); 11970 11971 if (Ty->isVectorType()) { 11972 unsigned n = Ty->castAs<VectorType>()->getNumElements(); 11973 11974 // The vec_step built-in functions that take a 3-component 11975 // vector return 4. (OpenCL 1.1 spec 6.11.12) 11976 if (n == 3) 11977 n = 4; 11978 11979 return Success(n, E); 11980 } else 11981 return Success(1, E); 11982 } 11983 11984 case UETT_SizeOf: { 11985 QualType SrcTy = E->getTypeOfArgument(); 11986 // C++ [expr.sizeof]p2: "When applied to a reference or a reference type, 11987 // the result is the size of the referenced type." 11988 if (const ReferenceType *Ref = SrcTy->getAs<ReferenceType>()) 11989 SrcTy = Ref->getPointeeType(); 11990 11991 CharUnits Sizeof; 11992 if (!HandleSizeof(Info, E->getExprLoc(), SrcTy, Sizeof)) 11993 return false; 11994 return Success(Sizeof, E); 11995 } 11996 case UETT_OpenMPRequiredSimdAlign: 11997 assert(E->isArgumentType()); 11998 return Success( 11999 Info.Ctx.toCharUnitsFromBits( 12000 Info.Ctx.getOpenMPDefaultSimdAlign(E->getArgumentType())) 12001 .getQuantity(), 12002 E); 12003 } 12004 12005 llvm_unreachable("unknown expr/type trait"); 12006 } 12007 12008 bool IntExprEvaluator::VisitOffsetOfExpr(const OffsetOfExpr *OOE) { 12009 CharUnits Result; 12010 unsigned n = OOE->getNumComponents(); 12011 if (n == 0) 12012 return Error(OOE); 12013 QualType CurrentType = OOE->getTypeSourceInfo()->getType(); 12014 for (unsigned i = 0; i != n; ++i) { 12015 OffsetOfNode ON = OOE->getComponent(i); 12016 switch (ON.getKind()) { 12017 case OffsetOfNode::Array: { 12018 const Expr *Idx = OOE->getIndexExpr(ON.getArrayExprIndex()); 12019 APSInt IdxResult; 12020 if (!EvaluateInteger(Idx, IdxResult, Info)) 12021 return false; 12022 const ArrayType *AT = Info.Ctx.getAsArrayType(CurrentType); 12023 if (!AT) 12024 return Error(OOE); 12025 CurrentType = AT->getElementType(); 12026 CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(CurrentType); 12027 Result += IdxResult.getSExtValue() * ElementSize; 12028 break; 12029 } 12030 12031 case OffsetOfNode::Field: { 12032 FieldDecl *MemberDecl = ON.getField(); 12033 const RecordType *RT = CurrentType->getAs<RecordType>(); 12034 if (!RT) 12035 return Error(OOE); 12036 RecordDecl *RD = RT->getDecl(); 12037 if (RD->isInvalidDecl()) return false; 12038 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD); 12039 unsigned i = MemberDecl->getFieldIndex(); 12040 assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 12041 Result += Info.Ctx.toCharUnitsFromBits(RL.getFieldOffset(i)); 12042 CurrentType = MemberDecl->getType().getNonReferenceType(); 12043 break; 12044 } 12045 12046 case OffsetOfNode::Identifier: 12047 llvm_unreachable("dependent __builtin_offsetof"); 12048 12049 case OffsetOfNode::Base: { 12050 CXXBaseSpecifier *BaseSpec = ON.getBase(); 12051 if (BaseSpec->isVirtual()) 12052 return Error(OOE); 12053 12054 // Find the layout of the class whose base we are looking into. 12055 const RecordType *RT = CurrentType->getAs<RecordType>(); 12056 if (!RT) 12057 return Error(OOE); 12058 RecordDecl *RD = RT->getDecl(); 12059 if (RD->isInvalidDecl()) return false; 12060 const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD); 12061 12062 // Find the base class itself. 12063 CurrentType = BaseSpec->getType(); 12064 const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 12065 if (!BaseRT) 12066 return Error(OOE); 12067 12068 // Add the offset to the base. 12069 Result += RL.getBaseClassOffset(cast<CXXRecordDecl>(BaseRT->getDecl())); 12070 break; 12071 } 12072 } 12073 } 12074 return Success(Result, OOE); 12075 } 12076 12077 bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) { 12078 switch (E->getOpcode()) { 12079 default: 12080 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 12081 // See C99 6.6p3. 12082 return Error(E); 12083 case UO_Extension: 12084 // FIXME: Should extension allow i-c-e extension expressions in its scope? 12085 // If so, we could clear the diagnostic ID. 12086 return Visit(E->getSubExpr()); 12087 case UO_Plus: 12088 // The result is just the value. 12089 return Visit(E->getSubExpr()); 12090 case UO_Minus: { 12091 if (!Visit(E->getSubExpr())) 12092 return false; 12093 if (!Result.isInt()) return Error(E); 12094 const APSInt &Value = Result.getInt(); 12095 if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow() && 12096 !HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1), 12097 E->getType())) 12098 return false; 12099 return Success(-Value, E); 12100 } 12101 case UO_Not: { 12102 if (!Visit(E->getSubExpr())) 12103 return false; 12104 if (!Result.isInt()) return Error(E); 12105 return Success(~Result.getInt(), E); 12106 } 12107 case UO_LNot: { 12108 bool bres; 12109 if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info)) 12110 return false; 12111 return Success(!bres, E); 12112 } 12113 } 12114 } 12115 12116 /// HandleCast - This is used to evaluate implicit or explicit casts where the 12117 /// result type is integer. 12118 bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) { 12119 const Expr *SubExpr = E->getSubExpr(); 12120 QualType DestType = E->getType(); 12121 QualType SrcType = SubExpr->getType(); 12122 12123 switch (E->getCastKind()) { 12124 case CK_BaseToDerived: 12125 case CK_DerivedToBase: 12126 case CK_UncheckedDerivedToBase: 12127 case CK_Dynamic: 12128 case CK_ToUnion: 12129 case CK_ArrayToPointerDecay: 12130 case CK_FunctionToPointerDecay: 12131 case CK_NullToPointer: 12132 case CK_NullToMemberPointer: 12133 case CK_BaseToDerivedMemberPointer: 12134 case CK_DerivedToBaseMemberPointer: 12135 case CK_ReinterpretMemberPointer: 12136 case CK_ConstructorConversion: 12137 case CK_IntegralToPointer: 12138 case CK_ToVoid: 12139 case CK_VectorSplat: 12140 case CK_IntegralToFloating: 12141 case CK_FloatingCast: 12142 case CK_CPointerToObjCPointerCast: 12143 case CK_BlockPointerToObjCPointerCast: 12144 case CK_AnyPointerToBlockPointerCast: 12145 case CK_ObjCObjectLValueCast: 12146 case CK_FloatingRealToComplex: 12147 case CK_FloatingComplexToReal: 12148 case CK_FloatingComplexCast: 12149 case CK_FloatingComplexToIntegralComplex: 12150 case CK_IntegralRealToComplex: 12151 case CK_IntegralComplexCast: 12152 case CK_IntegralComplexToFloatingComplex: 12153 case CK_BuiltinFnToFnPtr: 12154 case CK_ZeroToOCLOpaqueType: 12155 case CK_NonAtomicToAtomic: 12156 case CK_AddressSpaceConversion: 12157 case CK_IntToOCLSampler: 12158 case CK_FixedPointCast: 12159 case CK_IntegralToFixedPoint: 12160 llvm_unreachable("invalid cast kind for integral value"); 12161 12162 case CK_BitCast: 12163 case CK_Dependent: 12164 case CK_LValueBitCast: 12165 case CK_ARCProduceObject: 12166 case CK_ARCConsumeObject: 12167 case CK_ARCReclaimReturnedObject: 12168 case CK_ARCExtendBlockObject: 12169 case CK_CopyAndAutoreleaseBlockObject: 12170 return Error(E); 12171 12172 case CK_UserDefinedConversion: 12173 case CK_LValueToRValue: 12174 case CK_AtomicToNonAtomic: 12175 case CK_NoOp: 12176 case CK_LValueToRValueBitCast: 12177 return ExprEvaluatorBaseTy::VisitCastExpr(E); 12178 12179 case CK_MemberPointerToBoolean: 12180 case CK_PointerToBoolean: 12181 case CK_IntegralToBoolean: 12182 case CK_FloatingToBoolean: 12183 case CK_BooleanToSignedIntegral: 12184 case CK_FloatingComplexToBoolean: 12185 case CK_IntegralComplexToBoolean: { 12186 bool BoolResult; 12187 if (!EvaluateAsBooleanCondition(SubExpr, BoolResult, Info)) 12188 return false; 12189 uint64_t IntResult = BoolResult; 12190 if (BoolResult && E->getCastKind() == CK_BooleanToSignedIntegral) 12191 IntResult = (uint64_t)-1; 12192 return Success(IntResult, E); 12193 } 12194 12195 case CK_FixedPointToIntegral: { 12196 APFixedPoint Src(Info.Ctx.getFixedPointSemantics(SrcType)); 12197 if (!EvaluateFixedPoint(SubExpr, Src, Info)) 12198 return false; 12199 bool Overflowed; 12200 llvm::APSInt Result = Src.convertToInt( 12201 Info.Ctx.getIntWidth(DestType), 12202 DestType->isSignedIntegerOrEnumerationType(), &Overflowed); 12203 if (Overflowed && !HandleOverflow(Info, E, Result, DestType)) 12204 return false; 12205 return Success(Result, E); 12206 } 12207 12208 case CK_FixedPointToBoolean: { 12209 // Unsigned padding does not affect this. 12210 APValue Val; 12211 if (!Evaluate(Val, Info, SubExpr)) 12212 return false; 12213 return Success(Val.getFixedPoint().getBoolValue(), E); 12214 } 12215 12216 case CK_IntegralCast: { 12217 if (!Visit(SubExpr)) 12218 return false; 12219 12220 if (!Result.isInt()) { 12221 // Allow casts of address-of-label differences if they are no-ops 12222 // or narrowing. (The narrowing case isn't actually guaranteed to 12223 // be constant-evaluatable except in some narrow cases which are hard 12224 // to detect here. We let it through on the assumption the user knows 12225 // what they are doing.) 12226 if (Result.isAddrLabelDiff()) 12227 return Info.Ctx.getTypeSize(DestType) <= Info.Ctx.getTypeSize(SrcType); 12228 // Only allow casts of lvalues if they are lossless. 12229 return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType); 12230 } 12231 12232 return Success(HandleIntToIntCast(Info, E, DestType, SrcType, 12233 Result.getInt()), E); 12234 } 12235 12236 case CK_PointerToIntegral: { 12237 CCEDiag(E, diag::note_constexpr_invalid_cast) << 2; 12238 12239 LValue LV; 12240 if (!EvaluatePointer(SubExpr, LV, Info)) 12241 return false; 12242 12243 if (LV.getLValueBase()) { 12244 // Only allow based lvalue casts if they are lossless. 12245 // FIXME: Allow a larger integer size than the pointer size, and allow 12246 // narrowing back down to pointer width in subsequent integral casts. 12247 // FIXME: Check integer type's active bits, not its type size. 12248 if (Info.Ctx.getTypeSize(DestType) != Info.Ctx.getTypeSize(SrcType)) 12249 return Error(E); 12250 12251 LV.Designator.setInvalid(); 12252 LV.moveInto(Result); 12253 return true; 12254 } 12255 12256 APSInt AsInt; 12257 APValue V; 12258 LV.moveInto(V); 12259 if (!V.toIntegralConstant(AsInt, SrcType, Info.Ctx)) 12260 llvm_unreachable("Can't cast this!"); 12261 12262 return Success(HandleIntToIntCast(Info, E, DestType, SrcType, AsInt), E); 12263 } 12264 12265 case CK_IntegralComplexToReal: { 12266 ComplexValue C; 12267 if (!EvaluateComplex(SubExpr, C, Info)) 12268 return false; 12269 return Success(C.getComplexIntReal(), E); 12270 } 12271 12272 case CK_FloatingToIntegral: { 12273 APFloat F(0.0); 12274 if (!EvaluateFloat(SubExpr, F, Info)) 12275 return false; 12276 12277 APSInt Value; 12278 if (!HandleFloatToIntCast(Info, E, SrcType, F, DestType, Value)) 12279 return false; 12280 return Success(Value, E); 12281 } 12282 } 12283 12284 llvm_unreachable("unknown cast resulting in integral value"); 12285 } 12286 12287 bool IntExprEvaluator::VisitUnaryReal(const UnaryOperator *E) { 12288 if (E->getSubExpr()->getType()->isAnyComplexType()) { 12289 ComplexValue LV; 12290 if (!EvaluateComplex(E->getSubExpr(), LV, Info)) 12291 return false; 12292 if (!LV.isComplexInt()) 12293 return Error(E); 12294 return Success(LV.getComplexIntReal(), E); 12295 } 12296 12297 return Visit(E->getSubExpr()); 12298 } 12299 12300 bool IntExprEvaluator::VisitUnaryImag(const UnaryOperator *E) { 12301 if (E->getSubExpr()->getType()->isComplexIntegerType()) { 12302 ComplexValue LV; 12303 if (!EvaluateComplex(E->getSubExpr(), LV, Info)) 12304 return false; 12305 if (!LV.isComplexInt()) 12306 return Error(E); 12307 return Success(LV.getComplexIntImag(), E); 12308 } 12309 12310 VisitIgnoredValue(E->getSubExpr()); 12311 return Success(0, E); 12312 } 12313 12314 bool IntExprEvaluator::VisitSizeOfPackExpr(const SizeOfPackExpr *E) { 12315 return Success(E->getPackLength(), E); 12316 } 12317 12318 bool IntExprEvaluator::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) { 12319 return Success(E->getValue(), E); 12320 } 12321 12322 bool IntExprEvaluator::VisitConceptSpecializationExpr( 12323 const ConceptSpecializationExpr *E) { 12324 return Success(E->isSatisfied(), E); 12325 } 12326 12327 12328 bool FixedPointExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) { 12329 switch (E->getOpcode()) { 12330 default: 12331 // Invalid unary operators 12332 return Error(E); 12333 case UO_Plus: 12334 // The result is just the value. 12335 return Visit(E->getSubExpr()); 12336 case UO_Minus: { 12337 if (!Visit(E->getSubExpr())) return false; 12338 if (!Result.isFixedPoint()) 12339 return Error(E); 12340 bool Overflowed; 12341 APFixedPoint Negated = Result.getFixedPoint().negate(&Overflowed); 12342 if (Overflowed && !HandleOverflow(Info, E, Negated, E->getType())) 12343 return false; 12344 return Success(Negated, E); 12345 } 12346 case UO_LNot: { 12347 bool bres; 12348 if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info)) 12349 return false; 12350 return Success(!bres, E); 12351 } 12352 } 12353 } 12354 12355 bool FixedPointExprEvaluator::VisitCastExpr(const CastExpr *E) { 12356 const Expr *SubExpr = E->getSubExpr(); 12357 QualType DestType = E->getType(); 12358 assert(DestType->isFixedPointType() && 12359 "Expected destination type to be a fixed point type"); 12360 auto DestFXSema = Info.Ctx.getFixedPointSemantics(DestType); 12361 12362 switch (E->getCastKind()) { 12363 case CK_FixedPointCast: { 12364 APFixedPoint Src(Info.Ctx.getFixedPointSemantics(SubExpr->getType())); 12365 if (!EvaluateFixedPoint(SubExpr, Src, Info)) 12366 return false; 12367 bool Overflowed; 12368 APFixedPoint Result = Src.convert(DestFXSema, &Overflowed); 12369 if (Overflowed && !HandleOverflow(Info, E, Result, DestType)) 12370 return false; 12371 return Success(Result, E); 12372 } 12373 case CK_IntegralToFixedPoint: { 12374 APSInt Src; 12375 if (!EvaluateInteger(SubExpr, Src, Info)) 12376 return false; 12377 12378 bool Overflowed; 12379 APFixedPoint IntResult = APFixedPoint::getFromIntValue( 12380 Src, Info.Ctx.getFixedPointSemantics(DestType), &Overflowed); 12381 12382 if (Overflowed && !HandleOverflow(Info, E, IntResult, DestType)) 12383 return false; 12384 12385 return Success(IntResult, E); 12386 } 12387 case CK_NoOp: 12388 case CK_LValueToRValue: 12389 return ExprEvaluatorBaseTy::VisitCastExpr(E); 12390 default: 12391 return Error(E); 12392 } 12393 } 12394 12395 bool FixedPointExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { 12396 const Expr *LHS = E->getLHS(); 12397 const Expr *RHS = E->getRHS(); 12398 FixedPointSemantics ResultFXSema = 12399 Info.Ctx.getFixedPointSemantics(E->getType()); 12400 12401 APFixedPoint LHSFX(Info.Ctx.getFixedPointSemantics(LHS->getType())); 12402 if (!EvaluateFixedPointOrInteger(LHS, LHSFX, Info)) 12403 return false; 12404 APFixedPoint RHSFX(Info.Ctx.getFixedPointSemantics(RHS->getType())); 12405 if (!EvaluateFixedPointOrInteger(RHS, RHSFX, Info)) 12406 return false; 12407 12408 switch (E->getOpcode()) { 12409 case BO_Add: { 12410 bool AddOverflow, ConversionOverflow; 12411 APFixedPoint Result = LHSFX.add(RHSFX, &AddOverflow) 12412 .convert(ResultFXSema, &ConversionOverflow); 12413 if ((AddOverflow || ConversionOverflow) && 12414 !HandleOverflow(Info, E, Result, E->getType())) 12415 return false; 12416 return Success(Result, E); 12417 } 12418 default: 12419 return false; 12420 } 12421 llvm_unreachable("Should've exited before this"); 12422 } 12423 12424 //===----------------------------------------------------------------------===// 12425 // Float Evaluation 12426 //===----------------------------------------------------------------------===// 12427 12428 namespace { 12429 class FloatExprEvaluator 12430 : public ExprEvaluatorBase<FloatExprEvaluator> { 12431 APFloat &Result; 12432 public: 12433 FloatExprEvaluator(EvalInfo &info, APFloat &result) 12434 : ExprEvaluatorBaseTy(info), Result(result) {} 12435 12436 bool Success(const APValue &V, const Expr *e) { 12437 Result = V.getFloat(); 12438 return true; 12439 } 12440 12441 bool ZeroInitialization(const Expr *E) { 12442 Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType())); 12443 return true; 12444 } 12445 12446 bool VisitCallExpr(const CallExpr *E); 12447 12448 bool VisitUnaryOperator(const UnaryOperator *E); 12449 bool VisitBinaryOperator(const BinaryOperator *E); 12450 bool VisitFloatingLiteral(const FloatingLiteral *E); 12451 bool VisitCastExpr(const CastExpr *E); 12452 12453 bool VisitUnaryReal(const UnaryOperator *E); 12454 bool VisitUnaryImag(const UnaryOperator *E); 12455 12456 // FIXME: Missing: array subscript of vector, member of vector 12457 }; 12458 } // end anonymous namespace 12459 12460 static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) { 12461 assert(E->isRValue() && E->getType()->isRealFloatingType()); 12462 return FloatExprEvaluator(Info, Result).Visit(E); 12463 } 12464 12465 static bool TryEvaluateBuiltinNaN(const ASTContext &Context, 12466 QualType ResultTy, 12467 const Expr *Arg, 12468 bool SNaN, 12469 llvm::APFloat &Result) { 12470 const StringLiteral *S = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts()); 12471 if (!S) return false; 12472 12473 const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(ResultTy); 12474 12475 llvm::APInt fill; 12476 12477 // Treat empty strings as if they were zero. 12478 if (S->getString().empty()) 12479 fill = llvm::APInt(32, 0); 12480 else if (S->getString().getAsInteger(0, fill)) 12481 return false; 12482 12483 if (Context.getTargetInfo().isNan2008()) { 12484 if (SNaN) 12485 Result = llvm::APFloat::getSNaN(Sem, false, &fill); 12486 else 12487 Result = llvm::APFloat::getQNaN(Sem, false, &fill); 12488 } else { 12489 // Prior to IEEE 754-2008, architectures were allowed to choose whether 12490 // the first bit of their significand was set for qNaN or sNaN. MIPS chose 12491 // a different encoding to what became a standard in 2008, and for pre- 12492 // 2008 revisions, MIPS interpreted sNaN-2008 as qNan and qNaN-2008 as 12493 // sNaN. This is now known as "legacy NaN" encoding. 12494 if (SNaN) 12495 Result = llvm::APFloat::getQNaN(Sem, false, &fill); 12496 else 12497 Result = llvm::APFloat::getSNaN(Sem, false, &fill); 12498 } 12499 12500 return true; 12501 } 12502 12503 bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) { 12504 switch (E->getBuiltinCallee()) { 12505 default: 12506 return ExprEvaluatorBaseTy::VisitCallExpr(E); 12507 12508 case Builtin::BI__builtin_huge_val: 12509 case Builtin::BI__builtin_huge_valf: 12510 case Builtin::BI__builtin_huge_vall: 12511 case Builtin::BI__builtin_huge_valf128: 12512 case Builtin::BI__builtin_inf: 12513 case Builtin::BI__builtin_inff: 12514 case Builtin::BI__builtin_infl: 12515 case Builtin::BI__builtin_inff128: { 12516 const llvm::fltSemantics &Sem = 12517 Info.Ctx.getFloatTypeSemantics(E->getType()); 12518 Result = llvm::APFloat::getInf(Sem); 12519 return true; 12520 } 12521 12522 case Builtin::BI__builtin_nans: 12523 case Builtin::BI__builtin_nansf: 12524 case Builtin::BI__builtin_nansl: 12525 case Builtin::BI__builtin_nansf128: 12526 if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0), 12527 true, Result)) 12528 return Error(E); 12529 return true; 12530 12531 case Builtin::BI__builtin_nan: 12532 case Builtin::BI__builtin_nanf: 12533 case Builtin::BI__builtin_nanl: 12534 case Builtin::BI__builtin_nanf128: 12535 // If this is __builtin_nan() turn this into a nan, otherwise we 12536 // can't constant fold it. 12537 if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0), 12538 false, Result)) 12539 return Error(E); 12540 return true; 12541 12542 case Builtin::BI__builtin_fabs: 12543 case Builtin::BI__builtin_fabsf: 12544 case Builtin::BI__builtin_fabsl: 12545 case Builtin::BI__builtin_fabsf128: 12546 if (!EvaluateFloat(E->getArg(0), Result, Info)) 12547 return false; 12548 12549 if (Result.isNegative()) 12550 Result.changeSign(); 12551 return true; 12552 12553 // FIXME: Builtin::BI__builtin_powi 12554 // FIXME: Builtin::BI__builtin_powif 12555 // FIXME: Builtin::BI__builtin_powil 12556 12557 case Builtin::BI__builtin_copysign: 12558 case Builtin::BI__builtin_copysignf: 12559 case Builtin::BI__builtin_copysignl: 12560 case Builtin::BI__builtin_copysignf128: { 12561 APFloat RHS(0.); 12562 if (!EvaluateFloat(E->getArg(0), Result, Info) || 12563 !EvaluateFloat(E->getArg(1), RHS, Info)) 12564 return false; 12565 Result.copySign(RHS); 12566 return true; 12567 } 12568 } 12569 } 12570 12571 bool FloatExprEvaluator::VisitUnaryReal(const UnaryOperator *E) { 12572 if (E->getSubExpr()->getType()->isAnyComplexType()) { 12573 ComplexValue CV; 12574 if (!EvaluateComplex(E->getSubExpr(), CV, Info)) 12575 return false; 12576 Result = CV.FloatReal; 12577 return true; 12578 } 12579 12580 return Visit(E->getSubExpr()); 12581 } 12582 12583 bool FloatExprEvaluator::VisitUnaryImag(const UnaryOperator *E) { 12584 if (E->getSubExpr()->getType()->isAnyComplexType()) { 12585 ComplexValue CV; 12586 if (!EvaluateComplex(E->getSubExpr(), CV, Info)) 12587 return false; 12588 Result = CV.FloatImag; 12589 return true; 12590 } 12591 12592 VisitIgnoredValue(E->getSubExpr()); 12593 const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->getType()); 12594 Result = llvm::APFloat::getZero(Sem); 12595 return true; 12596 } 12597 12598 bool FloatExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) { 12599 switch (E->getOpcode()) { 12600 default: return Error(E); 12601 case UO_Plus: 12602 return EvaluateFloat(E->getSubExpr(), Result, Info); 12603 case UO_Minus: 12604 if (!EvaluateFloat(E->getSubExpr(), Result, Info)) 12605 return false; 12606 Result.changeSign(); 12607 return true; 12608 } 12609 } 12610 12611 bool FloatExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { 12612 if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma) 12613 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 12614 12615 APFloat RHS(0.0); 12616 bool LHSOK = EvaluateFloat(E->getLHS(), Result, Info); 12617 if (!LHSOK && !Info.noteFailure()) 12618 return false; 12619 return EvaluateFloat(E->getRHS(), RHS, Info) && LHSOK && 12620 handleFloatFloatBinOp(Info, E, Result, E->getOpcode(), RHS); 12621 } 12622 12623 bool FloatExprEvaluator::VisitFloatingLiteral(const FloatingLiteral *E) { 12624 Result = E->getValue(); 12625 return true; 12626 } 12627 12628 bool FloatExprEvaluator::VisitCastExpr(const CastExpr *E) { 12629 const Expr* SubExpr = E->getSubExpr(); 12630 12631 switch (E->getCastKind()) { 12632 default: 12633 return ExprEvaluatorBaseTy::VisitCastExpr(E); 12634 12635 case CK_IntegralToFloating: { 12636 APSInt IntResult; 12637 return EvaluateInteger(SubExpr, IntResult, Info) && 12638 HandleIntToFloatCast(Info, E, SubExpr->getType(), IntResult, 12639 E->getType(), Result); 12640 } 12641 12642 case CK_FloatingCast: { 12643 if (!Visit(SubExpr)) 12644 return false; 12645 return HandleFloatToFloatCast(Info, E, SubExpr->getType(), E->getType(), 12646 Result); 12647 } 12648 12649 case CK_FloatingComplexToReal: { 12650 ComplexValue V; 12651 if (!EvaluateComplex(SubExpr, V, Info)) 12652 return false; 12653 Result = V.getComplexFloatReal(); 12654 return true; 12655 } 12656 } 12657 } 12658 12659 //===----------------------------------------------------------------------===// 12660 // Complex Evaluation (for float and integer) 12661 //===----------------------------------------------------------------------===// 12662 12663 namespace { 12664 class ComplexExprEvaluator 12665 : public ExprEvaluatorBase<ComplexExprEvaluator> { 12666 ComplexValue &Result; 12667 12668 public: 12669 ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result) 12670 : ExprEvaluatorBaseTy(info), Result(Result) {} 12671 12672 bool Success(const APValue &V, const Expr *e) { 12673 Result.setFrom(V); 12674 return true; 12675 } 12676 12677 bool ZeroInitialization(const Expr *E); 12678 12679 //===--------------------------------------------------------------------===// 12680 // Visitor Methods 12681 //===--------------------------------------------------------------------===// 12682 12683 bool VisitImaginaryLiteral(const ImaginaryLiteral *E); 12684 bool VisitCastExpr(const CastExpr *E); 12685 bool VisitBinaryOperator(const BinaryOperator *E); 12686 bool VisitUnaryOperator(const UnaryOperator *E); 12687 bool VisitInitListExpr(const InitListExpr *E); 12688 }; 12689 } // end anonymous namespace 12690 12691 static bool EvaluateComplex(const Expr *E, ComplexValue &Result, 12692 EvalInfo &Info) { 12693 assert(E->isRValue() && E->getType()->isAnyComplexType()); 12694 return ComplexExprEvaluator(Info, Result).Visit(E); 12695 } 12696 12697 bool ComplexExprEvaluator::ZeroInitialization(const Expr *E) { 12698 QualType ElemTy = E->getType()->castAs<ComplexType>()->getElementType(); 12699 if (ElemTy->isRealFloatingType()) { 12700 Result.makeComplexFloat(); 12701 APFloat Zero = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(ElemTy)); 12702 Result.FloatReal = Zero; 12703 Result.FloatImag = Zero; 12704 } else { 12705 Result.makeComplexInt(); 12706 APSInt Zero = Info.Ctx.MakeIntValue(0, ElemTy); 12707 Result.IntReal = Zero; 12708 Result.IntImag = Zero; 12709 } 12710 return true; 12711 } 12712 12713 bool ComplexExprEvaluator::VisitImaginaryLiteral(const ImaginaryLiteral *E) { 12714 const Expr* SubExpr = E->getSubExpr(); 12715 12716 if (SubExpr->getType()->isRealFloatingType()) { 12717 Result.makeComplexFloat(); 12718 APFloat &Imag = Result.FloatImag; 12719 if (!EvaluateFloat(SubExpr, Imag, Info)) 12720 return false; 12721 12722 Result.FloatReal = APFloat(Imag.getSemantics()); 12723 return true; 12724 } else { 12725 assert(SubExpr->getType()->isIntegerType() && 12726 "Unexpected imaginary literal."); 12727 12728 Result.makeComplexInt(); 12729 APSInt &Imag = Result.IntImag; 12730 if (!EvaluateInteger(SubExpr, Imag, Info)) 12731 return false; 12732 12733 Result.IntReal = APSInt(Imag.getBitWidth(), !Imag.isSigned()); 12734 return true; 12735 } 12736 } 12737 12738 bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) { 12739 12740 switch (E->getCastKind()) { 12741 case CK_BitCast: 12742 case CK_BaseToDerived: 12743 case CK_DerivedToBase: 12744 case CK_UncheckedDerivedToBase: 12745 case CK_Dynamic: 12746 case CK_ToUnion: 12747 case CK_ArrayToPointerDecay: 12748 case CK_FunctionToPointerDecay: 12749 case CK_NullToPointer: 12750 case CK_NullToMemberPointer: 12751 case CK_BaseToDerivedMemberPointer: 12752 case CK_DerivedToBaseMemberPointer: 12753 case CK_MemberPointerToBoolean: 12754 case CK_ReinterpretMemberPointer: 12755 case CK_ConstructorConversion: 12756 case CK_IntegralToPointer: 12757 case CK_PointerToIntegral: 12758 case CK_PointerToBoolean: 12759 case CK_ToVoid: 12760 case CK_VectorSplat: 12761 case CK_IntegralCast: 12762 case CK_BooleanToSignedIntegral: 12763 case CK_IntegralToBoolean: 12764 case CK_IntegralToFloating: 12765 case CK_FloatingToIntegral: 12766 case CK_FloatingToBoolean: 12767 case CK_FloatingCast: 12768 case CK_CPointerToObjCPointerCast: 12769 case CK_BlockPointerToObjCPointerCast: 12770 case CK_AnyPointerToBlockPointerCast: 12771 case CK_ObjCObjectLValueCast: 12772 case CK_FloatingComplexToReal: 12773 case CK_FloatingComplexToBoolean: 12774 case CK_IntegralComplexToReal: 12775 case CK_IntegralComplexToBoolean: 12776 case CK_ARCProduceObject: 12777 case CK_ARCConsumeObject: 12778 case CK_ARCReclaimReturnedObject: 12779 case CK_ARCExtendBlockObject: 12780 case CK_CopyAndAutoreleaseBlockObject: 12781 case CK_BuiltinFnToFnPtr: 12782 case CK_ZeroToOCLOpaqueType: 12783 case CK_NonAtomicToAtomic: 12784 case CK_AddressSpaceConversion: 12785 case CK_IntToOCLSampler: 12786 case CK_FixedPointCast: 12787 case CK_FixedPointToBoolean: 12788 case CK_FixedPointToIntegral: 12789 case CK_IntegralToFixedPoint: 12790 llvm_unreachable("invalid cast kind for complex value"); 12791 12792 case CK_LValueToRValue: 12793 case CK_AtomicToNonAtomic: 12794 case CK_NoOp: 12795 case CK_LValueToRValueBitCast: 12796 return ExprEvaluatorBaseTy::VisitCastExpr(E); 12797 12798 case CK_Dependent: 12799 case CK_LValueBitCast: 12800 case CK_UserDefinedConversion: 12801 return Error(E); 12802 12803 case CK_FloatingRealToComplex: { 12804 APFloat &Real = Result.FloatReal; 12805 if (!EvaluateFloat(E->getSubExpr(), Real, Info)) 12806 return false; 12807 12808 Result.makeComplexFloat(); 12809 Result.FloatImag = APFloat(Real.getSemantics()); 12810 return true; 12811 } 12812 12813 case CK_FloatingComplexCast: { 12814 if (!Visit(E->getSubExpr())) 12815 return false; 12816 12817 QualType To = E->getType()->castAs<ComplexType>()->getElementType(); 12818 QualType From 12819 = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType(); 12820 12821 return HandleFloatToFloatCast(Info, E, From, To, Result.FloatReal) && 12822 HandleFloatToFloatCast(Info, E, From, To, Result.FloatImag); 12823 } 12824 12825 case CK_FloatingComplexToIntegralComplex: { 12826 if (!Visit(E->getSubExpr())) 12827 return false; 12828 12829 QualType To = E->getType()->castAs<ComplexType>()->getElementType(); 12830 QualType From 12831 = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType(); 12832 Result.makeComplexInt(); 12833 return HandleFloatToIntCast(Info, E, From, Result.FloatReal, 12834 To, Result.IntReal) && 12835 HandleFloatToIntCast(Info, E, From, Result.FloatImag, 12836 To, Result.IntImag); 12837 } 12838 12839 case CK_IntegralRealToComplex: { 12840 APSInt &Real = Result.IntReal; 12841 if (!EvaluateInteger(E->getSubExpr(), Real, Info)) 12842 return false; 12843 12844 Result.makeComplexInt(); 12845 Result.IntImag = APSInt(Real.getBitWidth(), !Real.isSigned()); 12846 return true; 12847 } 12848 12849 case CK_IntegralComplexCast: { 12850 if (!Visit(E->getSubExpr())) 12851 return false; 12852 12853 QualType To = E->getType()->castAs<ComplexType>()->getElementType(); 12854 QualType From 12855 = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType(); 12856 12857 Result.IntReal = HandleIntToIntCast(Info, E, To, From, Result.IntReal); 12858 Result.IntImag = HandleIntToIntCast(Info, E, To, From, Result.IntImag); 12859 return true; 12860 } 12861 12862 case CK_IntegralComplexToFloatingComplex: { 12863 if (!Visit(E->getSubExpr())) 12864 return false; 12865 12866 QualType To = E->getType()->castAs<ComplexType>()->getElementType(); 12867 QualType From 12868 = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType(); 12869 Result.makeComplexFloat(); 12870 return HandleIntToFloatCast(Info, E, From, Result.IntReal, 12871 To, Result.FloatReal) && 12872 HandleIntToFloatCast(Info, E, From, Result.IntImag, 12873 To, Result.FloatImag); 12874 } 12875 } 12876 12877 llvm_unreachable("unknown cast resulting in complex value"); 12878 } 12879 12880 bool ComplexExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) { 12881 if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma) 12882 return ExprEvaluatorBaseTy::VisitBinaryOperator(E); 12883 12884 // Track whether the LHS or RHS is real at the type system level. When this is 12885 // the case we can simplify our evaluation strategy. 12886 bool LHSReal = false, RHSReal = false; 12887 12888 bool LHSOK; 12889 if (E->getLHS()->getType()->isRealFloatingType()) { 12890 LHSReal = true; 12891 APFloat &Real = Result.FloatReal; 12892 LHSOK = EvaluateFloat(E->getLHS(), Real, Info); 12893 if (LHSOK) { 12894 Result.makeComplexFloat(); 12895 Result.FloatImag = APFloat(Real.getSemantics()); 12896 } 12897 } else { 12898 LHSOK = Visit(E->getLHS()); 12899 } 12900 if (!LHSOK && !Info.noteFailure()) 12901 return false; 12902 12903 ComplexValue RHS; 12904 if (E->getRHS()->getType()->isRealFloatingType()) { 12905 RHSReal = true; 12906 APFloat &Real = RHS.FloatReal; 12907 if (!EvaluateFloat(E->getRHS(), Real, Info) || !LHSOK) 12908 return false; 12909 RHS.makeComplexFloat(); 12910 RHS.FloatImag = APFloat(Real.getSemantics()); 12911 } else if (!EvaluateComplex(E->getRHS(), RHS, Info) || !LHSOK) 12912 return false; 12913 12914 assert(!(LHSReal && RHSReal) && 12915 "Cannot have both operands of a complex operation be real."); 12916 switch (E->getOpcode()) { 12917 default: return Error(E); 12918 case BO_Add: 12919 if (Result.isComplexFloat()) { 12920 Result.getComplexFloatReal().add(RHS.getComplexFloatReal(), 12921 APFloat::rmNearestTiesToEven); 12922 if (LHSReal) 12923 Result.getComplexFloatImag() = RHS.getComplexFloatImag(); 12924 else if (!RHSReal) 12925 Result.getComplexFloatImag().add(RHS.getComplexFloatImag(), 12926 APFloat::rmNearestTiesToEven); 12927 } else { 12928 Result.getComplexIntReal() += RHS.getComplexIntReal(); 12929 Result.getComplexIntImag() += RHS.getComplexIntImag(); 12930 } 12931 break; 12932 case BO_Sub: 12933 if (Result.isComplexFloat()) { 12934 Result.getComplexFloatReal().subtract(RHS.getComplexFloatReal(), 12935 APFloat::rmNearestTiesToEven); 12936 if (LHSReal) { 12937 Result.getComplexFloatImag() = RHS.getComplexFloatImag(); 12938 Result.getComplexFloatImag().changeSign(); 12939 } else if (!RHSReal) { 12940 Result.getComplexFloatImag().subtract(RHS.getComplexFloatImag(), 12941 APFloat::rmNearestTiesToEven); 12942 } 12943 } else { 12944 Result.getComplexIntReal() -= RHS.getComplexIntReal(); 12945 Result.getComplexIntImag() -= RHS.getComplexIntImag(); 12946 } 12947 break; 12948 case BO_Mul: 12949 if (Result.isComplexFloat()) { 12950 // This is an implementation of complex multiplication according to the 12951 // constraints laid out in C11 Annex G. The implementation uses the 12952 // following naming scheme: 12953 // (a + ib) * (c + id) 12954 ComplexValue LHS = Result; 12955 APFloat &A = LHS.getComplexFloatReal(); 12956 APFloat &B = LHS.getComplexFloatImag(); 12957 APFloat &C = RHS.getComplexFloatReal(); 12958 APFloat &D = RHS.getComplexFloatImag(); 12959 APFloat &ResR = Result.getComplexFloatReal(); 12960 APFloat &ResI = Result.getComplexFloatImag(); 12961 if (LHSReal) { 12962 assert(!RHSReal && "Cannot have two real operands for a complex op!"); 12963 ResR = A * C; 12964 ResI = A * D; 12965 } else if (RHSReal) { 12966 ResR = C * A; 12967 ResI = C * B; 12968 } else { 12969 // In the fully general case, we need to handle NaNs and infinities 12970 // robustly. 12971 APFloat AC = A * C; 12972 APFloat BD = B * D; 12973 APFloat AD = A * D; 12974 APFloat BC = B * C; 12975 ResR = AC - BD; 12976 ResI = AD + BC; 12977 if (ResR.isNaN() && ResI.isNaN()) { 12978 bool Recalc = false; 12979 if (A.isInfinity() || B.isInfinity()) { 12980 A = APFloat::copySign( 12981 APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A); 12982 B = APFloat::copySign( 12983 APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B); 12984 if (C.isNaN()) 12985 C = APFloat::copySign(APFloat(C.getSemantics()), C); 12986 if (D.isNaN()) 12987 D = APFloat::copySign(APFloat(D.getSemantics()), D); 12988 Recalc = true; 12989 } 12990 if (C.isInfinity() || D.isInfinity()) { 12991 C = APFloat::copySign( 12992 APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C); 12993 D = APFloat::copySign( 12994 APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D); 12995 if (A.isNaN()) 12996 A = APFloat::copySign(APFloat(A.getSemantics()), A); 12997 if (B.isNaN()) 12998 B = APFloat::copySign(APFloat(B.getSemantics()), B); 12999 Recalc = true; 13000 } 13001 if (!Recalc && (AC.isInfinity() || BD.isInfinity() || 13002 AD.isInfinity() || BC.isInfinity())) { 13003 if (A.isNaN()) 13004 A = APFloat::copySign(APFloat(A.getSemantics()), A); 13005 if (B.isNaN()) 13006 B = APFloat::copySign(APFloat(B.getSemantics()), B); 13007 if (C.isNaN()) 13008 C = APFloat::copySign(APFloat(C.getSemantics()), C); 13009 if (D.isNaN()) 13010 D = APFloat::copySign(APFloat(D.getSemantics()), D); 13011 Recalc = true; 13012 } 13013 if (Recalc) { 13014 ResR = APFloat::getInf(A.getSemantics()) * (A * C - B * D); 13015 ResI = APFloat::getInf(A.getSemantics()) * (A * D + B * C); 13016 } 13017 } 13018 } 13019 } else { 13020 ComplexValue LHS = Result; 13021 Result.getComplexIntReal() = 13022 (LHS.getComplexIntReal() * RHS.getComplexIntReal() - 13023 LHS.getComplexIntImag() * RHS.getComplexIntImag()); 13024 Result.getComplexIntImag() = 13025 (LHS.getComplexIntReal() * RHS.getComplexIntImag() + 13026 LHS.getComplexIntImag() * RHS.getComplexIntReal()); 13027 } 13028 break; 13029 case BO_Div: 13030 if (Result.isComplexFloat()) { 13031 // This is an implementation of complex division according to the 13032 // constraints laid out in C11 Annex G. The implementation uses the 13033 // following naming scheme: 13034 // (a + ib) / (c + id) 13035 ComplexValue LHS = Result; 13036 APFloat &A = LHS.getComplexFloatReal(); 13037 APFloat &B = LHS.getComplexFloatImag(); 13038 APFloat &C = RHS.getComplexFloatReal(); 13039 APFloat &D = RHS.getComplexFloatImag(); 13040 APFloat &ResR = Result.getComplexFloatReal(); 13041 APFloat &ResI = Result.getComplexFloatImag(); 13042 if (RHSReal) { 13043 ResR = A / C; 13044 ResI = B / C; 13045 } else { 13046 if (LHSReal) { 13047 // No real optimizations we can do here, stub out with zero. 13048 B = APFloat::getZero(A.getSemantics()); 13049 } 13050 int DenomLogB = 0; 13051 APFloat MaxCD = maxnum(abs(C), abs(D)); 13052 if (MaxCD.isFinite()) { 13053 DenomLogB = ilogb(MaxCD); 13054 C = scalbn(C, -DenomLogB, APFloat::rmNearestTiesToEven); 13055 D = scalbn(D, -DenomLogB, APFloat::rmNearestTiesToEven); 13056 } 13057 APFloat Denom = C * C + D * D; 13058 ResR = scalbn((A * C + B * D) / Denom, -DenomLogB, 13059 APFloat::rmNearestTiesToEven); 13060 ResI = scalbn((B * C - A * D) / Denom, -DenomLogB, 13061 APFloat::rmNearestTiesToEven); 13062 if (ResR.isNaN() && ResI.isNaN()) { 13063 if (Denom.isPosZero() && (!A.isNaN() || !B.isNaN())) { 13064 ResR = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * A; 13065 ResI = APFloat::getInf(ResR.getSemantics(), C.isNegative()) * B; 13066 } else if ((A.isInfinity() || B.isInfinity()) && C.isFinite() && 13067 D.isFinite()) { 13068 A = APFloat::copySign( 13069 APFloat(A.getSemantics(), A.isInfinity() ? 1 : 0), A); 13070 B = APFloat::copySign( 13071 APFloat(B.getSemantics(), B.isInfinity() ? 1 : 0), B); 13072 ResR = APFloat::getInf(ResR.getSemantics()) * (A * C + B * D); 13073 ResI = APFloat::getInf(ResI.getSemantics()) * (B * C - A * D); 13074 } else if (MaxCD.isInfinity() && A.isFinite() && B.isFinite()) { 13075 C = APFloat::copySign( 13076 APFloat(C.getSemantics(), C.isInfinity() ? 1 : 0), C); 13077 D = APFloat::copySign( 13078 APFloat(D.getSemantics(), D.isInfinity() ? 1 : 0), D); 13079 ResR = APFloat::getZero(ResR.getSemantics()) * (A * C + B * D); 13080 ResI = APFloat::getZero(ResI.getSemantics()) * (B * C - A * D); 13081 } 13082 } 13083 } 13084 } else { 13085 if (RHS.getComplexIntReal() == 0 && RHS.getComplexIntImag() == 0) 13086 return Error(E, diag::note_expr_divide_by_zero); 13087 13088 ComplexValue LHS = Result; 13089 APSInt Den = RHS.getComplexIntReal() * RHS.getComplexIntReal() + 13090 RHS.getComplexIntImag() * RHS.getComplexIntImag(); 13091 Result.getComplexIntReal() = 13092 (LHS.getComplexIntReal() * RHS.getComplexIntReal() + 13093 LHS.getComplexIntImag() * RHS.getComplexIntImag()) / Den; 13094 Result.getComplexIntImag() = 13095 (LHS.getComplexIntImag() * RHS.getComplexIntReal() - 13096 LHS.getComplexIntReal() * RHS.getComplexIntImag()) / Den; 13097 } 13098 break; 13099 } 13100 13101 return true; 13102 } 13103 13104 bool ComplexExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) { 13105 // Get the operand value into 'Result'. 13106 if (!Visit(E->getSubExpr())) 13107 return false; 13108 13109 switch (E->getOpcode()) { 13110 default: 13111 return Error(E); 13112 case UO_Extension: 13113 return true; 13114 case UO_Plus: 13115 // The result is always just the subexpr. 13116 return true; 13117 case UO_Minus: 13118 if (Result.isComplexFloat()) { 13119 Result.getComplexFloatReal().changeSign(); 13120 Result.getComplexFloatImag().changeSign(); 13121 } 13122 else { 13123 Result.getComplexIntReal() = -Result.getComplexIntReal(); 13124 Result.getComplexIntImag() = -Result.getComplexIntImag(); 13125 } 13126 return true; 13127 case UO_Not: 13128 if (Result.isComplexFloat()) 13129 Result.getComplexFloatImag().changeSign(); 13130 else 13131 Result.getComplexIntImag() = -Result.getComplexIntImag(); 13132 return true; 13133 } 13134 } 13135 13136 bool ComplexExprEvaluator::VisitInitListExpr(const InitListExpr *E) { 13137 if (E->getNumInits() == 2) { 13138 if (E->getType()->isComplexType()) { 13139 Result.makeComplexFloat(); 13140 if (!EvaluateFloat(E->getInit(0), Result.FloatReal, Info)) 13141 return false; 13142 if (!EvaluateFloat(E->getInit(1), Result.FloatImag, Info)) 13143 return false; 13144 } else { 13145 Result.makeComplexInt(); 13146 if (!EvaluateInteger(E->getInit(0), Result.IntReal, Info)) 13147 return false; 13148 if (!EvaluateInteger(E->getInit(1), Result.IntImag, Info)) 13149 return false; 13150 } 13151 return true; 13152 } 13153 return ExprEvaluatorBaseTy::VisitInitListExpr(E); 13154 } 13155 13156 //===----------------------------------------------------------------------===// 13157 // Atomic expression evaluation, essentially just handling the NonAtomicToAtomic 13158 // implicit conversion. 13159 //===----------------------------------------------------------------------===// 13160 13161 namespace { 13162 class AtomicExprEvaluator : 13163 public ExprEvaluatorBase<AtomicExprEvaluator> { 13164 const LValue *This; 13165 APValue &Result; 13166 public: 13167 AtomicExprEvaluator(EvalInfo &Info, const LValue *This, APValue &Result) 13168 : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {} 13169 13170 bool Success(const APValue &V, const Expr *E) { 13171 Result = V; 13172 return true; 13173 } 13174 13175 bool ZeroInitialization(const Expr *E) { 13176 ImplicitValueInitExpr VIE( 13177 E->getType()->castAs<AtomicType>()->getValueType()); 13178 // For atomic-qualified class (and array) types in C++, initialize the 13179 // _Atomic-wrapped subobject directly, in-place. 13180 return This ? EvaluateInPlace(Result, Info, *This, &VIE) 13181 : Evaluate(Result, Info, &VIE); 13182 } 13183 13184 bool VisitCastExpr(const CastExpr *E) { 13185 switch (E->getCastKind()) { 13186 default: 13187 return ExprEvaluatorBaseTy::VisitCastExpr(E); 13188 case CK_NonAtomicToAtomic: 13189 return This ? EvaluateInPlace(Result, Info, *This, E->getSubExpr()) 13190 : Evaluate(Result, Info, E->getSubExpr()); 13191 } 13192 } 13193 }; 13194 } // end anonymous namespace 13195 13196 static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result, 13197 EvalInfo &Info) { 13198 assert(E->isRValue() && E->getType()->isAtomicType()); 13199 return AtomicExprEvaluator(Info, This, Result).Visit(E); 13200 } 13201 13202 //===----------------------------------------------------------------------===// 13203 // Void expression evaluation, primarily for a cast to void on the LHS of a 13204 // comma operator 13205 //===----------------------------------------------------------------------===// 13206 13207 namespace { 13208 class VoidExprEvaluator 13209 : public ExprEvaluatorBase<VoidExprEvaluator> { 13210 public: 13211 VoidExprEvaluator(EvalInfo &Info) : ExprEvaluatorBaseTy(Info) {} 13212 13213 bool Success(const APValue &V, const Expr *e) { return true; } 13214 13215 bool ZeroInitialization(const Expr *E) { return true; } 13216 13217 bool VisitCastExpr(const CastExpr *E) { 13218 switch (E->getCastKind()) { 13219 default: 13220 return ExprEvaluatorBaseTy::VisitCastExpr(E); 13221 case CK_ToVoid: 13222 VisitIgnoredValue(E->getSubExpr()); 13223 return true; 13224 } 13225 } 13226 13227 bool VisitCallExpr(const CallExpr *E) { 13228 switch (E->getBuiltinCallee()) { 13229 case Builtin::BI__assume: 13230 case Builtin::BI__builtin_assume: 13231 // The argument is not evaluated! 13232 return true; 13233 13234 case Builtin::BI__builtin_operator_delete: 13235 return HandleOperatorDeleteCall(Info, E); 13236 13237 default: 13238 break; 13239 } 13240 13241 return ExprEvaluatorBaseTy::VisitCallExpr(E); 13242 } 13243 13244 bool VisitCXXDeleteExpr(const CXXDeleteExpr *E); 13245 }; 13246 } // end anonymous namespace 13247 13248 bool VoidExprEvaluator::VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 13249 // We cannot speculatively evaluate a delete expression. 13250 if (Info.SpeculativeEvaluationDepth) 13251 return false; 13252 13253 FunctionDecl *OperatorDelete = E->getOperatorDelete(); 13254 if (!OperatorDelete->isReplaceableGlobalAllocationFunction()) { 13255 Info.FFDiag(E, diag::note_constexpr_new_non_replaceable) 13256 << isa<CXXMethodDecl>(OperatorDelete) << OperatorDelete; 13257 return false; 13258 } 13259 13260 const Expr *Arg = E->getArgument(); 13261 13262 LValue Pointer; 13263 if (!EvaluatePointer(Arg, Pointer, Info)) 13264 return false; 13265 if (Pointer.Designator.Invalid) 13266 return false; 13267 13268 // Deleting a null pointer has no effect. 13269 if (Pointer.isNullPointer()) { 13270 // This is the only case where we need to produce an extension warning: 13271 // the only other way we can succeed is if we find a dynamic allocation, 13272 // and we will have warned when we allocated it in that case. 13273 if (!Info.getLangOpts().CPlusPlus2a) 13274 Info.CCEDiag(E, diag::note_constexpr_new); 13275 return true; 13276 } 13277 13278 Optional<DynAlloc *> Alloc = CheckDeleteKind( 13279 Info, E, Pointer, E->isArrayForm() ? DynAlloc::ArrayNew : DynAlloc::New); 13280 if (!Alloc) 13281 return false; 13282 QualType AllocType = Pointer.Base.getDynamicAllocType(); 13283 13284 // For the non-array case, the designator must be empty if the static type 13285 // does not have a virtual destructor. 13286 if (!E->isArrayForm() && Pointer.Designator.Entries.size() != 0 && 13287 !hasVirtualDestructor(Arg->getType()->getPointeeType())) { 13288 Info.FFDiag(E, diag::note_constexpr_delete_base_nonvirt_dtor) 13289 << Arg->getType()->getPointeeType() << AllocType; 13290 return false; 13291 } 13292 13293 // For a class type with a virtual destructor, the selected operator delete 13294 // is the one looked up when building the destructor. 13295 if (!E->isArrayForm() && !E->isGlobalDelete()) { 13296 const FunctionDecl *VirtualDelete = getVirtualOperatorDelete(AllocType); 13297 if (VirtualDelete && 13298 !VirtualDelete->isReplaceableGlobalAllocationFunction()) { 13299 Info.FFDiag(E, diag::note_constexpr_new_non_replaceable) 13300 << isa<CXXMethodDecl>(VirtualDelete) << VirtualDelete; 13301 return false; 13302 } 13303 } 13304 13305 if (!HandleDestruction(Info, E->getExprLoc(), Pointer.getLValueBase(), 13306 (*Alloc)->Value, AllocType)) 13307 return false; 13308 13309 if (!Info.HeapAllocs.erase(Pointer.Base.dyn_cast<DynamicAllocLValue>())) { 13310 // The element was already erased. This means the destructor call also 13311 // deleted the object. 13312 // FIXME: This probably results in undefined behavior before we get this 13313 // far, and should be diagnosed elsewhere first. 13314 Info.FFDiag(E, diag::note_constexpr_double_delete); 13315 return false; 13316 } 13317 13318 return true; 13319 } 13320 13321 static bool EvaluateVoid(const Expr *E, EvalInfo &Info) { 13322 assert(E->isRValue() && E->getType()->isVoidType()); 13323 return VoidExprEvaluator(Info).Visit(E); 13324 } 13325 13326 //===----------------------------------------------------------------------===// 13327 // Top level Expr::EvaluateAsRValue method. 13328 //===----------------------------------------------------------------------===// 13329 13330 static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) { 13331 // In C, function designators are not lvalues, but we evaluate them as if they 13332 // are. 13333 QualType T = E->getType(); 13334 if (E->isGLValue() || T->isFunctionType()) { 13335 LValue LV; 13336 if (!EvaluateLValue(E, LV, Info)) 13337 return false; 13338 LV.moveInto(Result); 13339 } else if (T->isVectorType()) { 13340 if (!EvaluateVector(E, Result, Info)) 13341 return false; 13342 } else if (T->isIntegralOrEnumerationType()) { 13343 if (!IntExprEvaluator(Info, Result).Visit(E)) 13344 return false; 13345 } else if (T->hasPointerRepresentation()) { 13346 LValue LV; 13347 if (!EvaluatePointer(E, LV, Info)) 13348 return false; 13349 LV.moveInto(Result); 13350 } else if (T->isRealFloatingType()) { 13351 llvm::APFloat F(0.0); 13352 if (!EvaluateFloat(E, F, Info)) 13353 return false; 13354 Result = APValue(F); 13355 } else if (T->isAnyComplexType()) { 13356 ComplexValue C; 13357 if (!EvaluateComplex(E, C, Info)) 13358 return false; 13359 C.moveInto(Result); 13360 } else if (T->isFixedPointType()) { 13361 if (!FixedPointExprEvaluator(Info, Result).Visit(E)) return false; 13362 } else if (T->isMemberPointerType()) { 13363 MemberPtr P; 13364 if (!EvaluateMemberPointer(E, P, Info)) 13365 return false; 13366 P.moveInto(Result); 13367 return true; 13368 } else if (T->isArrayType()) { 13369 LValue LV; 13370 APValue &Value = 13371 Info.CurrentCall->createTemporary(E, T, false, LV); 13372 if (!EvaluateArray(E, LV, Value, Info)) 13373 return false; 13374 Result = Value; 13375 } else if (T->isRecordType()) { 13376 LValue LV; 13377 APValue &Value = Info.CurrentCall->createTemporary(E, T, false, LV); 13378 if (!EvaluateRecord(E, LV, Value, Info)) 13379 return false; 13380 Result = Value; 13381 } else if (T->isVoidType()) { 13382 if (!Info.getLangOpts().CPlusPlus11) 13383 Info.CCEDiag(E, diag::note_constexpr_nonliteral) 13384 << E->getType(); 13385 if (!EvaluateVoid(E, Info)) 13386 return false; 13387 } else if (T->isAtomicType()) { 13388 QualType Unqual = T.getAtomicUnqualifiedType(); 13389 if (Unqual->isArrayType() || Unqual->isRecordType()) { 13390 LValue LV; 13391 APValue &Value = Info.CurrentCall->createTemporary(E, Unqual, false, LV); 13392 if (!EvaluateAtomic(E, &LV, Value, Info)) 13393 return false; 13394 } else { 13395 if (!EvaluateAtomic(E, nullptr, Result, Info)) 13396 return false; 13397 } 13398 } else if (Info.getLangOpts().CPlusPlus11) { 13399 Info.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType(); 13400 return false; 13401 } else { 13402 Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr); 13403 return false; 13404 } 13405 13406 return true; 13407 } 13408 13409 /// EvaluateInPlace - Evaluate an expression in-place in an APValue. In some 13410 /// cases, the in-place evaluation is essential, since later initializers for 13411 /// an object can indirectly refer to subobjects which were initialized earlier. 13412 static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This, 13413 const Expr *E, bool AllowNonLiteralTypes) { 13414 assert(!E->isValueDependent()); 13415 13416 if (!AllowNonLiteralTypes && !CheckLiteralType(Info, E, &This)) 13417 return false; 13418 13419 if (E->isRValue()) { 13420 // Evaluate arrays and record types in-place, so that later initializers can 13421 // refer to earlier-initialized members of the object. 13422 QualType T = E->getType(); 13423 if (T->isArrayType()) 13424 return EvaluateArray(E, This, Result, Info); 13425 else if (T->isRecordType()) 13426 return EvaluateRecord(E, This, Result, Info); 13427 else if (T->isAtomicType()) { 13428 QualType Unqual = T.getAtomicUnqualifiedType(); 13429 if (Unqual->isArrayType() || Unqual->isRecordType()) 13430 return EvaluateAtomic(E, &This, Result, Info); 13431 } 13432 } 13433 13434 // For any other type, in-place evaluation is unimportant. 13435 return Evaluate(Result, Info, E); 13436 } 13437 13438 /// EvaluateAsRValue - Try to evaluate this expression, performing an implicit 13439 /// lvalue-to-rvalue cast if it is an lvalue. 13440 static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) { 13441 if (Info.EnableNewConstInterp) { 13442 if (!Info.Ctx.getInterpContext().evaluateAsRValue(Info, E, Result)) 13443 return false; 13444 } else { 13445 if (E->getType().isNull()) 13446 return false; 13447 13448 if (!CheckLiteralType(Info, E)) 13449 return false; 13450 13451 if (!::Evaluate(Result, Info, E)) 13452 return false; 13453 13454 if (E->isGLValue()) { 13455 LValue LV; 13456 LV.setFrom(Info.Ctx, Result); 13457 if (!handleLValueToRValueConversion(Info, E, E->getType(), LV, Result)) 13458 return false; 13459 } 13460 } 13461 13462 // Check this core constant expression is a constant expression. 13463 return CheckConstantExpression(Info, E->getExprLoc(), E->getType(), Result) && 13464 CheckMemoryLeaks(Info); 13465 } 13466 13467 static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result, 13468 const ASTContext &Ctx, bool &IsConst) { 13469 // Fast-path evaluations of integer literals, since we sometimes see files 13470 // containing vast quantities of these. 13471 if (const IntegerLiteral *L = dyn_cast<IntegerLiteral>(Exp)) { 13472 Result.Val = APValue(APSInt(L->getValue(), 13473 L->getType()->isUnsignedIntegerType())); 13474 IsConst = true; 13475 return true; 13476 } 13477 13478 // This case should be rare, but we need to check it before we check on 13479 // the type below. 13480 if (Exp->getType().isNull()) { 13481 IsConst = false; 13482 return true; 13483 } 13484 13485 // FIXME: Evaluating values of large array and record types can cause 13486 // performance problems. Only do so in C++11 for now. 13487 if (Exp->isRValue() && (Exp->getType()->isArrayType() || 13488 Exp->getType()->isRecordType()) && 13489 !Ctx.getLangOpts().CPlusPlus11) { 13490 IsConst = false; 13491 return true; 13492 } 13493 return false; 13494 } 13495 13496 static bool hasUnacceptableSideEffect(Expr::EvalStatus &Result, 13497 Expr::SideEffectsKind SEK) { 13498 return (SEK < Expr::SE_AllowSideEffects && Result.HasSideEffects) || 13499 (SEK < Expr::SE_AllowUndefinedBehavior && Result.HasUndefinedBehavior); 13500 } 13501 13502 static bool EvaluateAsRValue(const Expr *E, Expr::EvalResult &Result, 13503 const ASTContext &Ctx, EvalInfo &Info) { 13504 bool IsConst; 13505 if (FastEvaluateAsRValue(E, Result, Ctx, IsConst)) 13506 return IsConst; 13507 13508 return EvaluateAsRValue(Info, E, Result.Val); 13509 } 13510 13511 static bool EvaluateAsInt(const Expr *E, Expr::EvalResult &ExprResult, 13512 const ASTContext &Ctx, 13513 Expr::SideEffectsKind AllowSideEffects, 13514 EvalInfo &Info) { 13515 if (!E->getType()->isIntegralOrEnumerationType()) 13516 return false; 13517 13518 if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info) || 13519 !ExprResult.Val.isInt() || 13520 hasUnacceptableSideEffect(ExprResult, AllowSideEffects)) 13521 return false; 13522 13523 return true; 13524 } 13525 13526 static bool EvaluateAsFixedPoint(const Expr *E, Expr::EvalResult &ExprResult, 13527 const ASTContext &Ctx, 13528 Expr::SideEffectsKind AllowSideEffects, 13529 EvalInfo &Info) { 13530 if (!E->getType()->isFixedPointType()) 13531 return false; 13532 13533 if (!::EvaluateAsRValue(E, ExprResult, Ctx, Info)) 13534 return false; 13535 13536 if (!ExprResult.Val.isFixedPoint() || 13537 hasUnacceptableSideEffect(ExprResult, AllowSideEffects)) 13538 return false; 13539 13540 return true; 13541 } 13542 13543 /// EvaluateAsRValue - Return true if this is a constant which we can fold using 13544 /// any crazy technique (that has nothing to do with language standards) that 13545 /// we want to. If this function returns true, it returns the folded constant 13546 /// in Result. If this expression is a glvalue, an lvalue-to-rvalue conversion 13547 /// will be applied to the result. 13548 bool Expr::EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, 13549 bool InConstantContext) const { 13550 assert(!isValueDependent() && 13551 "Expression evaluator can't be called on a dependent expression."); 13552 EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects); 13553 Info.InConstantContext = InConstantContext; 13554 return ::EvaluateAsRValue(this, Result, Ctx, Info); 13555 } 13556 13557 bool Expr::EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx, 13558 bool InConstantContext) const { 13559 assert(!isValueDependent() && 13560 "Expression evaluator can't be called on a dependent expression."); 13561 EvalResult Scratch; 13562 return EvaluateAsRValue(Scratch, Ctx, InConstantContext) && 13563 HandleConversionToBool(Scratch.Val, Result); 13564 } 13565 13566 bool Expr::EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, 13567 SideEffectsKind AllowSideEffects, 13568 bool InConstantContext) const { 13569 assert(!isValueDependent() && 13570 "Expression evaluator can't be called on a dependent expression."); 13571 EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects); 13572 Info.InConstantContext = InConstantContext; 13573 return ::EvaluateAsInt(this, Result, Ctx, AllowSideEffects, Info); 13574 } 13575 13576 bool Expr::EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx, 13577 SideEffectsKind AllowSideEffects, 13578 bool InConstantContext) const { 13579 assert(!isValueDependent() && 13580 "Expression evaluator can't be called on a dependent expression."); 13581 EvalInfo Info(Ctx, Result, EvalInfo::EM_IgnoreSideEffects); 13582 Info.InConstantContext = InConstantContext; 13583 return ::EvaluateAsFixedPoint(this, Result, Ctx, AllowSideEffects, Info); 13584 } 13585 13586 bool Expr::EvaluateAsFloat(APFloat &Result, const ASTContext &Ctx, 13587 SideEffectsKind AllowSideEffects, 13588 bool InConstantContext) const { 13589 assert(!isValueDependent() && 13590 "Expression evaluator can't be called on a dependent expression."); 13591 13592 if (!getType()->isRealFloatingType()) 13593 return false; 13594 13595 EvalResult ExprResult; 13596 if (!EvaluateAsRValue(ExprResult, Ctx, InConstantContext) || 13597 !ExprResult.Val.isFloat() || 13598 hasUnacceptableSideEffect(ExprResult, AllowSideEffects)) 13599 return false; 13600 13601 Result = ExprResult.Val.getFloat(); 13602 return true; 13603 } 13604 13605 bool Expr::EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx, 13606 bool InConstantContext) const { 13607 assert(!isValueDependent() && 13608 "Expression evaluator can't be called on a dependent expression."); 13609 13610 EvalInfo Info(Ctx, Result, EvalInfo::EM_ConstantFold); 13611 Info.InConstantContext = InConstantContext; 13612 LValue LV; 13613 CheckedTemporaries CheckedTemps; 13614 if (!EvaluateLValue(this, LV, Info) || !Info.discardCleanups() || 13615 Result.HasSideEffects || 13616 !CheckLValueConstantExpression(Info, getExprLoc(), 13617 Ctx.getLValueReferenceType(getType()), LV, 13618 Expr::EvaluateForCodeGen, CheckedTemps)) 13619 return false; 13620 13621 LV.moveInto(Result.Val); 13622 return true; 13623 } 13624 13625 bool Expr::EvaluateAsConstantExpr(EvalResult &Result, ConstExprUsage Usage, 13626 const ASTContext &Ctx) const { 13627 assert(!isValueDependent() && 13628 "Expression evaluator can't be called on a dependent expression."); 13629 13630 EvalInfo::EvaluationMode EM = EvalInfo::EM_ConstantExpression; 13631 EvalInfo Info(Ctx, Result, EM); 13632 Info.InConstantContext = true; 13633 13634 if (!::Evaluate(Result.Val, Info, this) || Result.HasSideEffects) 13635 return false; 13636 13637 if (!Info.discardCleanups()) 13638 llvm_unreachable("Unhandled cleanup; missing full expression marker?"); 13639 13640 return CheckConstantExpression(Info, getExprLoc(), getStorageType(Ctx, this), 13641 Result.Val, Usage) && 13642 CheckMemoryLeaks(Info); 13643 } 13644 13645 bool Expr::EvaluateAsInitializer(APValue &Value, const ASTContext &Ctx, 13646 const VarDecl *VD, 13647 SmallVectorImpl<PartialDiagnosticAt> &Notes) const { 13648 assert(!isValueDependent() && 13649 "Expression evaluator can't be called on a dependent expression."); 13650 13651 // FIXME: Evaluating initializers for large array and record types can cause 13652 // performance problems. Only do so in C++11 for now. 13653 if (isRValue() && (getType()->isArrayType() || getType()->isRecordType()) && 13654 !Ctx.getLangOpts().CPlusPlus11) 13655 return false; 13656 13657 Expr::EvalStatus EStatus; 13658 EStatus.Diag = &Notes; 13659 13660 EvalInfo Info(Ctx, EStatus, VD->isConstexpr() 13661 ? EvalInfo::EM_ConstantExpression 13662 : EvalInfo::EM_ConstantFold); 13663 Info.setEvaluatingDecl(VD, Value); 13664 Info.InConstantContext = true; 13665 13666 SourceLocation DeclLoc = VD->getLocation(); 13667 QualType DeclTy = VD->getType(); 13668 13669 if (Info.EnableNewConstInterp) { 13670 auto &InterpCtx = const_cast<ASTContext &>(Ctx).getInterpContext(); 13671 if (!InterpCtx.evaluateAsInitializer(Info, VD, Value)) 13672 return false; 13673 } else { 13674 LValue LVal; 13675 LVal.set(VD); 13676 13677 // C++11 [basic.start.init]p2: 13678 // Variables with static storage duration or thread storage duration shall 13679 // be zero-initialized before any other initialization takes place. 13680 // This behavior is not present in C. 13681 if (Ctx.getLangOpts().CPlusPlus && !VD->hasLocalStorage() && 13682 !DeclTy->isReferenceType()) { 13683 ImplicitValueInitExpr VIE(DeclTy); 13684 if (!EvaluateInPlace(Value, Info, LVal, &VIE, 13685 /*AllowNonLiteralTypes=*/true)) 13686 return false; 13687 } 13688 13689 if (!EvaluateInPlace(Value, Info, LVal, this, 13690 /*AllowNonLiteralTypes=*/true) || 13691 EStatus.HasSideEffects) 13692 return false; 13693 13694 // At this point, any lifetime-extended temporaries are completely 13695 // initialized. 13696 Info.performLifetimeExtension(); 13697 13698 if (!Info.discardCleanups()) 13699 llvm_unreachable("Unhandled cleanup; missing full expression marker?"); 13700 } 13701 return CheckConstantExpression(Info, DeclLoc, DeclTy, Value) && 13702 CheckMemoryLeaks(Info); 13703 } 13704 13705 bool VarDecl::evaluateDestruction( 13706 SmallVectorImpl<PartialDiagnosticAt> &Notes) const { 13707 assert(getEvaluatedValue() && !getEvaluatedValue()->isAbsent() && 13708 "cannot evaluate destruction of non-constant-initialized variable"); 13709 13710 Expr::EvalStatus EStatus; 13711 EStatus.Diag = &Notes; 13712 13713 // Make a copy of the value for the destructor to mutate. 13714 APValue DestroyedValue = *getEvaluatedValue(); 13715 13716 EvalInfo Info(getASTContext(), EStatus, EvalInfo::EM_ConstantExpression); 13717 Info.setEvaluatingDecl(this, DestroyedValue, 13718 EvalInfo::EvaluatingDeclKind::Dtor); 13719 Info.InConstantContext = true; 13720 13721 SourceLocation DeclLoc = getLocation(); 13722 QualType DeclTy = getType(); 13723 13724 LValue LVal; 13725 LVal.set(this); 13726 13727 // FIXME: Consider storing whether this variable has constant destruction in 13728 // the EvaluatedStmt so that CodeGen can query it. 13729 if (!HandleDestruction(Info, DeclLoc, LVal.Base, DestroyedValue, DeclTy) || 13730 EStatus.HasSideEffects) 13731 return false; 13732 13733 if (!Info.discardCleanups()) 13734 llvm_unreachable("Unhandled cleanup; missing full expression marker?"); 13735 13736 ensureEvaluatedStmt()->HasConstantDestruction = true; 13737 return true; 13738 } 13739 13740 /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be 13741 /// constant folded, but discard the result. 13742 bool Expr::isEvaluatable(const ASTContext &Ctx, SideEffectsKind SEK) const { 13743 assert(!isValueDependent() && 13744 "Expression evaluator can't be called on a dependent expression."); 13745 13746 EvalResult Result; 13747 return EvaluateAsRValue(Result, Ctx, /* in constant context */ true) && 13748 !hasUnacceptableSideEffect(Result, SEK); 13749 } 13750 13751 APSInt Expr::EvaluateKnownConstInt(const ASTContext &Ctx, 13752 SmallVectorImpl<PartialDiagnosticAt> *Diag) const { 13753 assert(!isValueDependent() && 13754 "Expression evaluator can't be called on a dependent expression."); 13755 13756 EvalResult EVResult; 13757 EVResult.Diag = Diag; 13758 EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects); 13759 Info.InConstantContext = true; 13760 13761 bool Result = ::EvaluateAsRValue(this, EVResult, Ctx, Info); 13762 (void)Result; 13763 assert(Result && "Could not evaluate expression"); 13764 assert(EVResult.Val.isInt() && "Expression did not evaluate to integer"); 13765 13766 return EVResult.Val.getInt(); 13767 } 13768 13769 APSInt Expr::EvaluateKnownConstIntCheckOverflow( 13770 const ASTContext &Ctx, SmallVectorImpl<PartialDiagnosticAt> *Diag) const { 13771 assert(!isValueDependent() && 13772 "Expression evaluator can't be called on a dependent expression."); 13773 13774 EvalResult EVResult; 13775 EVResult.Diag = Diag; 13776 EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects); 13777 Info.InConstantContext = true; 13778 Info.CheckingForUndefinedBehavior = true; 13779 13780 bool Result = ::EvaluateAsRValue(Info, this, EVResult.Val); 13781 (void)Result; 13782 assert(Result && "Could not evaluate expression"); 13783 assert(EVResult.Val.isInt() && "Expression did not evaluate to integer"); 13784 13785 return EVResult.Val.getInt(); 13786 } 13787 13788 void Expr::EvaluateForOverflow(const ASTContext &Ctx) const { 13789 assert(!isValueDependent() && 13790 "Expression evaluator can't be called on a dependent expression."); 13791 13792 bool IsConst; 13793 EvalResult EVResult; 13794 if (!FastEvaluateAsRValue(this, EVResult, Ctx, IsConst)) { 13795 EvalInfo Info(Ctx, EVResult, EvalInfo::EM_IgnoreSideEffects); 13796 Info.CheckingForUndefinedBehavior = true; 13797 (void)::EvaluateAsRValue(Info, this, EVResult.Val); 13798 } 13799 } 13800 13801 bool Expr::EvalResult::isGlobalLValue() const { 13802 assert(Val.isLValue()); 13803 return IsGlobalLValue(Val.getLValueBase()); 13804 } 13805 13806 13807 /// isIntegerConstantExpr - this recursive routine will test if an expression is 13808 /// an integer constant expression. 13809 13810 /// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 13811 /// comma, etc 13812 13813 // CheckICE - This function does the fundamental ICE checking: the returned 13814 // ICEDiag contains an ICEKind indicating whether the expression is an ICE, 13815 // and a (possibly null) SourceLocation indicating the location of the problem. 13816 // 13817 // Note that to reduce code duplication, this helper does no evaluation 13818 // itself; the caller checks whether the expression is evaluatable, and 13819 // in the rare cases where CheckICE actually cares about the evaluated 13820 // value, it calls into Evaluate. 13821 13822 namespace { 13823 13824 enum ICEKind { 13825 /// This expression is an ICE. 13826 IK_ICE, 13827 /// This expression is not an ICE, but if it isn't evaluated, it's 13828 /// a legal subexpression for an ICE. This return value is used to handle 13829 /// the comma operator in C99 mode, and non-constant subexpressions. 13830 IK_ICEIfUnevaluated, 13831 /// This expression is not an ICE, and is not a legal subexpression for one. 13832 IK_NotICE 13833 }; 13834 13835 struct ICEDiag { 13836 ICEKind Kind; 13837 SourceLocation Loc; 13838 13839 ICEDiag(ICEKind IK, SourceLocation l) : Kind(IK), Loc(l) {} 13840 }; 13841 13842 } 13843 13844 static ICEDiag NoDiag() { return ICEDiag(IK_ICE, SourceLocation()); } 13845 13846 static ICEDiag Worst(ICEDiag A, ICEDiag B) { return A.Kind >= B.Kind ? A : B; } 13847 13848 static ICEDiag CheckEvalInICE(const Expr* E, const ASTContext &Ctx) { 13849 Expr::EvalResult EVResult; 13850 Expr::EvalStatus Status; 13851 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression); 13852 13853 Info.InConstantContext = true; 13854 if (!::EvaluateAsRValue(E, EVResult, Ctx, Info) || EVResult.HasSideEffects || 13855 !EVResult.Val.isInt()) 13856 return ICEDiag(IK_NotICE, E->getBeginLoc()); 13857 13858 return NoDiag(); 13859 } 13860 13861 static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) { 13862 assert(!E->isValueDependent() && "Should not see value dependent exprs!"); 13863 if (!E->getType()->isIntegralOrEnumerationType()) 13864 return ICEDiag(IK_NotICE, E->getBeginLoc()); 13865 13866 switch (E->getStmtClass()) { 13867 #define ABSTRACT_STMT(Node) 13868 #define STMT(Node, Base) case Expr::Node##Class: 13869 #define EXPR(Node, Base) 13870 #include "clang/AST/StmtNodes.inc" 13871 case Expr::PredefinedExprClass: 13872 case Expr::FloatingLiteralClass: 13873 case Expr::ImaginaryLiteralClass: 13874 case Expr::StringLiteralClass: 13875 case Expr::ArraySubscriptExprClass: 13876 case Expr::OMPArraySectionExprClass: 13877 case Expr::MemberExprClass: 13878 case Expr::CompoundAssignOperatorClass: 13879 case Expr::CompoundLiteralExprClass: 13880 case Expr::ExtVectorElementExprClass: 13881 case Expr::DesignatedInitExprClass: 13882 case Expr::ArrayInitLoopExprClass: 13883 case Expr::ArrayInitIndexExprClass: 13884 case Expr::NoInitExprClass: 13885 case Expr::DesignatedInitUpdateExprClass: 13886 case Expr::ImplicitValueInitExprClass: 13887 case Expr::ParenListExprClass: 13888 case Expr::VAArgExprClass: 13889 case Expr::AddrLabelExprClass: 13890 case Expr::StmtExprClass: 13891 case Expr::CXXMemberCallExprClass: 13892 case Expr::CUDAKernelCallExprClass: 13893 case Expr::CXXDynamicCastExprClass: 13894 case Expr::CXXTypeidExprClass: 13895 case Expr::CXXUuidofExprClass: 13896 case Expr::MSPropertyRefExprClass: 13897 case Expr::MSPropertySubscriptExprClass: 13898 case Expr::CXXNullPtrLiteralExprClass: 13899 case Expr::UserDefinedLiteralClass: 13900 case Expr::CXXThisExprClass: 13901 case Expr::CXXThrowExprClass: 13902 case Expr::CXXNewExprClass: 13903 case Expr::CXXDeleteExprClass: 13904 case Expr::CXXPseudoDestructorExprClass: 13905 case Expr::UnresolvedLookupExprClass: 13906 case Expr::TypoExprClass: 13907 case Expr::DependentScopeDeclRefExprClass: 13908 case Expr::CXXConstructExprClass: 13909 case Expr::CXXInheritedCtorInitExprClass: 13910 case Expr::CXXStdInitializerListExprClass: 13911 case Expr::CXXBindTemporaryExprClass: 13912 case Expr::ExprWithCleanupsClass: 13913 case Expr::CXXTemporaryObjectExprClass: 13914 case Expr::CXXUnresolvedConstructExprClass: 13915 case Expr::CXXDependentScopeMemberExprClass: 13916 case Expr::UnresolvedMemberExprClass: 13917 case Expr::ObjCStringLiteralClass: 13918 case Expr::ObjCBoxedExprClass: 13919 case Expr::ObjCArrayLiteralClass: 13920 case Expr::ObjCDictionaryLiteralClass: 13921 case Expr::ObjCEncodeExprClass: 13922 case Expr::ObjCMessageExprClass: 13923 case Expr::ObjCSelectorExprClass: 13924 case Expr::ObjCProtocolExprClass: 13925 case Expr::ObjCIvarRefExprClass: 13926 case Expr::ObjCPropertyRefExprClass: 13927 case Expr::ObjCSubscriptRefExprClass: 13928 case Expr::ObjCIsaExprClass: 13929 case Expr::ObjCAvailabilityCheckExprClass: 13930 case Expr::ShuffleVectorExprClass: 13931 case Expr::ConvertVectorExprClass: 13932 case Expr::BlockExprClass: 13933 case Expr::NoStmtClass: 13934 case Expr::OpaqueValueExprClass: 13935 case Expr::PackExpansionExprClass: 13936 case Expr::SubstNonTypeTemplateParmPackExprClass: 13937 case Expr::FunctionParmPackExprClass: 13938 case Expr::AsTypeExprClass: 13939 case Expr::ObjCIndirectCopyRestoreExprClass: 13940 case Expr::MaterializeTemporaryExprClass: 13941 case Expr::PseudoObjectExprClass: 13942 case Expr::AtomicExprClass: 13943 case Expr::LambdaExprClass: 13944 case Expr::CXXFoldExprClass: 13945 case Expr::CoawaitExprClass: 13946 case Expr::DependentCoawaitExprClass: 13947 case Expr::CoyieldExprClass: 13948 return ICEDiag(IK_NotICE, E->getBeginLoc()); 13949 13950 case Expr::InitListExprClass: { 13951 // C++03 [dcl.init]p13: If T is a scalar type, then a declaration of the 13952 // form "T x = { a };" is equivalent to "T x = a;". 13953 // Unless we're initializing a reference, T is a scalar as it is known to be 13954 // of integral or enumeration type. 13955 if (E->isRValue()) 13956 if (cast<InitListExpr>(E)->getNumInits() == 1) 13957 return CheckICE(cast<InitListExpr>(E)->getInit(0), Ctx); 13958 return ICEDiag(IK_NotICE, E->getBeginLoc()); 13959 } 13960 13961 case Expr::SizeOfPackExprClass: 13962 case Expr::GNUNullExprClass: 13963 case Expr::SourceLocExprClass: 13964 return NoDiag(); 13965 13966 case Expr::SubstNonTypeTemplateParmExprClass: 13967 return 13968 CheckICE(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), Ctx); 13969 13970 case Expr::ConstantExprClass: 13971 return CheckICE(cast<ConstantExpr>(E)->getSubExpr(), Ctx); 13972 13973 case Expr::ParenExprClass: 13974 return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx); 13975 case Expr::GenericSelectionExprClass: 13976 return CheckICE(cast<GenericSelectionExpr>(E)->getResultExpr(), Ctx); 13977 case Expr::IntegerLiteralClass: 13978 case Expr::FixedPointLiteralClass: 13979 case Expr::CharacterLiteralClass: 13980 case Expr::ObjCBoolLiteralExprClass: 13981 case Expr::CXXBoolLiteralExprClass: 13982 case Expr::CXXScalarValueInitExprClass: 13983 case Expr::TypeTraitExprClass: 13984 case Expr::ConceptSpecializationExprClass: 13985 case Expr::ArrayTypeTraitExprClass: 13986 case Expr::ExpressionTraitExprClass: 13987 case Expr::CXXNoexceptExprClass: 13988 return NoDiag(); 13989 case Expr::CallExprClass: 13990 case Expr::CXXOperatorCallExprClass: { 13991 // C99 6.6/3 allows function calls within unevaluated subexpressions of 13992 // constant expressions, but they can never be ICEs because an ICE cannot 13993 // contain an operand of (pointer to) function type. 13994 const CallExpr *CE = cast<CallExpr>(E); 13995 if (CE->getBuiltinCallee()) 13996 return CheckEvalInICE(E, Ctx); 13997 return ICEDiag(IK_NotICE, E->getBeginLoc()); 13998 } 13999 case Expr::CXXRewrittenBinaryOperatorClass: 14000 return CheckICE(cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm(), 14001 Ctx); 14002 case Expr::DeclRefExprClass: { 14003 if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl())) 14004 return NoDiag(); 14005 const ValueDecl *D = cast<DeclRefExpr>(E)->getDecl(); 14006 if (Ctx.getLangOpts().CPlusPlus && 14007 D && IsConstNonVolatile(D->getType())) { 14008 // Parameter variables are never constants. Without this check, 14009 // getAnyInitializer() can find a default argument, which leads 14010 // to chaos. 14011 if (isa<ParmVarDecl>(D)) 14012 return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation()); 14013 14014 // C++ 7.1.5.1p2 14015 // A variable of non-volatile const-qualified integral or enumeration 14016 // type initialized by an ICE can be used in ICEs. 14017 if (const VarDecl *Dcl = dyn_cast<VarDecl>(D)) { 14018 if (!Dcl->getType()->isIntegralOrEnumerationType()) 14019 return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation()); 14020 14021 const VarDecl *VD; 14022 // Look for a declaration of this variable that has an initializer, and 14023 // check whether it is an ICE. 14024 if (Dcl->getAnyInitializer(VD) && VD->checkInitIsICE()) 14025 return NoDiag(); 14026 else 14027 return ICEDiag(IK_NotICE, cast<DeclRefExpr>(E)->getLocation()); 14028 } 14029 } 14030 return ICEDiag(IK_NotICE, E->getBeginLoc()); 14031 } 14032 case Expr::UnaryOperatorClass: { 14033 const UnaryOperator *Exp = cast<UnaryOperator>(E); 14034 switch (Exp->getOpcode()) { 14035 case UO_PostInc: 14036 case UO_PostDec: 14037 case UO_PreInc: 14038 case UO_PreDec: 14039 case UO_AddrOf: 14040 case UO_Deref: 14041 case UO_Coawait: 14042 // C99 6.6/3 allows increment and decrement within unevaluated 14043 // subexpressions of constant expressions, but they can never be ICEs 14044 // because an ICE cannot contain an lvalue operand. 14045 return ICEDiag(IK_NotICE, E->getBeginLoc()); 14046 case UO_Extension: 14047 case UO_LNot: 14048 case UO_Plus: 14049 case UO_Minus: 14050 case UO_Not: 14051 case UO_Real: 14052 case UO_Imag: 14053 return CheckICE(Exp->getSubExpr(), Ctx); 14054 } 14055 llvm_unreachable("invalid unary operator class"); 14056 } 14057 case Expr::OffsetOfExprClass: { 14058 // Note that per C99, offsetof must be an ICE. And AFAIK, using 14059 // EvaluateAsRValue matches the proposed gcc behavior for cases like 14060 // "offsetof(struct s{int x[4];}, x[1.0])". This doesn't affect 14061 // compliance: we should warn earlier for offsetof expressions with 14062 // array subscripts that aren't ICEs, and if the array subscripts 14063 // are ICEs, the value of the offsetof must be an integer constant. 14064 return CheckEvalInICE(E, Ctx); 14065 } 14066 case Expr::UnaryExprOrTypeTraitExprClass: { 14067 const UnaryExprOrTypeTraitExpr *Exp = cast<UnaryExprOrTypeTraitExpr>(E); 14068 if ((Exp->getKind() == UETT_SizeOf) && 14069 Exp->getTypeOfArgument()->isVariableArrayType()) 14070 return ICEDiag(IK_NotICE, E->getBeginLoc()); 14071 return NoDiag(); 14072 } 14073 case Expr::BinaryOperatorClass: { 14074 const BinaryOperator *Exp = cast<BinaryOperator>(E); 14075 switch (Exp->getOpcode()) { 14076 case BO_PtrMemD: 14077 case BO_PtrMemI: 14078 case BO_Assign: 14079 case BO_MulAssign: 14080 case BO_DivAssign: 14081 case BO_RemAssign: 14082 case BO_AddAssign: 14083 case BO_SubAssign: 14084 case BO_ShlAssign: 14085 case BO_ShrAssign: 14086 case BO_AndAssign: 14087 case BO_XorAssign: 14088 case BO_OrAssign: 14089 // C99 6.6/3 allows assignments within unevaluated subexpressions of 14090 // constant expressions, but they can never be ICEs because an ICE cannot 14091 // contain an lvalue operand. 14092 return ICEDiag(IK_NotICE, E->getBeginLoc()); 14093 14094 case BO_Mul: 14095 case BO_Div: 14096 case BO_Rem: 14097 case BO_Add: 14098 case BO_Sub: 14099 case BO_Shl: 14100 case BO_Shr: 14101 case BO_LT: 14102 case BO_GT: 14103 case BO_LE: 14104 case BO_GE: 14105 case BO_EQ: 14106 case BO_NE: 14107 case BO_And: 14108 case BO_Xor: 14109 case BO_Or: 14110 case BO_Comma: 14111 case BO_Cmp: { 14112 ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 14113 ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 14114 if (Exp->getOpcode() == BO_Div || 14115 Exp->getOpcode() == BO_Rem) { 14116 // EvaluateAsRValue gives an error for undefined Div/Rem, so make sure 14117 // we don't evaluate one. 14118 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) { 14119 llvm::APSInt REval = Exp->getRHS()->EvaluateKnownConstInt(Ctx); 14120 if (REval == 0) 14121 return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc()); 14122 if (REval.isSigned() && REval.isAllOnesValue()) { 14123 llvm::APSInt LEval = Exp->getLHS()->EvaluateKnownConstInt(Ctx); 14124 if (LEval.isMinSignedValue()) 14125 return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc()); 14126 } 14127 } 14128 } 14129 if (Exp->getOpcode() == BO_Comma) { 14130 if (Ctx.getLangOpts().C99) { 14131 // C99 6.6p3 introduces a strange edge case: comma can be in an ICE 14132 // if it isn't evaluated. 14133 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) 14134 return ICEDiag(IK_ICEIfUnevaluated, E->getBeginLoc()); 14135 } else { 14136 // In both C89 and C++, commas in ICEs are illegal. 14137 return ICEDiag(IK_NotICE, E->getBeginLoc()); 14138 } 14139 } 14140 return Worst(LHSResult, RHSResult); 14141 } 14142 case BO_LAnd: 14143 case BO_LOr: { 14144 ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 14145 ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 14146 if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICEIfUnevaluated) { 14147 // Rare case where the RHS has a comma "side-effect"; we need 14148 // to actually check the condition to see whether the side 14149 // with the comma is evaluated. 14150 if ((Exp->getOpcode() == BO_LAnd) != 14151 (Exp->getLHS()->EvaluateKnownConstInt(Ctx) == 0)) 14152 return RHSResult; 14153 return NoDiag(); 14154 } 14155 14156 return Worst(LHSResult, RHSResult); 14157 } 14158 } 14159 llvm_unreachable("invalid binary operator kind"); 14160 } 14161 case Expr::ImplicitCastExprClass: 14162 case Expr::CStyleCastExprClass: 14163 case Expr::CXXFunctionalCastExprClass: 14164 case Expr::CXXStaticCastExprClass: 14165 case Expr::CXXReinterpretCastExprClass: 14166 case Expr::CXXConstCastExprClass: 14167 case Expr::ObjCBridgedCastExprClass: { 14168 const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr(); 14169 if (isa<ExplicitCastExpr>(E)) { 14170 if (const FloatingLiteral *FL 14171 = dyn_cast<FloatingLiteral>(SubExpr->IgnoreParenImpCasts())) { 14172 unsigned DestWidth = Ctx.getIntWidth(E->getType()); 14173 bool DestSigned = E->getType()->isSignedIntegerOrEnumerationType(); 14174 APSInt IgnoredVal(DestWidth, !DestSigned); 14175 bool Ignored; 14176 // If the value does not fit in the destination type, the behavior is 14177 // undefined, so we are not required to treat it as a constant 14178 // expression. 14179 if (FL->getValue().convertToInteger(IgnoredVal, 14180 llvm::APFloat::rmTowardZero, 14181 &Ignored) & APFloat::opInvalidOp) 14182 return ICEDiag(IK_NotICE, E->getBeginLoc()); 14183 return NoDiag(); 14184 } 14185 } 14186 switch (cast<CastExpr>(E)->getCastKind()) { 14187 case CK_LValueToRValue: 14188 case CK_AtomicToNonAtomic: 14189 case CK_NonAtomicToAtomic: 14190 case CK_NoOp: 14191 case CK_IntegralToBoolean: 14192 case CK_IntegralCast: 14193 return CheckICE(SubExpr, Ctx); 14194 default: 14195 return ICEDiag(IK_NotICE, E->getBeginLoc()); 14196 } 14197 } 14198 case Expr::BinaryConditionalOperatorClass: { 14199 const BinaryConditionalOperator *Exp = cast<BinaryConditionalOperator>(E); 14200 ICEDiag CommonResult = CheckICE(Exp->getCommon(), Ctx); 14201 if (CommonResult.Kind == IK_NotICE) return CommonResult; 14202 ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx); 14203 if (FalseResult.Kind == IK_NotICE) return FalseResult; 14204 if (CommonResult.Kind == IK_ICEIfUnevaluated) return CommonResult; 14205 if (FalseResult.Kind == IK_ICEIfUnevaluated && 14206 Exp->getCommon()->EvaluateKnownConstInt(Ctx) != 0) return NoDiag(); 14207 return FalseResult; 14208 } 14209 case Expr::ConditionalOperatorClass: { 14210 const ConditionalOperator *Exp = cast<ConditionalOperator>(E); 14211 // If the condition (ignoring parens) is a __builtin_constant_p call, 14212 // then only the true side is actually considered in an integer constant 14213 // expression, and it is fully evaluated. This is an important GNU 14214 // extension. See GCC PR38377 for discussion. 14215 if (const CallExpr *CallCE 14216 = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts())) 14217 if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p) 14218 return CheckEvalInICE(E, Ctx); 14219 ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx); 14220 if (CondResult.Kind == IK_NotICE) 14221 return CondResult; 14222 14223 ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx); 14224 ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx); 14225 14226 if (TrueResult.Kind == IK_NotICE) 14227 return TrueResult; 14228 if (FalseResult.Kind == IK_NotICE) 14229 return FalseResult; 14230 if (CondResult.Kind == IK_ICEIfUnevaluated) 14231 return CondResult; 14232 if (TrueResult.Kind == IK_ICE && FalseResult.Kind == IK_ICE) 14233 return NoDiag(); 14234 // Rare case where the diagnostics depend on which side is evaluated 14235 // Note that if we get here, CondResult is 0, and at least one of 14236 // TrueResult and FalseResult is non-zero. 14237 if (Exp->getCond()->EvaluateKnownConstInt(Ctx) == 0) 14238 return FalseResult; 14239 return TrueResult; 14240 } 14241 case Expr::CXXDefaultArgExprClass: 14242 return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx); 14243 case Expr::CXXDefaultInitExprClass: 14244 return CheckICE(cast<CXXDefaultInitExpr>(E)->getExpr(), Ctx); 14245 case Expr::ChooseExprClass: { 14246 return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(), Ctx); 14247 } 14248 case Expr::BuiltinBitCastExprClass: { 14249 if (!checkBitCastConstexprEligibility(nullptr, Ctx, cast<CastExpr>(E))) 14250 return ICEDiag(IK_NotICE, E->getBeginLoc()); 14251 return CheckICE(cast<CastExpr>(E)->getSubExpr(), Ctx); 14252 } 14253 } 14254 14255 llvm_unreachable("Invalid StmtClass!"); 14256 } 14257 14258 /// Evaluate an expression as a C++11 integral constant expression. 14259 static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx, 14260 const Expr *E, 14261 llvm::APSInt *Value, 14262 SourceLocation *Loc) { 14263 if (!E->getType()->isIntegralOrUnscopedEnumerationType()) { 14264 if (Loc) *Loc = E->getExprLoc(); 14265 return false; 14266 } 14267 14268 APValue Result; 14269 if (!E->isCXX11ConstantExpr(Ctx, &Result, Loc)) 14270 return false; 14271 14272 if (!Result.isInt()) { 14273 if (Loc) *Loc = E->getExprLoc(); 14274 return false; 14275 } 14276 14277 if (Value) *Value = Result.getInt(); 14278 return true; 14279 } 14280 14281 bool Expr::isIntegerConstantExpr(const ASTContext &Ctx, 14282 SourceLocation *Loc) const { 14283 assert(!isValueDependent() && 14284 "Expression evaluator can't be called on a dependent expression."); 14285 14286 if (Ctx.getLangOpts().CPlusPlus11) 14287 return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, nullptr, Loc); 14288 14289 ICEDiag D = CheckICE(this, Ctx); 14290 if (D.Kind != IK_ICE) { 14291 if (Loc) *Loc = D.Loc; 14292 return false; 14293 } 14294 return true; 14295 } 14296 14297 bool Expr::isIntegerConstantExpr(llvm::APSInt &Value, const ASTContext &Ctx, 14298 SourceLocation *Loc, bool isEvaluated) const { 14299 assert(!isValueDependent() && 14300 "Expression evaluator can't be called on a dependent expression."); 14301 14302 if (Ctx.getLangOpts().CPlusPlus11) 14303 return EvaluateCPlusPlus11IntegralConstantExpr(Ctx, this, &Value, Loc); 14304 14305 if (!isIntegerConstantExpr(Ctx, Loc)) 14306 return false; 14307 14308 // The only possible side-effects here are due to UB discovered in the 14309 // evaluation (for instance, INT_MAX + 1). In such a case, we are still 14310 // required to treat the expression as an ICE, so we produce the folded 14311 // value. 14312 EvalResult ExprResult; 14313 Expr::EvalStatus Status; 14314 EvalInfo Info(Ctx, Status, EvalInfo::EM_IgnoreSideEffects); 14315 Info.InConstantContext = true; 14316 14317 if (!::EvaluateAsInt(this, ExprResult, Ctx, SE_AllowSideEffects, Info)) 14318 llvm_unreachable("ICE cannot be evaluated!"); 14319 14320 Value = ExprResult.Val.getInt(); 14321 return true; 14322 } 14323 14324 bool Expr::isCXX98IntegralConstantExpr(const ASTContext &Ctx) const { 14325 assert(!isValueDependent() && 14326 "Expression evaluator can't be called on a dependent expression."); 14327 14328 return CheckICE(this, Ctx).Kind == IK_ICE; 14329 } 14330 14331 bool Expr::isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result, 14332 SourceLocation *Loc) const { 14333 assert(!isValueDependent() && 14334 "Expression evaluator can't be called on a dependent expression."); 14335 14336 // We support this checking in C++98 mode in order to diagnose compatibility 14337 // issues. 14338 assert(Ctx.getLangOpts().CPlusPlus); 14339 14340 // Build evaluation settings. 14341 Expr::EvalStatus Status; 14342 SmallVector<PartialDiagnosticAt, 8> Diags; 14343 Status.Diag = &Diags; 14344 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression); 14345 14346 APValue Scratch; 14347 bool IsConstExpr = 14348 ::EvaluateAsRValue(Info, this, Result ? *Result : Scratch) && 14349 // FIXME: We don't produce a diagnostic for this, but the callers that 14350 // call us on arbitrary full-expressions should generally not care. 14351 Info.discardCleanups() && !Status.HasSideEffects; 14352 14353 if (!Diags.empty()) { 14354 IsConstExpr = false; 14355 if (Loc) *Loc = Diags[0].first; 14356 } else if (!IsConstExpr) { 14357 // FIXME: This shouldn't happen. 14358 if (Loc) *Loc = getExprLoc(); 14359 } 14360 14361 return IsConstExpr; 14362 } 14363 14364 bool Expr::EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx, 14365 const FunctionDecl *Callee, 14366 ArrayRef<const Expr*> Args, 14367 const Expr *This) const { 14368 assert(!isValueDependent() && 14369 "Expression evaluator can't be called on a dependent expression."); 14370 14371 Expr::EvalStatus Status; 14372 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpressionUnevaluated); 14373 Info.InConstantContext = true; 14374 14375 LValue ThisVal; 14376 const LValue *ThisPtr = nullptr; 14377 if (This) { 14378 #ifndef NDEBUG 14379 auto *MD = dyn_cast<CXXMethodDecl>(Callee); 14380 assert(MD && "Don't provide `this` for non-methods."); 14381 assert(!MD->isStatic() && "Don't provide `this` for static methods."); 14382 #endif 14383 if (!This->isValueDependent() && 14384 EvaluateObjectArgument(Info, This, ThisVal) && 14385 !Info.EvalStatus.HasSideEffects) 14386 ThisPtr = &ThisVal; 14387 14388 // Ignore any side-effects from a failed evaluation. This is safe because 14389 // they can't interfere with any other argument evaluation. 14390 Info.EvalStatus.HasSideEffects = false; 14391 } 14392 14393 ArgVector ArgValues(Args.size()); 14394 for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end(); 14395 I != E; ++I) { 14396 if ((*I)->isValueDependent() || 14397 !Evaluate(ArgValues[I - Args.begin()], Info, *I) || 14398 Info.EvalStatus.HasSideEffects) 14399 // If evaluation fails, throw away the argument entirely. 14400 ArgValues[I - Args.begin()] = APValue(); 14401 14402 // Ignore any side-effects from a failed evaluation. This is safe because 14403 // they can't interfere with any other argument evaluation. 14404 Info.EvalStatus.HasSideEffects = false; 14405 } 14406 14407 // Parameter cleanups happen in the caller and are not part of this 14408 // evaluation. 14409 Info.discardCleanups(); 14410 Info.EvalStatus.HasSideEffects = false; 14411 14412 // Build fake call to Callee. 14413 CallStackFrame Frame(Info, Callee->getLocation(), Callee, ThisPtr, 14414 ArgValues.data()); 14415 // FIXME: Missing ExprWithCleanups in enable_if conditions? 14416 FullExpressionRAII Scope(Info); 14417 return Evaluate(Value, Info, this) && Scope.destroy() && 14418 !Info.EvalStatus.HasSideEffects; 14419 } 14420 14421 bool Expr::isPotentialConstantExpr(const FunctionDecl *FD, 14422 SmallVectorImpl< 14423 PartialDiagnosticAt> &Diags) { 14424 // FIXME: It would be useful to check constexpr function templates, but at the 14425 // moment the constant expression evaluator cannot cope with the non-rigorous 14426 // ASTs which we build for dependent expressions. 14427 if (FD->isDependentContext()) 14428 return true; 14429 14430 Expr::EvalStatus Status; 14431 Status.Diag = &Diags; 14432 14433 EvalInfo Info(FD->getASTContext(), Status, EvalInfo::EM_ConstantExpression); 14434 Info.InConstantContext = true; 14435 Info.CheckingPotentialConstantExpression = true; 14436 14437 // The constexpr VM attempts to compile all methods to bytecode here. 14438 if (Info.EnableNewConstInterp) { 14439 Info.Ctx.getInterpContext().isPotentialConstantExpr(Info, FD); 14440 return Diags.empty(); 14441 } 14442 14443 const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD); 14444 const CXXRecordDecl *RD = MD ? MD->getParent()->getCanonicalDecl() : nullptr; 14445 14446 // Fabricate an arbitrary expression on the stack and pretend that it 14447 // is a temporary being used as the 'this' pointer. 14448 LValue This; 14449 ImplicitValueInitExpr VIE(RD ? Info.Ctx.getRecordType(RD) : Info.Ctx.IntTy); 14450 This.set({&VIE, Info.CurrentCall->Index}); 14451 14452 ArrayRef<const Expr*> Args; 14453 14454 APValue Scratch; 14455 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) { 14456 // Evaluate the call as a constant initializer, to allow the construction 14457 // of objects of non-literal types. 14458 Info.setEvaluatingDecl(This.getLValueBase(), Scratch); 14459 HandleConstructorCall(&VIE, This, Args, CD, Info, Scratch); 14460 } else { 14461 SourceLocation Loc = FD->getLocation(); 14462 HandleFunctionCall(Loc, FD, (MD && MD->isInstance()) ? &This : nullptr, 14463 Args, FD->getBody(), Info, Scratch, nullptr); 14464 } 14465 14466 return Diags.empty(); 14467 } 14468 14469 bool Expr::isPotentialConstantExprUnevaluated(Expr *E, 14470 const FunctionDecl *FD, 14471 SmallVectorImpl< 14472 PartialDiagnosticAt> &Diags) { 14473 assert(!E->isValueDependent() && 14474 "Expression evaluator can't be called on a dependent expression."); 14475 14476 Expr::EvalStatus Status; 14477 Status.Diag = &Diags; 14478 14479 EvalInfo Info(FD->getASTContext(), Status, 14480 EvalInfo::EM_ConstantExpressionUnevaluated); 14481 Info.InConstantContext = true; 14482 Info.CheckingPotentialConstantExpression = true; 14483 14484 // Fabricate a call stack frame to give the arguments a plausible cover story. 14485 ArrayRef<const Expr*> Args; 14486 ArgVector ArgValues(0); 14487 bool Success = EvaluateArgs(Args, ArgValues, Info, FD); 14488 (void)Success; 14489 assert(Success && 14490 "Failed to set up arguments for potential constant evaluation"); 14491 CallStackFrame Frame(Info, SourceLocation(), FD, nullptr, ArgValues.data()); 14492 14493 APValue ResultScratch; 14494 Evaluate(ResultScratch, Info, E); 14495 return Diags.empty(); 14496 } 14497 14498 bool Expr::tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx, 14499 unsigned Type) const { 14500 if (!getType()->isPointerType()) 14501 return false; 14502 14503 Expr::EvalStatus Status; 14504 EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantFold); 14505 return tryEvaluateBuiltinObjectSize(this, Type, Info, Result); 14506 } 14507