1//===--- Expr.cpp - Expression AST Node Implementation --------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Expr class and subclasses. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/APValue.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/Attr.h" 17#include "clang/AST/DeclCXX.h" 18#include "clang/AST/DeclObjC.h" 19#include "clang/AST/DeclTemplate.h" 20#include "clang/AST/EvaluatedExprVisitor.h" 21#include "clang/AST/Expr.h" 22#include "clang/AST/ExprCXX.h" 23#include "clang/AST/RecordLayout.h" 24#include "clang/AST/StmtVisitor.h" 25#include "clang/Basic/Builtins.h" 26#include "clang/Basic/CharInfo.h" 27#include "clang/Basic/SourceManager.h" 28#include "clang/Basic/TargetInfo.h" 29#include "clang/Lex/Lexer.h" 30#include "clang/Lex/LiteralSupport.h" 31#include "clang/Sema/SemaDiagnostic.h" 32#include "llvm/Support/ErrorHandling.h" 33#include "llvm/Support/raw_ostream.h" 34#include <algorithm> 35#include <cstring> 36using namespace clang; 37 38const CXXRecordDecl *Expr::getBestDynamicClassType() const { 39 const Expr *E = ignoreParenBaseCasts(); 40 41 QualType DerivedType = E->getType(); 42 if (const PointerType *PTy = DerivedType->getAs<PointerType>()) 43 DerivedType = PTy->getPointeeType(); 44 45 if (DerivedType->isDependentType()) 46 return NULL; 47 48 const RecordType *Ty = DerivedType->castAs<RecordType>(); 49 Decl *D = Ty->getDecl(); 50 return cast<CXXRecordDecl>(D); 51} 52 53const Expr * 54Expr::skipRValueSubobjectAdjustments( 55 SmallVectorImpl<SubobjectAdjustment> &Adjustments) const { 56 const Expr *E = this; 57 while (true) { 58 E = E->IgnoreParens(); 59 60 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { 61 if ((CE->getCastKind() == CK_DerivedToBase || 62 CE->getCastKind() == CK_UncheckedDerivedToBase) && 63 E->getType()->isRecordType()) { 64 E = CE->getSubExpr(); 65 CXXRecordDecl *Derived 66 = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl()); 67 Adjustments.push_back(SubobjectAdjustment(CE, Derived)); 68 continue; 69 } 70 71 if (CE->getCastKind() == CK_NoOp) { 72 E = CE->getSubExpr(); 73 continue; 74 } 75 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 76 if (!ME->isArrow() && ME->getBase()->isRValue()) { 77 assert(ME->getBase()->getType()->isRecordType()); 78 if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) { 79 E = ME->getBase(); 80 Adjustments.push_back(SubobjectAdjustment(Field)); 81 continue; 82 } 83 } 84 } else if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 85 if (BO->isPtrMemOp()) { 86 assert(BO->getRHS()->isRValue()); 87 E = BO->getLHS(); 88 const MemberPointerType *MPT = 89 BO->getRHS()->getType()->getAs<MemberPointerType>(); 90 Adjustments.push_back(SubobjectAdjustment(MPT, BO->getRHS())); 91 } 92 } 93 94 // Nothing changed. 95 break; 96 } 97 return E; 98} 99 100const Expr * 101Expr::findMaterializedTemporary(const MaterializeTemporaryExpr *&MTE) const { 102 const Expr *E = this; 103 104 // This might be a default initializer for a reference member. Walk over the 105 // wrapper node for that. 106 if (const CXXDefaultInitExpr *DAE = dyn_cast<CXXDefaultInitExpr>(E)) 107 E = DAE->getExpr(); 108 109 // Look through single-element init lists that claim to be lvalues. They're 110 // just syntactic wrappers in this case. 111 if (const InitListExpr *ILE = dyn_cast<InitListExpr>(E)) { 112 if (ILE->getNumInits() == 1 && ILE->isGLValue()) { 113 E = ILE->getInit(0); 114 if (const CXXDefaultInitExpr *DAE = dyn_cast<CXXDefaultInitExpr>(E)) 115 E = DAE->getExpr(); 116 } 117 } 118 119 // Look through expressions for materialized temporaries (for now). 120 if (const MaterializeTemporaryExpr *M 121 = dyn_cast<MaterializeTemporaryExpr>(E)) { 122 MTE = M; 123 E = M->GetTemporaryExpr(); 124 } 125 126 if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E)) 127 E = DAE->getExpr(); 128 return E; 129} 130 131/// isKnownToHaveBooleanValue - Return true if this is an integer expression 132/// that is known to return 0 or 1. This happens for _Bool/bool expressions 133/// but also int expressions which are produced by things like comparisons in 134/// C. 135bool Expr::isKnownToHaveBooleanValue() const { 136 const Expr *E = IgnoreParens(); 137 138 // If this value has _Bool type, it is obvious 0/1. 139 if (E->getType()->isBooleanType()) return true; 140 // If this is a non-scalar-integer type, we don't care enough to try. 141 if (!E->getType()->isIntegralOrEnumerationType()) return false; 142 143 if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { 144 switch (UO->getOpcode()) { 145 case UO_Plus: 146 return UO->getSubExpr()->isKnownToHaveBooleanValue(); 147 default: 148 return false; 149 } 150 } 151 152 // Only look through implicit casts. If the user writes 153 // '(int) (a && b)' treat it as an arbitrary int. 154 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 155 return CE->getSubExpr()->isKnownToHaveBooleanValue(); 156 157 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 158 switch (BO->getOpcode()) { 159 default: return false; 160 case BO_LT: // Relational operators. 161 case BO_GT: 162 case BO_LE: 163 case BO_GE: 164 case BO_EQ: // Equality operators. 165 case BO_NE: 166 case BO_LAnd: // AND operator. 167 case BO_LOr: // Logical OR operator. 168 return true; 169 170 case BO_And: // Bitwise AND operator. 171 case BO_Xor: // Bitwise XOR operator. 172 case BO_Or: // Bitwise OR operator. 173 // Handle things like (x==2)|(y==12). 174 return BO->getLHS()->isKnownToHaveBooleanValue() && 175 BO->getRHS()->isKnownToHaveBooleanValue(); 176 177 case BO_Comma: 178 case BO_Assign: 179 return BO->getRHS()->isKnownToHaveBooleanValue(); 180 } 181 } 182 183 if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) 184 return CO->getTrueExpr()->isKnownToHaveBooleanValue() && 185 CO->getFalseExpr()->isKnownToHaveBooleanValue(); 186 187 return false; 188} 189 190// Amusing macro metaprogramming hack: check whether a class provides 191// a more specific implementation of getExprLoc(). 192// 193// See also Stmt.cpp:{getLocStart(),getLocEnd()}. 194namespace { 195 /// This implementation is used when a class provides a custom 196 /// implementation of getExprLoc. 197 template <class E, class T> 198 SourceLocation getExprLocImpl(const Expr *expr, 199 SourceLocation (T::*v)() const) { 200 return static_cast<const E*>(expr)->getExprLoc(); 201 } 202 203 /// This implementation is used when a class doesn't provide 204 /// a custom implementation of getExprLoc. Overload resolution 205 /// should pick it over the implementation above because it's 206 /// more specialized according to function template partial ordering. 207 template <class E> 208 SourceLocation getExprLocImpl(const Expr *expr, 209 SourceLocation (Expr::*v)() const) { 210 return static_cast<const E*>(expr)->getLocStart(); 211 } 212} 213 214SourceLocation Expr::getExprLoc() const { 215 switch (getStmtClass()) { 216 case Stmt::NoStmtClass: llvm_unreachable("statement without class"); 217#define ABSTRACT_STMT(type) 218#define STMT(type, base) \ 219 case Stmt::type##Class: llvm_unreachable(#type " is not an Expr"); break; 220#define EXPR(type, base) \ 221 case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc); 222#include "clang/AST/StmtNodes.inc" 223 } 224 llvm_unreachable("unknown statement kind"); 225} 226 227//===----------------------------------------------------------------------===// 228// Primary Expressions. 229//===----------------------------------------------------------------------===// 230 231/// \brief Compute the type-, value-, and instantiation-dependence of a 232/// declaration reference 233/// based on the declaration being referenced. 234static void computeDeclRefDependence(ASTContext &Ctx, NamedDecl *D, QualType T, 235 bool &TypeDependent, 236 bool &ValueDependent, 237 bool &InstantiationDependent) { 238 TypeDependent = false; 239 ValueDependent = false; 240 InstantiationDependent = false; 241 242 // (TD) C++ [temp.dep.expr]p3: 243 // An id-expression is type-dependent if it contains: 244 // 245 // and 246 // 247 // (VD) C++ [temp.dep.constexpr]p2: 248 // An identifier is value-dependent if it is: 249 250 // (TD) - an identifier that was declared with dependent type 251 // (VD) - a name declared with a dependent type, 252 if (T->isDependentType()) { 253 TypeDependent = true; 254 ValueDependent = true; 255 InstantiationDependent = true; 256 return; 257 } else if (T->isInstantiationDependentType()) { 258 InstantiationDependent = true; 259 } 260 261 // (TD) - a conversion-function-id that specifies a dependent type 262 if (D->getDeclName().getNameKind() 263 == DeclarationName::CXXConversionFunctionName) { 264 QualType T = D->getDeclName().getCXXNameType(); 265 if (T->isDependentType()) { 266 TypeDependent = true; 267 ValueDependent = true; 268 InstantiationDependent = true; 269 return; 270 } 271 272 if (T->isInstantiationDependentType()) 273 InstantiationDependent = true; 274 } 275 276 // (VD) - the name of a non-type template parameter, 277 if (isa<NonTypeTemplateParmDecl>(D)) { 278 ValueDependent = true; 279 InstantiationDependent = true; 280 return; 281 } 282 283 // (VD) - a constant with integral or enumeration type and is 284 // initialized with an expression that is value-dependent. 285 // (VD) - a constant with literal type and is initialized with an 286 // expression that is value-dependent [C++11]. 287 // (VD) - FIXME: Missing from the standard: 288 // - an entity with reference type and is initialized with an 289 // expression that is value-dependent [C++11] 290 if (VarDecl *Var = dyn_cast<VarDecl>(D)) { 291 if ((Ctx.getLangOpts().CPlusPlus11 ? 292 Var->getType()->isLiteralType(Ctx) : 293 Var->getType()->isIntegralOrEnumerationType()) && 294 (Var->getType().isConstQualified() || 295 Var->getType()->isReferenceType())) { 296 if (const Expr *Init = Var->getAnyInitializer()) 297 if (Init->isValueDependent()) { 298 ValueDependent = true; 299 InstantiationDependent = true; 300 } 301 } 302 303 // (VD) - FIXME: Missing from the standard: 304 // - a member function or a static data member of the current 305 // instantiation 306 if (Var->isStaticDataMember() && 307 Var->getDeclContext()->isDependentContext()) { 308 ValueDependent = true; 309 InstantiationDependent = true; 310 } 311 312 return; 313 } 314 315 // (VD) - FIXME: Missing from the standard: 316 // - a member function or a static data member of the current 317 // instantiation 318 if (isa<CXXMethodDecl>(D) && D->getDeclContext()->isDependentContext()) { 319 ValueDependent = true; 320 InstantiationDependent = true; 321 } 322} 323 324void DeclRefExpr::computeDependence(ASTContext &Ctx) { 325 bool TypeDependent = false; 326 bool ValueDependent = false; 327 bool InstantiationDependent = false; 328 computeDeclRefDependence(Ctx, getDecl(), getType(), TypeDependent, 329 ValueDependent, InstantiationDependent); 330 331 // (TD) C++ [temp.dep.expr]p3: 332 // An id-expression is type-dependent if it contains: 333 // 334 // and 335 // 336 // (VD) C++ [temp.dep.constexpr]p2: 337 // An identifier is value-dependent if it is: 338 if (!TypeDependent && !ValueDependent && 339 hasExplicitTemplateArgs() && 340 TemplateSpecializationType::anyDependentTemplateArguments( 341 getTemplateArgs(), 342 getNumTemplateArgs(), 343 InstantiationDependent)) { 344 TypeDependent = true; 345 ValueDependent = true; 346 InstantiationDependent = true; 347 } 348 349 ExprBits.TypeDependent = TypeDependent; 350 ExprBits.ValueDependent = ValueDependent; 351 ExprBits.InstantiationDependent = InstantiationDependent; 352 353 // Is the declaration a parameter pack? 354 if (getDecl()->isParameterPack()) 355 ExprBits.ContainsUnexpandedParameterPack = true; 356} 357 358DeclRefExpr::DeclRefExpr(ASTContext &Ctx, 359 NestedNameSpecifierLoc QualifierLoc, 360 SourceLocation TemplateKWLoc, 361 ValueDecl *D, bool RefersToEnclosingLocal, 362 const DeclarationNameInfo &NameInfo, 363 NamedDecl *FoundD, 364 const TemplateArgumentListInfo *TemplateArgs, 365 QualType T, ExprValueKind VK) 366 : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false), 367 D(D), Loc(NameInfo.getLoc()), DNLoc(NameInfo.getInfo()) { 368 DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0; 369 if (QualifierLoc) 370 getInternalQualifierLoc() = QualifierLoc; 371 DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0; 372 if (FoundD) 373 getInternalFoundDecl() = FoundD; 374 DeclRefExprBits.HasTemplateKWAndArgsInfo 375 = (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0; 376 DeclRefExprBits.RefersToEnclosingLocal = RefersToEnclosingLocal; 377 if (TemplateArgs) { 378 bool Dependent = false; 379 bool InstantiationDependent = false; 380 bool ContainsUnexpandedParameterPack = false; 381 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, 382 Dependent, 383 InstantiationDependent, 384 ContainsUnexpandedParameterPack); 385 if (InstantiationDependent) 386 setInstantiationDependent(true); 387 } else if (TemplateKWLoc.isValid()) { 388 getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 389 } 390 DeclRefExprBits.HadMultipleCandidates = 0; 391 392 computeDependence(Ctx); 393} 394 395DeclRefExpr *DeclRefExpr::Create(ASTContext &Context, 396 NestedNameSpecifierLoc QualifierLoc, 397 SourceLocation TemplateKWLoc, 398 ValueDecl *D, 399 bool RefersToEnclosingLocal, 400 SourceLocation NameLoc, 401 QualType T, 402 ExprValueKind VK, 403 NamedDecl *FoundD, 404 const TemplateArgumentListInfo *TemplateArgs) { 405 return Create(Context, QualifierLoc, TemplateKWLoc, D, 406 RefersToEnclosingLocal, 407 DeclarationNameInfo(D->getDeclName(), NameLoc), 408 T, VK, FoundD, TemplateArgs); 409} 410 411DeclRefExpr *DeclRefExpr::Create(ASTContext &Context, 412 NestedNameSpecifierLoc QualifierLoc, 413 SourceLocation TemplateKWLoc, 414 ValueDecl *D, 415 bool RefersToEnclosingLocal, 416 const DeclarationNameInfo &NameInfo, 417 QualType T, 418 ExprValueKind VK, 419 NamedDecl *FoundD, 420 const TemplateArgumentListInfo *TemplateArgs) { 421 // Filter out cases where the found Decl is the same as the value refenenced. 422 if (D == FoundD) 423 FoundD = 0; 424 425 std::size_t Size = sizeof(DeclRefExpr); 426 if (QualifierLoc != 0) 427 Size += sizeof(NestedNameSpecifierLoc); 428 if (FoundD) 429 Size += sizeof(NamedDecl *); 430 if (TemplateArgs) 431 Size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size()); 432 else if (TemplateKWLoc.isValid()) 433 Size += ASTTemplateKWAndArgsInfo::sizeFor(0); 434 435 void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>()); 436 return new (Mem) DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D, 437 RefersToEnclosingLocal, 438 NameInfo, FoundD, TemplateArgs, T, VK); 439} 440 441DeclRefExpr *DeclRefExpr::CreateEmpty(ASTContext &Context, 442 bool HasQualifier, 443 bool HasFoundDecl, 444 bool HasTemplateKWAndArgsInfo, 445 unsigned NumTemplateArgs) { 446 std::size_t Size = sizeof(DeclRefExpr); 447 if (HasQualifier) 448 Size += sizeof(NestedNameSpecifierLoc); 449 if (HasFoundDecl) 450 Size += sizeof(NamedDecl *); 451 if (HasTemplateKWAndArgsInfo) 452 Size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 453 454 void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>()); 455 return new (Mem) DeclRefExpr(EmptyShell()); 456} 457 458SourceLocation DeclRefExpr::getLocStart() const { 459 if (hasQualifier()) 460 return getQualifierLoc().getBeginLoc(); 461 return getNameInfo().getLocStart(); 462} 463SourceLocation DeclRefExpr::getLocEnd() const { 464 if (hasExplicitTemplateArgs()) 465 return getRAngleLoc(); 466 return getNameInfo().getLocEnd(); 467} 468 469// FIXME: Maybe this should use DeclPrinter with a special "print predefined 470// expr" policy instead. 471std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) { 472 ASTContext &Context = CurrentDecl->getASTContext(); 473 474 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) { 475 if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual) 476 return FD->getNameAsString(); 477 478 SmallString<256> Name; 479 llvm::raw_svector_ostream Out(Name); 480 481 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 482 if (MD->isVirtual() && IT != PrettyFunctionNoVirtual) 483 Out << "virtual "; 484 if (MD->isStatic()) 485 Out << "static "; 486 } 487 488 PrintingPolicy Policy(Context.getLangOpts()); 489 std::string Proto; 490 llvm::raw_string_ostream POut(Proto); 491 FD->printQualifiedName(POut, Policy); 492 493 const FunctionDecl *Decl = FD; 494 if (const FunctionDecl* Pattern = FD->getTemplateInstantiationPattern()) 495 Decl = Pattern; 496 const FunctionType *AFT = Decl->getType()->getAs<FunctionType>(); 497 const FunctionProtoType *FT = 0; 498 if (FD->hasWrittenPrototype()) 499 FT = dyn_cast<FunctionProtoType>(AFT); 500 501 POut << "("; 502 if (FT) { 503 for (unsigned i = 0, e = Decl->getNumParams(); i != e; ++i) { 504 if (i) POut << ", "; 505 POut << Decl->getParamDecl(i)->getType().stream(Policy); 506 } 507 508 if (FT->isVariadic()) { 509 if (FD->getNumParams()) POut << ", "; 510 POut << "..."; 511 } 512 } 513 POut << ")"; 514 515 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 516 const FunctionType *FT = MD->getType()->castAs<FunctionType>(); 517 if (FT->isConst()) 518 POut << " const"; 519 if (FT->isVolatile()) 520 POut << " volatile"; 521 RefQualifierKind Ref = MD->getRefQualifier(); 522 if (Ref == RQ_LValue) 523 POut << " &"; 524 else if (Ref == RQ_RValue) 525 POut << " &&"; 526 } 527 528 typedef SmallVector<const ClassTemplateSpecializationDecl *, 8> SpecsTy; 529 SpecsTy Specs; 530 const DeclContext *Ctx = FD->getDeclContext(); 531 while (Ctx && isa<NamedDecl>(Ctx)) { 532 const ClassTemplateSpecializationDecl *Spec 533 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx); 534 if (Spec && !Spec->isExplicitSpecialization()) 535 Specs.push_back(Spec); 536 Ctx = Ctx->getParent(); 537 } 538 539 std::string TemplateParams; 540 llvm::raw_string_ostream TOut(TemplateParams); 541 for (SpecsTy::reverse_iterator I = Specs.rbegin(), E = Specs.rend(); 542 I != E; ++I) { 543 const TemplateParameterList *Params 544 = (*I)->getSpecializedTemplate()->getTemplateParameters(); 545 const TemplateArgumentList &Args = (*I)->getTemplateArgs(); 546 assert(Params->size() == Args.size()); 547 for (unsigned i = 0, numParams = Params->size(); i != numParams; ++i) { 548 StringRef Param = Params->getParam(i)->getName(); 549 if (Param.empty()) continue; 550 TOut << Param << " = "; 551 Args.get(i).print(Policy, TOut); 552 TOut << ", "; 553 } 554 } 555 556 FunctionTemplateSpecializationInfo *FSI 557 = FD->getTemplateSpecializationInfo(); 558 if (FSI && !FSI->isExplicitSpecialization()) { 559 const TemplateParameterList* Params 560 = FSI->getTemplate()->getTemplateParameters(); 561 const TemplateArgumentList* Args = FSI->TemplateArguments; 562 assert(Params->size() == Args->size()); 563 for (unsigned i = 0, e = Params->size(); i != e; ++i) { 564 StringRef Param = Params->getParam(i)->getName(); 565 if (Param.empty()) continue; 566 TOut << Param << " = "; 567 Args->get(i).print(Policy, TOut); 568 TOut << ", "; 569 } 570 } 571 572 TOut.flush(); 573 if (!TemplateParams.empty()) { 574 // remove the trailing comma and space 575 TemplateParams.resize(TemplateParams.size() - 2); 576 POut << " [" << TemplateParams << "]"; 577 } 578 579 POut.flush(); 580 581 if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD)) 582 AFT->getResultType().getAsStringInternal(Proto, Policy); 583 584 Out << Proto; 585 586 Out.flush(); 587 return Name.str().str(); 588 } 589 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) { 590 SmallString<256> Name; 591 llvm::raw_svector_ostream Out(Name); 592 Out << (MD->isInstanceMethod() ? '-' : '+'); 593 Out << '['; 594 595 // For incorrect code, there might not be an ObjCInterfaceDecl. Do 596 // a null check to avoid a crash. 597 if (const ObjCInterfaceDecl *ID = MD->getClassInterface()) 598 Out << *ID; 599 600 if (const ObjCCategoryImplDecl *CID = 601 dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext())) 602 Out << '(' << *CID << ')'; 603 604 Out << ' '; 605 Out << MD->getSelector().getAsString(); 606 Out << ']'; 607 608 Out.flush(); 609 return Name.str().str(); 610 } 611 if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) { 612 // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string. 613 return "top level"; 614 } 615 return ""; 616} 617 618void APNumericStorage::setIntValue(ASTContext &C, const llvm::APInt &Val) { 619 if (hasAllocation()) 620 C.Deallocate(pVal); 621 622 BitWidth = Val.getBitWidth(); 623 unsigned NumWords = Val.getNumWords(); 624 const uint64_t* Words = Val.getRawData(); 625 if (NumWords > 1) { 626 pVal = new (C) uint64_t[NumWords]; 627 std::copy(Words, Words + NumWords, pVal); 628 } else if (NumWords == 1) 629 VAL = Words[0]; 630 else 631 VAL = 0; 632} 633 634IntegerLiteral::IntegerLiteral(ASTContext &C, const llvm::APInt &V, 635 QualType type, SourceLocation l) 636 : Expr(IntegerLiteralClass, type, VK_RValue, OK_Ordinary, false, false, 637 false, false), 638 Loc(l) { 639 assert(type->isIntegerType() && "Illegal type in IntegerLiteral"); 640 assert(V.getBitWidth() == C.getIntWidth(type) && 641 "Integer type is not the correct size for constant."); 642 setValue(C, V); 643} 644 645IntegerLiteral * 646IntegerLiteral::Create(ASTContext &C, const llvm::APInt &V, 647 QualType type, SourceLocation l) { 648 return new (C) IntegerLiteral(C, V, type, l); 649} 650 651IntegerLiteral * 652IntegerLiteral::Create(ASTContext &C, EmptyShell Empty) { 653 return new (C) IntegerLiteral(Empty); 654} 655 656FloatingLiteral::FloatingLiteral(ASTContext &C, const llvm::APFloat &V, 657 bool isexact, QualType Type, SourceLocation L) 658 : Expr(FloatingLiteralClass, Type, VK_RValue, OK_Ordinary, false, false, 659 false, false), Loc(L) { 660 setSemantics(V.getSemantics()); 661 FloatingLiteralBits.IsExact = isexact; 662 setValue(C, V); 663} 664 665FloatingLiteral::FloatingLiteral(ASTContext &C, EmptyShell Empty) 666 : Expr(FloatingLiteralClass, Empty) { 667 setRawSemantics(IEEEhalf); 668 FloatingLiteralBits.IsExact = false; 669} 670 671FloatingLiteral * 672FloatingLiteral::Create(ASTContext &C, const llvm::APFloat &V, 673 bool isexact, QualType Type, SourceLocation L) { 674 return new (C) FloatingLiteral(C, V, isexact, Type, L); 675} 676 677FloatingLiteral * 678FloatingLiteral::Create(ASTContext &C, EmptyShell Empty) { 679 return new (C) FloatingLiteral(C, Empty); 680} 681 682const llvm::fltSemantics &FloatingLiteral::getSemantics() const { 683 switch(FloatingLiteralBits.Semantics) { 684 case IEEEhalf: 685 return llvm::APFloat::IEEEhalf; 686 case IEEEsingle: 687 return llvm::APFloat::IEEEsingle; 688 case IEEEdouble: 689 return llvm::APFloat::IEEEdouble; 690 case x87DoubleExtended: 691 return llvm::APFloat::x87DoubleExtended; 692 case IEEEquad: 693 return llvm::APFloat::IEEEquad; 694 case PPCDoubleDouble: 695 return llvm::APFloat::PPCDoubleDouble; 696 } 697 llvm_unreachable("Unrecognised floating semantics"); 698} 699 700void FloatingLiteral::setSemantics(const llvm::fltSemantics &Sem) { 701 if (&Sem == &llvm::APFloat::IEEEhalf) 702 FloatingLiteralBits.Semantics = IEEEhalf; 703 else if (&Sem == &llvm::APFloat::IEEEsingle) 704 FloatingLiteralBits.Semantics = IEEEsingle; 705 else if (&Sem == &llvm::APFloat::IEEEdouble) 706 FloatingLiteralBits.Semantics = IEEEdouble; 707 else if (&Sem == &llvm::APFloat::x87DoubleExtended) 708 FloatingLiteralBits.Semantics = x87DoubleExtended; 709 else if (&Sem == &llvm::APFloat::IEEEquad) 710 FloatingLiteralBits.Semantics = IEEEquad; 711 else if (&Sem == &llvm::APFloat::PPCDoubleDouble) 712 FloatingLiteralBits.Semantics = PPCDoubleDouble; 713 else 714 llvm_unreachable("Unknown floating semantics"); 715} 716 717/// getValueAsApproximateDouble - This returns the value as an inaccurate 718/// double. Note that this may cause loss of precision, but is useful for 719/// debugging dumps, etc. 720double FloatingLiteral::getValueAsApproximateDouble() const { 721 llvm::APFloat V = getValue(); 722 bool ignored; 723 V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 724 &ignored); 725 return V.convertToDouble(); 726} 727 728int StringLiteral::mapCharByteWidth(TargetInfo const &target,StringKind k) { 729 int CharByteWidth = 0; 730 switch(k) { 731 case Ascii: 732 case UTF8: 733 CharByteWidth = target.getCharWidth(); 734 break; 735 case Wide: 736 CharByteWidth = target.getWCharWidth(); 737 break; 738 case UTF16: 739 CharByteWidth = target.getChar16Width(); 740 break; 741 case UTF32: 742 CharByteWidth = target.getChar32Width(); 743 break; 744 } 745 assert((CharByteWidth & 7) == 0 && "Assumes character size is byte multiple"); 746 CharByteWidth /= 8; 747 assert((CharByteWidth==1 || CharByteWidth==2 || CharByteWidth==4) 748 && "character byte widths supported are 1, 2, and 4 only"); 749 return CharByteWidth; 750} 751 752StringLiteral *StringLiteral::Create(ASTContext &C, StringRef Str, 753 StringKind Kind, bool Pascal, QualType Ty, 754 const SourceLocation *Loc, 755 unsigned NumStrs) { 756 // Allocate enough space for the StringLiteral plus an array of locations for 757 // any concatenated string tokens. 758 void *Mem = C.Allocate(sizeof(StringLiteral)+ 759 sizeof(SourceLocation)*(NumStrs-1), 760 llvm::alignOf<StringLiteral>()); 761 StringLiteral *SL = new (Mem) StringLiteral(Ty); 762 763 // OPTIMIZE: could allocate this appended to the StringLiteral. 764 SL->setString(C,Str,Kind,Pascal); 765 766 SL->TokLocs[0] = Loc[0]; 767 SL->NumConcatenated = NumStrs; 768 769 if (NumStrs != 1) 770 memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1)); 771 return SL; 772} 773 774StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) { 775 void *Mem = C.Allocate(sizeof(StringLiteral)+ 776 sizeof(SourceLocation)*(NumStrs-1), 777 llvm::alignOf<StringLiteral>()); 778 StringLiteral *SL = new (Mem) StringLiteral(QualType()); 779 SL->CharByteWidth = 0; 780 SL->Length = 0; 781 SL->NumConcatenated = NumStrs; 782 return SL; 783} 784 785void StringLiteral::outputString(raw_ostream &OS) const { 786 switch (getKind()) { 787 case Ascii: break; // no prefix. 788 case Wide: OS << 'L'; break; 789 case UTF8: OS << "u8"; break; 790 case UTF16: OS << 'u'; break; 791 case UTF32: OS << 'U'; break; 792 } 793 OS << '"'; 794 static const char Hex[] = "0123456789ABCDEF"; 795 796 unsigned LastSlashX = getLength(); 797 for (unsigned I = 0, N = getLength(); I != N; ++I) { 798 switch (uint32_t Char = getCodeUnit(I)) { 799 default: 800 // FIXME: Convert UTF-8 back to codepoints before rendering. 801 802 // Convert UTF-16 surrogate pairs back to codepoints before rendering. 803 // Leave invalid surrogates alone; we'll use \x for those. 804 if (getKind() == UTF16 && I != N - 1 && Char >= 0xd800 && 805 Char <= 0xdbff) { 806 uint32_t Trail = getCodeUnit(I + 1); 807 if (Trail >= 0xdc00 && Trail <= 0xdfff) { 808 Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00); 809 ++I; 810 } 811 } 812 813 if (Char > 0xff) { 814 // If this is a wide string, output characters over 0xff using \x 815 // escapes. Otherwise, this is a UTF-16 or UTF-32 string, and Char is a 816 // codepoint: use \x escapes for invalid codepoints. 817 if (getKind() == Wide || 818 (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) { 819 // FIXME: Is this the best way to print wchar_t? 820 OS << "\\x"; 821 int Shift = 28; 822 while ((Char >> Shift) == 0) 823 Shift -= 4; 824 for (/**/; Shift >= 0; Shift -= 4) 825 OS << Hex[(Char >> Shift) & 15]; 826 LastSlashX = I; 827 break; 828 } 829 830 if (Char > 0xffff) 831 OS << "\\U00" 832 << Hex[(Char >> 20) & 15] 833 << Hex[(Char >> 16) & 15]; 834 else 835 OS << "\\u"; 836 OS << Hex[(Char >> 12) & 15] 837 << Hex[(Char >> 8) & 15] 838 << Hex[(Char >> 4) & 15] 839 << Hex[(Char >> 0) & 15]; 840 break; 841 } 842 843 // If we used \x... for the previous character, and this character is a 844 // hexadecimal digit, prevent it being slurped as part of the \x. 845 if (LastSlashX + 1 == I) { 846 switch (Char) { 847 case '0': case '1': case '2': case '3': case '4': 848 case '5': case '6': case '7': case '8': case '9': 849 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': 850 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': 851 OS << "\"\""; 852 } 853 } 854 855 assert(Char <= 0xff && 856 "Characters above 0xff should already have been handled."); 857 858 if (isPrintable(Char)) 859 OS << (char)Char; 860 else // Output anything hard as an octal escape. 861 OS << '\\' 862 << (char)('0' + ((Char >> 6) & 7)) 863 << (char)('0' + ((Char >> 3) & 7)) 864 << (char)('0' + ((Char >> 0) & 7)); 865 break; 866 // Handle some common non-printable cases to make dumps prettier. 867 case '\\': OS << "\\\\"; break; 868 case '"': OS << "\\\""; break; 869 case '\n': OS << "\\n"; break; 870 case '\t': OS << "\\t"; break; 871 case '\a': OS << "\\a"; break; 872 case '\b': OS << "\\b"; break; 873 } 874 } 875 OS << '"'; 876} 877 878void StringLiteral::setString(ASTContext &C, StringRef Str, 879 StringKind Kind, bool IsPascal) { 880 //FIXME: we assume that the string data comes from a target that uses the same 881 // code unit size and endianess for the type of string. 882 this->Kind = Kind; 883 this->IsPascal = IsPascal; 884 885 CharByteWidth = mapCharByteWidth(C.getTargetInfo(),Kind); 886 assert((Str.size()%CharByteWidth == 0) 887 && "size of data must be multiple of CharByteWidth"); 888 Length = Str.size()/CharByteWidth; 889 890 switch(CharByteWidth) { 891 case 1: { 892 char *AStrData = new (C) char[Length]; 893 std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData)); 894 StrData.asChar = AStrData; 895 break; 896 } 897 case 2: { 898 uint16_t *AStrData = new (C) uint16_t[Length]; 899 std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData)); 900 StrData.asUInt16 = AStrData; 901 break; 902 } 903 case 4: { 904 uint32_t *AStrData = new (C) uint32_t[Length]; 905 std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData)); 906 StrData.asUInt32 = AStrData; 907 break; 908 } 909 default: 910 assert(false && "unsupported CharByteWidth"); 911 } 912} 913 914/// getLocationOfByte - Return a source location that points to the specified 915/// byte of this string literal. 916/// 917/// Strings are amazingly complex. They can be formed from multiple tokens and 918/// can have escape sequences in them in addition to the usual trigraph and 919/// escaped newline business. This routine handles this complexity. 920/// 921SourceLocation StringLiteral:: 922getLocationOfByte(unsigned ByteNo, const SourceManager &SM, 923 const LangOptions &Features, const TargetInfo &Target) const { 924 assert((Kind == StringLiteral::Ascii || Kind == StringLiteral::UTF8) && 925 "Only narrow string literals are currently supported"); 926 927 // Loop over all of the tokens in this string until we find the one that 928 // contains the byte we're looking for. 929 unsigned TokNo = 0; 930 while (1) { 931 assert(TokNo < getNumConcatenated() && "Invalid byte number!"); 932 SourceLocation StrTokLoc = getStrTokenLoc(TokNo); 933 934 // Get the spelling of the string so that we can get the data that makes up 935 // the string literal, not the identifier for the macro it is potentially 936 // expanded through. 937 SourceLocation StrTokSpellingLoc = SM.getSpellingLoc(StrTokLoc); 938 939 // Re-lex the token to get its length and original spelling. 940 std::pair<FileID, unsigned> LocInfo =SM.getDecomposedLoc(StrTokSpellingLoc); 941 bool Invalid = false; 942 StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid); 943 if (Invalid) 944 return StrTokSpellingLoc; 945 946 const char *StrData = Buffer.data()+LocInfo.second; 947 948 // Create a lexer starting at the beginning of this token. 949 Lexer TheLexer(SM.getLocForStartOfFile(LocInfo.first), Features, 950 Buffer.begin(), StrData, Buffer.end()); 951 Token TheTok; 952 TheLexer.LexFromRawLexer(TheTok); 953 954 // Use the StringLiteralParser to compute the length of the string in bytes. 955 StringLiteralParser SLP(&TheTok, 1, SM, Features, Target); 956 unsigned TokNumBytes = SLP.GetStringLength(); 957 958 // If the byte is in this token, return the location of the byte. 959 if (ByteNo < TokNumBytes || 960 (ByteNo == TokNumBytes && TokNo == getNumConcatenated() - 1)) { 961 unsigned Offset = SLP.getOffsetOfStringByte(TheTok, ByteNo); 962 963 // Now that we know the offset of the token in the spelling, use the 964 // preprocessor to get the offset in the original source. 965 return Lexer::AdvanceToTokenCharacter(StrTokLoc, Offset, SM, Features); 966 } 967 968 // Move to the next string token. 969 ++TokNo; 970 ByteNo -= TokNumBytes; 971 } 972} 973 974 975 976/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 977/// corresponds to, e.g. "sizeof" or "[pre]++". 978StringRef UnaryOperator::getOpcodeStr(Opcode Op) { 979 switch (Op) { 980 case UO_PostInc: return "++"; 981 case UO_PostDec: return "--"; 982 case UO_PreInc: return "++"; 983 case UO_PreDec: return "--"; 984 case UO_AddrOf: return "&"; 985 case UO_Deref: return "*"; 986 case UO_Plus: return "+"; 987 case UO_Minus: return "-"; 988 case UO_Not: return "~"; 989 case UO_LNot: return "!"; 990 case UO_Real: return "__real"; 991 case UO_Imag: return "__imag"; 992 case UO_Extension: return "__extension__"; 993 } 994 llvm_unreachable("Unknown unary operator"); 995} 996 997UnaryOperatorKind 998UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) { 999 switch (OO) { 1000 default: llvm_unreachable("No unary operator for overloaded function"); 1001 case OO_PlusPlus: return Postfix ? UO_PostInc : UO_PreInc; 1002 case OO_MinusMinus: return Postfix ? UO_PostDec : UO_PreDec; 1003 case OO_Amp: return UO_AddrOf; 1004 case OO_Star: return UO_Deref; 1005 case OO_Plus: return UO_Plus; 1006 case OO_Minus: return UO_Minus; 1007 case OO_Tilde: return UO_Not; 1008 case OO_Exclaim: return UO_LNot; 1009 } 1010} 1011 1012OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) { 1013 switch (Opc) { 1014 case UO_PostInc: case UO_PreInc: return OO_PlusPlus; 1015 case UO_PostDec: case UO_PreDec: return OO_MinusMinus; 1016 case UO_AddrOf: return OO_Amp; 1017 case UO_Deref: return OO_Star; 1018 case UO_Plus: return OO_Plus; 1019 case UO_Minus: return OO_Minus; 1020 case UO_Not: return OO_Tilde; 1021 case UO_LNot: return OO_Exclaim; 1022 default: return OO_None; 1023 } 1024} 1025 1026 1027//===----------------------------------------------------------------------===// 1028// Postfix Operators. 1029//===----------------------------------------------------------------------===// 1030 1031CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, unsigned NumPreArgs, 1032 ArrayRef<Expr*> args, QualType t, ExprValueKind VK, 1033 SourceLocation rparenloc) 1034 : Expr(SC, t, VK, OK_Ordinary, 1035 fn->isTypeDependent(), 1036 fn->isValueDependent(), 1037 fn->isInstantiationDependent(), 1038 fn->containsUnexpandedParameterPack()), 1039 NumArgs(args.size()) { 1040 1041 SubExprs = new (C) Stmt*[args.size()+PREARGS_START+NumPreArgs]; 1042 SubExprs[FN] = fn; 1043 for (unsigned i = 0; i != args.size(); ++i) { 1044 if (args[i]->isTypeDependent()) 1045 ExprBits.TypeDependent = true; 1046 if (args[i]->isValueDependent()) 1047 ExprBits.ValueDependent = true; 1048 if (args[i]->isInstantiationDependent()) 1049 ExprBits.InstantiationDependent = true; 1050 if (args[i]->containsUnexpandedParameterPack()) 1051 ExprBits.ContainsUnexpandedParameterPack = true; 1052 1053 SubExprs[i+PREARGS_START+NumPreArgs] = args[i]; 1054 } 1055 1056 CallExprBits.NumPreArgs = NumPreArgs; 1057 RParenLoc = rparenloc; 1058} 1059 1060CallExpr::CallExpr(ASTContext& C, Expr *fn, ArrayRef<Expr*> args, 1061 QualType t, ExprValueKind VK, SourceLocation rparenloc) 1062 : Expr(CallExprClass, t, VK, OK_Ordinary, 1063 fn->isTypeDependent(), 1064 fn->isValueDependent(), 1065 fn->isInstantiationDependent(), 1066 fn->containsUnexpandedParameterPack()), 1067 NumArgs(args.size()) { 1068 1069 SubExprs = new (C) Stmt*[args.size()+PREARGS_START]; 1070 SubExprs[FN] = fn; 1071 for (unsigned i = 0; i != args.size(); ++i) { 1072 if (args[i]->isTypeDependent()) 1073 ExprBits.TypeDependent = true; 1074 if (args[i]->isValueDependent()) 1075 ExprBits.ValueDependent = true; 1076 if (args[i]->isInstantiationDependent()) 1077 ExprBits.InstantiationDependent = true; 1078 if (args[i]->containsUnexpandedParameterPack()) 1079 ExprBits.ContainsUnexpandedParameterPack = true; 1080 1081 SubExprs[i+PREARGS_START] = args[i]; 1082 } 1083 1084 CallExprBits.NumPreArgs = 0; 1085 RParenLoc = rparenloc; 1086} 1087 1088CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty) 1089 : Expr(SC, Empty), SubExprs(0), NumArgs(0) { 1090 // FIXME: Why do we allocate this? 1091 SubExprs = new (C) Stmt*[PREARGS_START]; 1092 CallExprBits.NumPreArgs = 0; 1093} 1094 1095CallExpr::CallExpr(ASTContext &C, StmtClass SC, unsigned NumPreArgs, 1096 EmptyShell Empty) 1097 : Expr(SC, Empty), SubExprs(0), NumArgs(0) { 1098 // FIXME: Why do we allocate this? 1099 SubExprs = new (C) Stmt*[PREARGS_START+NumPreArgs]; 1100 CallExprBits.NumPreArgs = NumPreArgs; 1101} 1102 1103Decl *CallExpr::getCalleeDecl() { 1104 Expr *CEE = getCallee()->IgnoreParenImpCasts(); 1105 1106 while (SubstNonTypeTemplateParmExpr *NTTP 1107 = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE)) { 1108 CEE = NTTP->getReplacement()->IgnoreParenCasts(); 1109 } 1110 1111 // If we're calling a dereference, look at the pointer instead. 1112 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CEE)) { 1113 if (BO->isPtrMemOp()) 1114 CEE = BO->getRHS()->IgnoreParenCasts(); 1115 } else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(CEE)) { 1116 if (UO->getOpcode() == UO_Deref) 1117 CEE = UO->getSubExpr()->IgnoreParenCasts(); 1118 } 1119 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) 1120 return DRE->getDecl(); 1121 if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE)) 1122 return ME->getMemberDecl(); 1123 1124 return 0; 1125} 1126 1127FunctionDecl *CallExpr::getDirectCallee() { 1128 return dyn_cast_or_null<FunctionDecl>(getCalleeDecl()); 1129} 1130 1131/// setNumArgs - This changes the number of arguments present in this call. 1132/// Any orphaned expressions are deleted by this, and any new operands are set 1133/// to null. 1134void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) { 1135 // No change, just return. 1136 if (NumArgs == getNumArgs()) return; 1137 1138 // If shrinking # arguments, just delete the extras and forgot them. 1139 if (NumArgs < getNumArgs()) { 1140 this->NumArgs = NumArgs; 1141 return; 1142 } 1143 1144 // Otherwise, we are growing the # arguments. New an bigger argument array. 1145 unsigned NumPreArgs = getNumPreArgs(); 1146 Stmt **NewSubExprs = new (C) Stmt*[NumArgs+PREARGS_START+NumPreArgs]; 1147 // Copy over args. 1148 for (unsigned i = 0; i != getNumArgs()+PREARGS_START+NumPreArgs; ++i) 1149 NewSubExprs[i] = SubExprs[i]; 1150 // Null out new args. 1151 for (unsigned i = getNumArgs()+PREARGS_START+NumPreArgs; 1152 i != NumArgs+PREARGS_START+NumPreArgs; ++i) 1153 NewSubExprs[i] = 0; 1154 1155 if (SubExprs) C.Deallocate(SubExprs); 1156 SubExprs = NewSubExprs; 1157 this->NumArgs = NumArgs; 1158} 1159 1160/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If 1161/// not, return 0. 1162unsigned CallExpr::isBuiltinCall() const { 1163 // All simple function calls (e.g. func()) are implicitly cast to pointer to 1164 // function. As a result, we try and obtain the DeclRefExpr from the 1165 // ImplicitCastExpr. 1166 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 1167 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 1168 return 0; 1169 1170 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 1171 if (!DRE) 1172 return 0; 1173 1174 const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 1175 if (!FDecl) 1176 return 0; 1177 1178 if (!FDecl->getIdentifier()) 1179 return 0; 1180 1181 return FDecl->getBuiltinID(); 1182} 1183 1184bool CallExpr::isUnevaluatedBuiltinCall(ASTContext &Ctx) const { 1185 if (unsigned BI = isBuiltinCall()) 1186 return Ctx.BuiltinInfo.isUnevaluated(BI); 1187 return false; 1188} 1189 1190QualType CallExpr::getCallReturnType() const { 1191 QualType CalleeType = getCallee()->getType(); 1192 if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>()) 1193 CalleeType = FnTypePtr->getPointeeType(); 1194 else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>()) 1195 CalleeType = BPT->getPointeeType(); 1196 else if (CalleeType->isSpecificPlaceholderType(BuiltinType::BoundMember)) 1197 // This should never be overloaded and so should never return null. 1198 CalleeType = Expr::findBoundMemberType(getCallee()); 1199 1200 const FunctionType *FnType = CalleeType->castAs<FunctionType>(); 1201 return FnType->getResultType(); 1202} 1203 1204SourceLocation CallExpr::getLocStart() const { 1205 if (isa<CXXOperatorCallExpr>(this)) 1206 return cast<CXXOperatorCallExpr>(this)->getLocStart(); 1207 1208 SourceLocation begin = getCallee()->getLocStart(); 1209 if (begin.isInvalid() && getNumArgs() > 0) 1210 begin = getArg(0)->getLocStart(); 1211 return begin; 1212} 1213SourceLocation CallExpr::getLocEnd() const { 1214 if (isa<CXXOperatorCallExpr>(this)) 1215 return cast<CXXOperatorCallExpr>(this)->getLocEnd(); 1216 1217 SourceLocation end = getRParenLoc(); 1218 if (end.isInvalid() && getNumArgs() > 0) 1219 end = getArg(getNumArgs() - 1)->getLocEnd(); 1220 return end; 1221} 1222 1223OffsetOfExpr *OffsetOfExpr::Create(ASTContext &C, QualType type, 1224 SourceLocation OperatorLoc, 1225 TypeSourceInfo *tsi, 1226 ArrayRef<OffsetOfNode> comps, 1227 ArrayRef<Expr*> exprs, 1228 SourceLocation RParenLoc) { 1229 void *Mem = C.Allocate(sizeof(OffsetOfExpr) + 1230 sizeof(OffsetOfNode) * comps.size() + 1231 sizeof(Expr*) * exprs.size()); 1232 1233 return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, comps, exprs, 1234 RParenLoc); 1235} 1236 1237OffsetOfExpr *OffsetOfExpr::CreateEmpty(ASTContext &C, 1238 unsigned numComps, unsigned numExprs) { 1239 void *Mem = C.Allocate(sizeof(OffsetOfExpr) + 1240 sizeof(OffsetOfNode) * numComps + 1241 sizeof(Expr*) * numExprs); 1242 return new (Mem) OffsetOfExpr(numComps, numExprs); 1243} 1244 1245OffsetOfExpr::OffsetOfExpr(ASTContext &C, QualType type, 1246 SourceLocation OperatorLoc, TypeSourceInfo *tsi, 1247 ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs, 1248 SourceLocation RParenLoc) 1249 : Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary, 1250 /*TypeDependent=*/false, 1251 /*ValueDependent=*/tsi->getType()->isDependentType(), 1252 tsi->getType()->isInstantiationDependentType(), 1253 tsi->getType()->containsUnexpandedParameterPack()), 1254 OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi), 1255 NumComps(comps.size()), NumExprs(exprs.size()) 1256{ 1257 for (unsigned i = 0; i != comps.size(); ++i) { 1258 setComponent(i, comps[i]); 1259 } 1260 1261 for (unsigned i = 0; i != exprs.size(); ++i) { 1262 if (exprs[i]->isTypeDependent() || exprs[i]->isValueDependent()) 1263 ExprBits.ValueDependent = true; 1264 if (exprs[i]->containsUnexpandedParameterPack()) 1265 ExprBits.ContainsUnexpandedParameterPack = true; 1266 1267 setIndexExpr(i, exprs[i]); 1268 } 1269} 1270 1271IdentifierInfo *OffsetOfExpr::OffsetOfNode::getFieldName() const { 1272 assert(getKind() == Field || getKind() == Identifier); 1273 if (getKind() == Field) 1274 return getField()->getIdentifier(); 1275 1276 return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask); 1277} 1278 1279MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow, 1280 NestedNameSpecifierLoc QualifierLoc, 1281 SourceLocation TemplateKWLoc, 1282 ValueDecl *memberdecl, 1283 DeclAccessPair founddecl, 1284 DeclarationNameInfo nameinfo, 1285 const TemplateArgumentListInfo *targs, 1286 QualType ty, 1287 ExprValueKind vk, 1288 ExprObjectKind ok) { 1289 std::size_t Size = sizeof(MemberExpr); 1290 1291 bool hasQualOrFound = (QualifierLoc || 1292 founddecl.getDecl() != memberdecl || 1293 founddecl.getAccess() != memberdecl->getAccess()); 1294 if (hasQualOrFound) 1295 Size += sizeof(MemberNameQualifier); 1296 1297 if (targs) 1298 Size += ASTTemplateKWAndArgsInfo::sizeFor(targs->size()); 1299 else if (TemplateKWLoc.isValid()) 1300 Size += ASTTemplateKWAndArgsInfo::sizeFor(0); 1301 1302 void *Mem = C.Allocate(Size, llvm::alignOf<MemberExpr>()); 1303 MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, nameinfo, 1304 ty, vk, ok); 1305 1306 if (hasQualOrFound) { 1307 // FIXME: Wrong. We should be looking at the member declaration we found. 1308 if (QualifierLoc && QualifierLoc.getNestedNameSpecifier()->isDependent()) { 1309 E->setValueDependent(true); 1310 E->setTypeDependent(true); 1311 E->setInstantiationDependent(true); 1312 } 1313 else if (QualifierLoc && 1314 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) 1315 E->setInstantiationDependent(true); 1316 1317 E->HasQualifierOrFoundDecl = true; 1318 1319 MemberNameQualifier *NQ = E->getMemberQualifier(); 1320 NQ->QualifierLoc = QualifierLoc; 1321 NQ->FoundDecl = founddecl; 1322 } 1323 1324 E->HasTemplateKWAndArgsInfo = (targs || TemplateKWLoc.isValid()); 1325 1326 if (targs) { 1327 bool Dependent = false; 1328 bool InstantiationDependent = false; 1329 bool ContainsUnexpandedParameterPack = false; 1330 E->getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *targs, 1331 Dependent, 1332 InstantiationDependent, 1333 ContainsUnexpandedParameterPack); 1334 if (InstantiationDependent) 1335 E->setInstantiationDependent(true); 1336 } else if (TemplateKWLoc.isValid()) { 1337 E->getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 1338 } 1339 1340 return E; 1341} 1342 1343SourceLocation MemberExpr::getLocStart() const { 1344 if (isImplicitAccess()) { 1345 if (hasQualifier()) 1346 return getQualifierLoc().getBeginLoc(); 1347 return MemberLoc; 1348 } 1349 1350 // FIXME: We don't want this to happen. Rather, we should be able to 1351 // detect all kinds of implicit accesses more cleanly. 1352 SourceLocation BaseStartLoc = getBase()->getLocStart(); 1353 if (BaseStartLoc.isValid()) 1354 return BaseStartLoc; 1355 return MemberLoc; 1356} 1357SourceLocation MemberExpr::getLocEnd() const { 1358 SourceLocation EndLoc = getMemberNameInfo().getEndLoc(); 1359 if (hasExplicitTemplateArgs()) 1360 EndLoc = getRAngleLoc(); 1361 else if (EndLoc.isInvalid()) 1362 EndLoc = getBase()->getLocEnd(); 1363 return EndLoc; 1364} 1365 1366void CastExpr::CheckCastConsistency() const { 1367 switch (getCastKind()) { 1368 case CK_DerivedToBase: 1369 case CK_UncheckedDerivedToBase: 1370 case CK_DerivedToBaseMemberPointer: 1371 case CK_BaseToDerived: 1372 case CK_BaseToDerivedMemberPointer: 1373 assert(!path_empty() && "Cast kind should have a base path!"); 1374 break; 1375 1376 case CK_CPointerToObjCPointerCast: 1377 assert(getType()->isObjCObjectPointerType()); 1378 assert(getSubExpr()->getType()->isPointerType()); 1379 goto CheckNoBasePath; 1380 1381 case CK_BlockPointerToObjCPointerCast: 1382 assert(getType()->isObjCObjectPointerType()); 1383 assert(getSubExpr()->getType()->isBlockPointerType()); 1384 goto CheckNoBasePath; 1385 1386 case CK_ReinterpretMemberPointer: 1387 assert(getType()->isMemberPointerType()); 1388 assert(getSubExpr()->getType()->isMemberPointerType()); 1389 goto CheckNoBasePath; 1390 1391 case CK_BitCast: 1392 // Arbitrary casts to C pointer types count as bitcasts. 1393 // Otherwise, we should only have block and ObjC pointer casts 1394 // here if they stay within the type kind. 1395 if (!getType()->isPointerType()) { 1396 assert(getType()->isObjCObjectPointerType() == 1397 getSubExpr()->getType()->isObjCObjectPointerType()); 1398 assert(getType()->isBlockPointerType() == 1399 getSubExpr()->getType()->isBlockPointerType()); 1400 } 1401 goto CheckNoBasePath; 1402 1403 case CK_AnyPointerToBlockPointerCast: 1404 assert(getType()->isBlockPointerType()); 1405 assert(getSubExpr()->getType()->isAnyPointerType() && 1406 !getSubExpr()->getType()->isBlockPointerType()); 1407 goto CheckNoBasePath; 1408 1409 case CK_CopyAndAutoreleaseBlockObject: 1410 assert(getType()->isBlockPointerType()); 1411 assert(getSubExpr()->getType()->isBlockPointerType()); 1412 goto CheckNoBasePath; 1413 1414 case CK_FunctionToPointerDecay: 1415 assert(getType()->isPointerType()); 1416 assert(getSubExpr()->getType()->isFunctionType()); 1417 goto CheckNoBasePath; 1418 1419 // These should not have an inheritance path. 1420 case CK_Dynamic: 1421 case CK_ToUnion: 1422 case CK_ArrayToPointerDecay: 1423 case CK_NullToMemberPointer: 1424 case CK_NullToPointer: 1425 case CK_ConstructorConversion: 1426 case CK_IntegralToPointer: 1427 case CK_PointerToIntegral: 1428 case CK_ToVoid: 1429 case CK_VectorSplat: 1430 case CK_IntegralCast: 1431 case CK_IntegralToFloating: 1432 case CK_FloatingToIntegral: 1433 case CK_FloatingCast: 1434 case CK_ObjCObjectLValueCast: 1435 case CK_FloatingRealToComplex: 1436 case CK_FloatingComplexToReal: 1437 case CK_FloatingComplexCast: 1438 case CK_FloatingComplexToIntegralComplex: 1439 case CK_IntegralRealToComplex: 1440 case CK_IntegralComplexToReal: 1441 case CK_IntegralComplexCast: 1442 case CK_IntegralComplexToFloatingComplex: 1443 case CK_ARCProduceObject: 1444 case CK_ARCConsumeObject: 1445 case CK_ARCReclaimReturnedObject: 1446 case CK_ARCExtendBlockObject: 1447 case CK_ZeroToOCLEvent: 1448 assert(!getType()->isBooleanType() && "unheralded conversion to bool"); 1449 goto CheckNoBasePath; 1450 1451 case CK_Dependent: 1452 case CK_LValueToRValue: 1453 case CK_NoOp: 1454 case CK_AtomicToNonAtomic: 1455 case CK_NonAtomicToAtomic: 1456 case CK_PointerToBoolean: 1457 case CK_IntegralToBoolean: 1458 case CK_FloatingToBoolean: 1459 case CK_MemberPointerToBoolean: 1460 case CK_FloatingComplexToBoolean: 1461 case CK_IntegralComplexToBoolean: 1462 case CK_LValueBitCast: // -> bool& 1463 case CK_UserDefinedConversion: // operator bool() 1464 case CK_BuiltinFnToFnPtr: 1465 CheckNoBasePath: 1466 assert(path_empty() && "Cast kind should not have a base path!"); 1467 break; 1468 } 1469} 1470 1471const char *CastExpr::getCastKindName() const { 1472 switch (getCastKind()) { 1473 case CK_Dependent: 1474 return "Dependent"; 1475 case CK_BitCast: 1476 return "BitCast"; 1477 case CK_LValueBitCast: 1478 return "LValueBitCast"; 1479 case CK_LValueToRValue: 1480 return "LValueToRValue"; 1481 case CK_NoOp: 1482 return "NoOp"; 1483 case CK_BaseToDerived: 1484 return "BaseToDerived"; 1485 case CK_DerivedToBase: 1486 return "DerivedToBase"; 1487 case CK_UncheckedDerivedToBase: 1488 return "UncheckedDerivedToBase"; 1489 case CK_Dynamic: 1490 return "Dynamic"; 1491 case CK_ToUnion: 1492 return "ToUnion"; 1493 case CK_ArrayToPointerDecay: 1494 return "ArrayToPointerDecay"; 1495 case CK_FunctionToPointerDecay: 1496 return "FunctionToPointerDecay"; 1497 case CK_NullToMemberPointer: 1498 return "NullToMemberPointer"; 1499 case CK_NullToPointer: 1500 return "NullToPointer"; 1501 case CK_BaseToDerivedMemberPointer: 1502 return "BaseToDerivedMemberPointer"; 1503 case CK_DerivedToBaseMemberPointer: 1504 return "DerivedToBaseMemberPointer"; 1505 case CK_ReinterpretMemberPointer: 1506 return "ReinterpretMemberPointer"; 1507 case CK_UserDefinedConversion: 1508 return "UserDefinedConversion"; 1509 case CK_ConstructorConversion: 1510 return "ConstructorConversion"; 1511 case CK_IntegralToPointer: 1512 return "IntegralToPointer"; 1513 case CK_PointerToIntegral: 1514 return "PointerToIntegral"; 1515 case CK_PointerToBoolean: 1516 return "PointerToBoolean"; 1517 case CK_ToVoid: 1518 return "ToVoid"; 1519 case CK_VectorSplat: 1520 return "VectorSplat"; 1521 case CK_IntegralCast: 1522 return "IntegralCast"; 1523 case CK_IntegralToBoolean: 1524 return "IntegralToBoolean"; 1525 case CK_IntegralToFloating: 1526 return "IntegralToFloating"; 1527 case CK_FloatingToIntegral: 1528 return "FloatingToIntegral"; 1529 case CK_FloatingCast: 1530 return "FloatingCast"; 1531 case CK_FloatingToBoolean: 1532 return "FloatingToBoolean"; 1533 case CK_MemberPointerToBoolean: 1534 return "MemberPointerToBoolean"; 1535 case CK_CPointerToObjCPointerCast: 1536 return "CPointerToObjCPointerCast"; 1537 case CK_BlockPointerToObjCPointerCast: 1538 return "BlockPointerToObjCPointerCast"; 1539 case CK_AnyPointerToBlockPointerCast: 1540 return "AnyPointerToBlockPointerCast"; 1541 case CK_ObjCObjectLValueCast: 1542 return "ObjCObjectLValueCast"; 1543 case CK_FloatingRealToComplex: 1544 return "FloatingRealToComplex"; 1545 case CK_FloatingComplexToReal: 1546 return "FloatingComplexToReal"; 1547 case CK_FloatingComplexToBoolean: 1548 return "FloatingComplexToBoolean"; 1549 case CK_FloatingComplexCast: 1550 return "FloatingComplexCast"; 1551 case CK_FloatingComplexToIntegralComplex: 1552 return "FloatingComplexToIntegralComplex"; 1553 case CK_IntegralRealToComplex: 1554 return "IntegralRealToComplex"; 1555 case CK_IntegralComplexToReal: 1556 return "IntegralComplexToReal"; 1557 case CK_IntegralComplexToBoolean: 1558 return "IntegralComplexToBoolean"; 1559 case CK_IntegralComplexCast: 1560 return "IntegralComplexCast"; 1561 case CK_IntegralComplexToFloatingComplex: 1562 return "IntegralComplexToFloatingComplex"; 1563 case CK_ARCConsumeObject: 1564 return "ARCConsumeObject"; 1565 case CK_ARCProduceObject: 1566 return "ARCProduceObject"; 1567 case CK_ARCReclaimReturnedObject: 1568 return "ARCReclaimReturnedObject"; 1569 case CK_ARCExtendBlockObject: 1570 return "ARCCExtendBlockObject"; 1571 case CK_AtomicToNonAtomic: 1572 return "AtomicToNonAtomic"; 1573 case CK_NonAtomicToAtomic: 1574 return "NonAtomicToAtomic"; 1575 case CK_CopyAndAutoreleaseBlockObject: 1576 return "CopyAndAutoreleaseBlockObject"; 1577 case CK_BuiltinFnToFnPtr: 1578 return "BuiltinFnToFnPtr"; 1579 case CK_ZeroToOCLEvent: 1580 return "ZeroToOCLEvent"; 1581 } 1582 1583 llvm_unreachable("Unhandled cast kind!"); 1584} 1585 1586Expr *CastExpr::getSubExprAsWritten() { 1587 Expr *SubExpr = 0; 1588 CastExpr *E = this; 1589 do { 1590 SubExpr = E->getSubExpr(); 1591 1592 // Skip through reference binding to temporary. 1593 if (MaterializeTemporaryExpr *Materialize 1594 = dyn_cast<MaterializeTemporaryExpr>(SubExpr)) 1595 SubExpr = Materialize->GetTemporaryExpr(); 1596 1597 // Skip any temporary bindings; they're implicit. 1598 if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr)) 1599 SubExpr = Binder->getSubExpr(); 1600 1601 // Conversions by constructor and conversion functions have a 1602 // subexpression describing the call; strip it off. 1603 if (E->getCastKind() == CK_ConstructorConversion) 1604 SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0); 1605 else if (E->getCastKind() == CK_UserDefinedConversion) 1606 SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument(); 1607 1608 // If the subexpression we're left with is an implicit cast, look 1609 // through that, too. 1610 } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr))); 1611 1612 return SubExpr; 1613} 1614 1615CXXBaseSpecifier **CastExpr::path_buffer() { 1616 switch (getStmtClass()) { 1617#define ABSTRACT_STMT(x) 1618#define CASTEXPR(Type, Base) \ 1619 case Stmt::Type##Class: \ 1620 return reinterpret_cast<CXXBaseSpecifier**>(static_cast<Type*>(this)+1); 1621#define STMT(Type, Base) 1622#include "clang/AST/StmtNodes.inc" 1623 default: 1624 llvm_unreachable("non-cast expressions not possible here"); 1625 } 1626} 1627 1628void CastExpr::setCastPath(const CXXCastPath &Path) { 1629 assert(Path.size() == path_size()); 1630 memcpy(path_buffer(), Path.data(), Path.size() * sizeof(CXXBaseSpecifier*)); 1631} 1632 1633ImplicitCastExpr *ImplicitCastExpr::Create(ASTContext &C, QualType T, 1634 CastKind Kind, Expr *Operand, 1635 const CXXCastPath *BasePath, 1636 ExprValueKind VK) { 1637 unsigned PathSize = (BasePath ? BasePath->size() : 0); 1638 void *Buffer = 1639 C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 1640 ImplicitCastExpr *E = 1641 new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK); 1642 if (PathSize) E->setCastPath(*BasePath); 1643 return E; 1644} 1645 1646ImplicitCastExpr *ImplicitCastExpr::CreateEmpty(ASTContext &C, 1647 unsigned PathSize) { 1648 void *Buffer = 1649 C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 1650 return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize); 1651} 1652 1653 1654CStyleCastExpr *CStyleCastExpr::Create(ASTContext &C, QualType T, 1655 ExprValueKind VK, CastKind K, Expr *Op, 1656 const CXXCastPath *BasePath, 1657 TypeSourceInfo *WrittenTy, 1658 SourceLocation L, SourceLocation R) { 1659 unsigned PathSize = (BasePath ? BasePath->size() : 0); 1660 void *Buffer = 1661 C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 1662 CStyleCastExpr *E = 1663 new (Buffer) CStyleCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, R); 1664 if (PathSize) E->setCastPath(*BasePath); 1665 return E; 1666} 1667 1668CStyleCastExpr *CStyleCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) { 1669 void *Buffer = 1670 C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 1671 return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize); 1672} 1673 1674/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 1675/// corresponds to, e.g. "<<=". 1676StringRef BinaryOperator::getOpcodeStr(Opcode Op) { 1677 switch (Op) { 1678 case BO_PtrMemD: return ".*"; 1679 case BO_PtrMemI: return "->*"; 1680 case BO_Mul: return "*"; 1681 case BO_Div: return "/"; 1682 case BO_Rem: return "%"; 1683 case BO_Add: return "+"; 1684 case BO_Sub: return "-"; 1685 case BO_Shl: return "<<"; 1686 case BO_Shr: return ">>"; 1687 case BO_LT: return "<"; 1688 case BO_GT: return ">"; 1689 case BO_LE: return "<="; 1690 case BO_GE: return ">="; 1691 case BO_EQ: return "=="; 1692 case BO_NE: return "!="; 1693 case BO_And: return "&"; 1694 case BO_Xor: return "^"; 1695 case BO_Or: return "|"; 1696 case BO_LAnd: return "&&"; 1697 case BO_LOr: return "||"; 1698 case BO_Assign: return "="; 1699 case BO_MulAssign: return "*="; 1700 case BO_DivAssign: return "/="; 1701 case BO_RemAssign: return "%="; 1702 case BO_AddAssign: return "+="; 1703 case BO_SubAssign: return "-="; 1704 case BO_ShlAssign: return "<<="; 1705 case BO_ShrAssign: return ">>="; 1706 case BO_AndAssign: return "&="; 1707 case BO_XorAssign: return "^="; 1708 case BO_OrAssign: return "|="; 1709 case BO_Comma: return ","; 1710 } 1711 1712 llvm_unreachable("Invalid OpCode!"); 1713} 1714 1715BinaryOperatorKind 1716BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) { 1717 switch (OO) { 1718 default: llvm_unreachable("Not an overloadable binary operator"); 1719 case OO_Plus: return BO_Add; 1720 case OO_Minus: return BO_Sub; 1721 case OO_Star: return BO_Mul; 1722 case OO_Slash: return BO_Div; 1723 case OO_Percent: return BO_Rem; 1724 case OO_Caret: return BO_Xor; 1725 case OO_Amp: return BO_And; 1726 case OO_Pipe: return BO_Or; 1727 case OO_Equal: return BO_Assign; 1728 case OO_Less: return BO_LT; 1729 case OO_Greater: return BO_GT; 1730 case OO_PlusEqual: return BO_AddAssign; 1731 case OO_MinusEqual: return BO_SubAssign; 1732 case OO_StarEqual: return BO_MulAssign; 1733 case OO_SlashEqual: return BO_DivAssign; 1734 case OO_PercentEqual: return BO_RemAssign; 1735 case OO_CaretEqual: return BO_XorAssign; 1736 case OO_AmpEqual: return BO_AndAssign; 1737 case OO_PipeEqual: return BO_OrAssign; 1738 case OO_LessLess: return BO_Shl; 1739 case OO_GreaterGreater: return BO_Shr; 1740 case OO_LessLessEqual: return BO_ShlAssign; 1741 case OO_GreaterGreaterEqual: return BO_ShrAssign; 1742 case OO_EqualEqual: return BO_EQ; 1743 case OO_ExclaimEqual: return BO_NE; 1744 case OO_LessEqual: return BO_LE; 1745 case OO_GreaterEqual: return BO_GE; 1746 case OO_AmpAmp: return BO_LAnd; 1747 case OO_PipePipe: return BO_LOr; 1748 case OO_Comma: return BO_Comma; 1749 case OO_ArrowStar: return BO_PtrMemI; 1750 } 1751} 1752 1753OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) { 1754 static const OverloadedOperatorKind OverOps[] = { 1755 /* .* Cannot be overloaded */OO_None, OO_ArrowStar, 1756 OO_Star, OO_Slash, OO_Percent, 1757 OO_Plus, OO_Minus, 1758 OO_LessLess, OO_GreaterGreater, 1759 OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual, 1760 OO_EqualEqual, OO_ExclaimEqual, 1761 OO_Amp, 1762 OO_Caret, 1763 OO_Pipe, 1764 OO_AmpAmp, 1765 OO_PipePipe, 1766 OO_Equal, OO_StarEqual, 1767 OO_SlashEqual, OO_PercentEqual, 1768 OO_PlusEqual, OO_MinusEqual, 1769 OO_LessLessEqual, OO_GreaterGreaterEqual, 1770 OO_AmpEqual, OO_CaretEqual, 1771 OO_PipeEqual, 1772 OO_Comma 1773 }; 1774 return OverOps[Opc]; 1775} 1776 1777InitListExpr::InitListExpr(ASTContext &C, SourceLocation lbraceloc, 1778 ArrayRef<Expr*> initExprs, SourceLocation rbraceloc) 1779 : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false, 1780 false, false), 1781 InitExprs(C, initExprs.size()), 1782 LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), AltForm(0, true) 1783{ 1784 sawArrayRangeDesignator(false); 1785 setInitializesStdInitializerList(false); 1786 for (unsigned I = 0; I != initExprs.size(); ++I) { 1787 if (initExprs[I]->isTypeDependent()) 1788 ExprBits.TypeDependent = true; 1789 if (initExprs[I]->isValueDependent()) 1790 ExprBits.ValueDependent = true; 1791 if (initExprs[I]->isInstantiationDependent()) 1792 ExprBits.InstantiationDependent = true; 1793 if (initExprs[I]->containsUnexpandedParameterPack()) 1794 ExprBits.ContainsUnexpandedParameterPack = true; 1795 } 1796 1797 InitExprs.insert(C, InitExprs.end(), initExprs.begin(), initExprs.end()); 1798} 1799 1800void InitListExpr::reserveInits(ASTContext &C, unsigned NumInits) { 1801 if (NumInits > InitExprs.size()) 1802 InitExprs.reserve(C, NumInits); 1803} 1804 1805void InitListExpr::resizeInits(ASTContext &C, unsigned NumInits) { 1806 InitExprs.resize(C, NumInits, 0); 1807} 1808 1809Expr *InitListExpr::updateInit(ASTContext &C, unsigned Init, Expr *expr) { 1810 if (Init >= InitExprs.size()) { 1811 InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, 0); 1812 InitExprs.back() = expr; 1813 return 0; 1814 } 1815 1816 Expr *Result = cast_or_null<Expr>(InitExprs[Init]); 1817 InitExprs[Init] = expr; 1818 return Result; 1819} 1820 1821void InitListExpr::setArrayFiller(Expr *filler) { 1822 assert(!hasArrayFiller() && "Filler already set!"); 1823 ArrayFillerOrUnionFieldInit = filler; 1824 // Fill out any "holes" in the array due to designated initializers. 1825 Expr **inits = getInits(); 1826 for (unsigned i = 0, e = getNumInits(); i != e; ++i) 1827 if (inits[i] == 0) 1828 inits[i] = filler; 1829} 1830 1831bool InitListExpr::isStringLiteralInit() const { 1832 if (getNumInits() != 1) 1833 return false; 1834 const ArrayType *AT = getType()->getAsArrayTypeUnsafe(); 1835 if (!AT || !AT->getElementType()->isIntegerType()) 1836 return false; 1837 const Expr *Init = getInit(0)->IgnoreParens(); 1838 return isa<StringLiteral>(Init) || isa<ObjCEncodeExpr>(Init); 1839} 1840 1841SourceLocation InitListExpr::getLocStart() const { 1842 if (InitListExpr *SyntacticForm = getSyntacticForm()) 1843 return SyntacticForm->getLocStart(); 1844 SourceLocation Beg = LBraceLoc; 1845 if (Beg.isInvalid()) { 1846 // Find the first non-null initializer. 1847 for (InitExprsTy::const_iterator I = InitExprs.begin(), 1848 E = InitExprs.end(); 1849 I != E; ++I) { 1850 if (Stmt *S = *I) { 1851 Beg = S->getLocStart(); 1852 break; 1853 } 1854 } 1855 } 1856 return Beg; 1857} 1858 1859SourceLocation InitListExpr::getLocEnd() const { 1860 if (InitListExpr *SyntacticForm = getSyntacticForm()) 1861 return SyntacticForm->getLocEnd(); 1862 SourceLocation End = RBraceLoc; 1863 if (End.isInvalid()) { 1864 // Find the first non-null initializer from the end. 1865 for (InitExprsTy::const_reverse_iterator I = InitExprs.rbegin(), 1866 E = InitExprs.rend(); 1867 I != E; ++I) { 1868 if (Stmt *S = *I) { 1869 End = S->getLocEnd(); 1870 break; 1871 } 1872 } 1873 } 1874 return End; 1875} 1876 1877/// getFunctionType - Return the underlying function type for this block. 1878/// 1879const FunctionProtoType *BlockExpr::getFunctionType() const { 1880 // The block pointer is never sugared, but the function type might be. 1881 return cast<BlockPointerType>(getType()) 1882 ->getPointeeType()->castAs<FunctionProtoType>(); 1883} 1884 1885SourceLocation BlockExpr::getCaretLocation() const { 1886 return TheBlock->getCaretLocation(); 1887} 1888const Stmt *BlockExpr::getBody() const { 1889 return TheBlock->getBody(); 1890} 1891Stmt *BlockExpr::getBody() { 1892 return TheBlock->getBody(); 1893} 1894 1895 1896//===----------------------------------------------------------------------===// 1897// Generic Expression Routines 1898//===----------------------------------------------------------------------===// 1899 1900/// isUnusedResultAWarning - Return true if this immediate expression should 1901/// be warned about if the result is unused. If so, fill in Loc and Ranges 1902/// with location to warn on and the source range[s] to report with the 1903/// warning. 1904bool Expr::isUnusedResultAWarning(const Expr *&WarnE, SourceLocation &Loc, 1905 SourceRange &R1, SourceRange &R2, 1906 ASTContext &Ctx) const { 1907 // Don't warn if the expr is type dependent. The type could end up 1908 // instantiating to void. 1909 if (isTypeDependent()) 1910 return false; 1911 1912 switch (getStmtClass()) { 1913 default: 1914 if (getType()->isVoidType()) 1915 return false; 1916 WarnE = this; 1917 Loc = getExprLoc(); 1918 R1 = getSourceRange(); 1919 return true; 1920 case ParenExprClass: 1921 return cast<ParenExpr>(this)->getSubExpr()-> 1922 isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 1923 case GenericSelectionExprClass: 1924 return cast<GenericSelectionExpr>(this)->getResultExpr()-> 1925 isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 1926 case UnaryOperatorClass: { 1927 const UnaryOperator *UO = cast<UnaryOperator>(this); 1928 1929 switch (UO->getOpcode()) { 1930 case UO_Plus: 1931 case UO_Minus: 1932 case UO_AddrOf: 1933 case UO_Not: 1934 case UO_LNot: 1935 case UO_Deref: 1936 break; 1937 case UO_PostInc: 1938 case UO_PostDec: 1939 case UO_PreInc: 1940 case UO_PreDec: // ++/-- 1941 return false; // Not a warning. 1942 case UO_Real: 1943 case UO_Imag: 1944 // accessing a piece of a volatile complex is a side-effect. 1945 if (Ctx.getCanonicalType(UO->getSubExpr()->getType()) 1946 .isVolatileQualified()) 1947 return false; 1948 break; 1949 case UO_Extension: 1950 return UO->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 1951 } 1952 WarnE = this; 1953 Loc = UO->getOperatorLoc(); 1954 R1 = UO->getSubExpr()->getSourceRange(); 1955 return true; 1956 } 1957 case BinaryOperatorClass: { 1958 const BinaryOperator *BO = cast<BinaryOperator>(this); 1959 switch (BO->getOpcode()) { 1960 default: 1961 break; 1962 // Consider the RHS of comma for side effects. LHS was checked by 1963 // Sema::CheckCommaOperands. 1964 case BO_Comma: 1965 // ((foo = <blah>), 0) is an idiom for hiding the result (and 1966 // lvalue-ness) of an assignment written in a macro. 1967 if (IntegerLiteral *IE = 1968 dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens())) 1969 if (IE->getValue() == 0) 1970 return false; 1971 return BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 1972 // Consider '||', '&&' to have side effects if the LHS or RHS does. 1973 case BO_LAnd: 1974 case BO_LOr: 1975 if (!BO->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) || 1976 !BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)) 1977 return false; 1978 break; 1979 } 1980 if (BO->isAssignmentOp()) 1981 return false; 1982 WarnE = this; 1983 Loc = BO->getOperatorLoc(); 1984 R1 = BO->getLHS()->getSourceRange(); 1985 R2 = BO->getRHS()->getSourceRange(); 1986 return true; 1987 } 1988 case CompoundAssignOperatorClass: 1989 case VAArgExprClass: 1990 case AtomicExprClass: 1991 return false; 1992 1993 case ConditionalOperatorClass: { 1994 // If only one of the LHS or RHS is a warning, the operator might 1995 // be being used for control flow. Only warn if both the LHS and 1996 // RHS are warnings. 1997 const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 1998 if (!Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)) 1999 return false; 2000 if (!Exp->getLHS()) 2001 return true; 2002 return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2003 } 2004 2005 case MemberExprClass: 2006 WarnE = this; 2007 Loc = cast<MemberExpr>(this)->getMemberLoc(); 2008 R1 = SourceRange(Loc, Loc); 2009 R2 = cast<MemberExpr>(this)->getBase()->getSourceRange(); 2010 return true; 2011 2012 case ArraySubscriptExprClass: 2013 WarnE = this; 2014 Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc(); 2015 R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange(); 2016 R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange(); 2017 return true; 2018 2019 case CXXOperatorCallExprClass: { 2020 // We warn about operator== and operator!= even when user-defined operator 2021 // overloads as there is no reasonable way to define these such that they 2022 // have non-trivial, desirable side-effects. See the -Wunused-comparison 2023 // warning: these operators are commonly typo'ed, and so warning on them 2024 // provides additional value as well. If this list is updated, 2025 // DiagnoseUnusedComparison should be as well. 2026 const CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(this); 2027 if (Op->getOperator() == OO_EqualEqual || 2028 Op->getOperator() == OO_ExclaimEqual) { 2029 WarnE = this; 2030 Loc = Op->getOperatorLoc(); 2031 R1 = Op->getSourceRange(); 2032 return true; 2033 } 2034 2035 // Fallthrough for generic call handling. 2036 } 2037 case CallExprClass: 2038 case CXXMemberCallExprClass: 2039 case UserDefinedLiteralClass: { 2040 // If this is a direct call, get the callee. 2041 const CallExpr *CE = cast<CallExpr>(this); 2042 if (const Decl *FD = CE->getCalleeDecl()) { 2043 // If the callee has attribute pure, const, or warn_unused_result, warn 2044 // about it. void foo() { strlen("bar"); } should warn. 2045 // 2046 // Note: If new cases are added here, DiagnoseUnusedExprResult should be 2047 // updated to match for QoI. 2048 if (FD->getAttr<WarnUnusedResultAttr>() || 2049 FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) { 2050 WarnE = this; 2051 Loc = CE->getCallee()->getLocStart(); 2052 R1 = CE->getCallee()->getSourceRange(); 2053 2054 if (unsigned NumArgs = CE->getNumArgs()) 2055 R2 = SourceRange(CE->getArg(0)->getLocStart(), 2056 CE->getArg(NumArgs-1)->getLocEnd()); 2057 return true; 2058 } 2059 } 2060 return false; 2061 } 2062 2063 // If we don't know precisely what we're looking at, let's not warn. 2064 case UnresolvedLookupExprClass: 2065 case CXXUnresolvedConstructExprClass: 2066 return false; 2067 2068 case CXXTemporaryObjectExprClass: 2069 case CXXConstructExprClass: 2070 return false; 2071 2072 case ObjCMessageExprClass: { 2073 const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this); 2074 if (Ctx.getLangOpts().ObjCAutoRefCount && 2075 ME->isInstanceMessage() && 2076 !ME->getType()->isVoidType() && 2077 ME->getSelector().getIdentifierInfoForSlot(0) && 2078 ME->getSelector().getIdentifierInfoForSlot(0) 2079 ->getName().startswith("init")) { 2080 WarnE = this; 2081 Loc = getExprLoc(); 2082 R1 = ME->getSourceRange(); 2083 return true; 2084 } 2085 2086 const ObjCMethodDecl *MD = ME->getMethodDecl(); 2087 if (MD && MD->getAttr<WarnUnusedResultAttr>()) { 2088 WarnE = this; 2089 Loc = getExprLoc(); 2090 return true; 2091 } 2092 return false; 2093 } 2094 2095 case ObjCPropertyRefExprClass: 2096 WarnE = this; 2097 Loc = getExprLoc(); 2098 R1 = getSourceRange(); 2099 return true; 2100 2101 case PseudoObjectExprClass: { 2102 const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this); 2103 2104 // Only complain about things that have the form of a getter. 2105 if (isa<UnaryOperator>(PO->getSyntacticForm()) || 2106 isa<BinaryOperator>(PO->getSyntacticForm())) 2107 return false; 2108 2109 WarnE = this; 2110 Loc = getExprLoc(); 2111 R1 = getSourceRange(); 2112 return true; 2113 } 2114 2115 case StmtExprClass: { 2116 // Statement exprs don't logically have side effects themselves, but are 2117 // sometimes used in macros in ways that give them a type that is unused. 2118 // For example ({ blah; foo(); }) will end up with a type if foo has a type. 2119 // however, if the result of the stmt expr is dead, we don't want to emit a 2120 // warning. 2121 const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 2122 if (!CS->body_empty()) { 2123 if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 2124 return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2125 if (const LabelStmt *Label = dyn_cast<LabelStmt>(CS->body_back())) 2126 if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt())) 2127 return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2128 } 2129 2130 if (getType()->isVoidType()) 2131 return false; 2132 WarnE = this; 2133 Loc = cast<StmtExpr>(this)->getLParenLoc(); 2134 R1 = getSourceRange(); 2135 return true; 2136 } 2137 case CXXFunctionalCastExprClass: 2138 case CStyleCastExprClass: { 2139 // Ignore an explicit cast to void unless the operand is a non-trivial 2140 // volatile lvalue. 2141 const CastExpr *CE = cast<CastExpr>(this); 2142 if (CE->getCastKind() == CK_ToVoid) { 2143 if (CE->getSubExpr()->isGLValue() && 2144 CE->getSubExpr()->getType().isVolatileQualified()) { 2145 const DeclRefExpr *DRE = 2146 dyn_cast<DeclRefExpr>(CE->getSubExpr()->IgnoreParens()); 2147 if (!(DRE && isa<VarDecl>(DRE->getDecl()) && 2148 cast<VarDecl>(DRE->getDecl())->hasLocalStorage())) { 2149 return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, 2150 R1, R2, Ctx); 2151 } 2152 } 2153 return false; 2154 } 2155 2156 // If this is a cast to a constructor conversion, check the operand. 2157 // Otherwise, the result of the cast is unused. 2158 if (CE->getCastKind() == CK_ConstructorConversion) 2159 return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2160 2161 WarnE = this; 2162 if (const CXXFunctionalCastExpr *CXXCE = 2163 dyn_cast<CXXFunctionalCastExpr>(this)) { 2164 Loc = CXXCE->getTypeBeginLoc(); 2165 R1 = CXXCE->getSubExpr()->getSourceRange(); 2166 } else { 2167 const CStyleCastExpr *CStyleCE = cast<CStyleCastExpr>(this); 2168 Loc = CStyleCE->getLParenLoc(); 2169 R1 = CStyleCE->getSubExpr()->getSourceRange(); 2170 } 2171 return true; 2172 } 2173 case ImplicitCastExprClass: { 2174 const CastExpr *ICE = cast<ImplicitCastExpr>(this); 2175 2176 // lvalue-to-rvalue conversion on a volatile lvalue is a side-effect. 2177 if (ICE->getCastKind() == CK_LValueToRValue && 2178 ICE->getSubExpr()->getType().isVolatileQualified()) 2179 return false; 2180 2181 return ICE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2182 } 2183 case CXXDefaultArgExprClass: 2184 return (cast<CXXDefaultArgExpr>(this) 2185 ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2186 case CXXDefaultInitExprClass: 2187 return (cast<CXXDefaultInitExpr>(this) 2188 ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2189 2190 case CXXNewExprClass: 2191 // FIXME: In theory, there might be new expressions that don't have side 2192 // effects (e.g. a placement new with an uninitialized POD). 2193 case CXXDeleteExprClass: 2194 return false; 2195 case CXXBindTemporaryExprClass: 2196 return (cast<CXXBindTemporaryExpr>(this) 2197 ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2198 case ExprWithCleanupsClass: 2199 return (cast<ExprWithCleanups>(this) 2200 ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2201 } 2202} 2203 2204/// isOBJCGCCandidate - Check if an expression is objc gc'able. 2205/// returns true, if it is; false otherwise. 2206bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const { 2207 const Expr *E = IgnoreParens(); 2208 switch (E->getStmtClass()) { 2209 default: 2210 return false; 2211 case ObjCIvarRefExprClass: 2212 return true; 2213 case Expr::UnaryOperatorClass: 2214 return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx); 2215 case ImplicitCastExprClass: 2216 return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx); 2217 case MaterializeTemporaryExprClass: 2218 return cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr() 2219 ->isOBJCGCCandidate(Ctx); 2220 case CStyleCastExprClass: 2221 return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx); 2222 case DeclRefExprClass: { 2223 const Decl *D = cast<DeclRefExpr>(E)->getDecl(); 2224 2225 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 2226 if (VD->hasGlobalStorage()) 2227 return true; 2228 QualType T = VD->getType(); 2229 // dereferencing to a pointer is always a gc'able candidate, 2230 // unless it is __weak. 2231 return T->isPointerType() && 2232 (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak); 2233 } 2234 return false; 2235 } 2236 case MemberExprClass: { 2237 const MemberExpr *M = cast<MemberExpr>(E); 2238 return M->getBase()->isOBJCGCCandidate(Ctx); 2239 } 2240 case ArraySubscriptExprClass: 2241 return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx); 2242 } 2243} 2244 2245bool Expr::isBoundMemberFunction(ASTContext &Ctx) const { 2246 if (isTypeDependent()) 2247 return false; 2248 return ClassifyLValue(Ctx) == Expr::LV_MemberFunction; 2249} 2250 2251QualType Expr::findBoundMemberType(const Expr *expr) { 2252 assert(expr->hasPlaceholderType(BuiltinType::BoundMember)); 2253 2254 // Bound member expressions are always one of these possibilities: 2255 // x->m x.m x->*y x.*y 2256 // (possibly parenthesized) 2257 2258 expr = expr->IgnoreParens(); 2259 if (const MemberExpr *mem = dyn_cast<MemberExpr>(expr)) { 2260 assert(isa<CXXMethodDecl>(mem->getMemberDecl())); 2261 return mem->getMemberDecl()->getType(); 2262 } 2263 2264 if (const BinaryOperator *op = dyn_cast<BinaryOperator>(expr)) { 2265 QualType type = op->getRHS()->getType()->castAs<MemberPointerType>() 2266 ->getPointeeType(); 2267 assert(type->isFunctionType()); 2268 return type; 2269 } 2270 2271 assert(isa<UnresolvedMemberExpr>(expr)); 2272 return QualType(); 2273} 2274 2275Expr* Expr::IgnoreParens() { 2276 Expr* E = this; 2277 while (true) { 2278 if (ParenExpr* P = dyn_cast<ParenExpr>(E)) { 2279 E = P->getSubExpr(); 2280 continue; 2281 } 2282 if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) { 2283 if (P->getOpcode() == UO_Extension) { 2284 E = P->getSubExpr(); 2285 continue; 2286 } 2287 } 2288 if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) { 2289 if (!P->isResultDependent()) { 2290 E = P->getResultExpr(); 2291 continue; 2292 } 2293 } 2294 return E; 2295 } 2296} 2297 2298/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 2299/// or CastExprs or ImplicitCastExprs, returning their operand. 2300Expr *Expr::IgnoreParenCasts() { 2301 Expr *E = this; 2302 while (true) { 2303 if (ParenExpr* P = dyn_cast<ParenExpr>(E)) { 2304 E = P->getSubExpr(); 2305 continue; 2306 } 2307 if (CastExpr *P = dyn_cast<CastExpr>(E)) { 2308 E = P->getSubExpr(); 2309 continue; 2310 } 2311 if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) { 2312 if (P->getOpcode() == UO_Extension) { 2313 E = P->getSubExpr(); 2314 continue; 2315 } 2316 } 2317 if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) { 2318 if (!P->isResultDependent()) { 2319 E = P->getResultExpr(); 2320 continue; 2321 } 2322 } 2323 if (MaterializeTemporaryExpr *Materialize 2324 = dyn_cast<MaterializeTemporaryExpr>(E)) { 2325 E = Materialize->GetTemporaryExpr(); 2326 continue; 2327 } 2328 if (SubstNonTypeTemplateParmExpr *NTTP 2329 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2330 E = NTTP->getReplacement(); 2331 continue; 2332 } 2333 return E; 2334 } 2335} 2336 2337/// IgnoreParenLValueCasts - Ignore parentheses and lvalue-to-rvalue 2338/// casts. This is intended purely as a temporary workaround for code 2339/// that hasn't yet been rewritten to do the right thing about those 2340/// casts, and may disappear along with the last internal use. 2341Expr *Expr::IgnoreParenLValueCasts() { 2342 Expr *E = this; 2343 while (true) { 2344 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) { 2345 E = P->getSubExpr(); 2346 continue; 2347 } else if (CastExpr *P = dyn_cast<CastExpr>(E)) { 2348 if (P->getCastKind() == CK_LValueToRValue) { 2349 E = P->getSubExpr(); 2350 continue; 2351 } 2352 } else if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) { 2353 if (P->getOpcode() == UO_Extension) { 2354 E = P->getSubExpr(); 2355 continue; 2356 } 2357 } else if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) { 2358 if (!P->isResultDependent()) { 2359 E = P->getResultExpr(); 2360 continue; 2361 } 2362 } else if (MaterializeTemporaryExpr *Materialize 2363 = dyn_cast<MaterializeTemporaryExpr>(E)) { 2364 E = Materialize->GetTemporaryExpr(); 2365 continue; 2366 } else if (SubstNonTypeTemplateParmExpr *NTTP 2367 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2368 E = NTTP->getReplacement(); 2369 continue; 2370 } 2371 break; 2372 } 2373 return E; 2374} 2375 2376Expr *Expr::ignoreParenBaseCasts() { 2377 Expr *E = this; 2378 while (true) { 2379 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) { 2380 E = P->getSubExpr(); 2381 continue; 2382 } 2383 if (CastExpr *CE = dyn_cast<CastExpr>(E)) { 2384 if (CE->getCastKind() == CK_DerivedToBase || 2385 CE->getCastKind() == CK_UncheckedDerivedToBase || 2386 CE->getCastKind() == CK_NoOp) { 2387 E = CE->getSubExpr(); 2388 continue; 2389 } 2390 } 2391 2392 return E; 2393 } 2394} 2395 2396Expr *Expr::IgnoreParenImpCasts() { 2397 Expr *E = this; 2398 while (true) { 2399 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) { 2400 E = P->getSubExpr(); 2401 continue; 2402 } 2403 if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) { 2404 E = P->getSubExpr(); 2405 continue; 2406 } 2407 if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) { 2408 if (P->getOpcode() == UO_Extension) { 2409 E = P->getSubExpr(); 2410 continue; 2411 } 2412 } 2413 if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) { 2414 if (!P->isResultDependent()) { 2415 E = P->getResultExpr(); 2416 continue; 2417 } 2418 } 2419 if (MaterializeTemporaryExpr *Materialize 2420 = dyn_cast<MaterializeTemporaryExpr>(E)) { 2421 E = Materialize->GetTemporaryExpr(); 2422 continue; 2423 } 2424 if (SubstNonTypeTemplateParmExpr *NTTP 2425 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2426 E = NTTP->getReplacement(); 2427 continue; 2428 } 2429 return E; 2430 } 2431} 2432 2433Expr *Expr::IgnoreConversionOperator() { 2434 if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(this)) { 2435 if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl())) 2436 return MCE->getImplicitObjectArgument(); 2437 } 2438 return this; 2439} 2440 2441/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the 2442/// value (including ptr->int casts of the same size). Strip off any 2443/// ParenExpr or CastExprs, returning their operand. 2444Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) { 2445 Expr *E = this; 2446 while (true) { 2447 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) { 2448 E = P->getSubExpr(); 2449 continue; 2450 } 2451 2452 if (CastExpr *P = dyn_cast<CastExpr>(E)) { 2453 // We ignore integer <-> casts that are of the same width, ptr<->ptr and 2454 // ptr<->int casts of the same width. We also ignore all identity casts. 2455 Expr *SE = P->getSubExpr(); 2456 2457 if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) { 2458 E = SE; 2459 continue; 2460 } 2461 2462 if ((E->getType()->isPointerType() || 2463 E->getType()->isIntegralType(Ctx)) && 2464 (SE->getType()->isPointerType() || 2465 SE->getType()->isIntegralType(Ctx)) && 2466 Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) { 2467 E = SE; 2468 continue; 2469 } 2470 } 2471 2472 if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) { 2473 if (P->getOpcode() == UO_Extension) { 2474 E = P->getSubExpr(); 2475 continue; 2476 } 2477 } 2478 2479 if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) { 2480 if (!P->isResultDependent()) { 2481 E = P->getResultExpr(); 2482 continue; 2483 } 2484 } 2485 2486 if (SubstNonTypeTemplateParmExpr *NTTP 2487 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2488 E = NTTP->getReplacement(); 2489 continue; 2490 } 2491 2492 return E; 2493 } 2494} 2495 2496bool Expr::isDefaultArgument() const { 2497 const Expr *E = this; 2498 if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E)) 2499 E = M->GetTemporaryExpr(); 2500 2501 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 2502 E = ICE->getSubExprAsWritten(); 2503 2504 return isa<CXXDefaultArgExpr>(E); 2505} 2506 2507/// \brief Skip over any no-op casts and any temporary-binding 2508/// expressions. 2509static const Expr *skipTemporaryBindingsNoOpCastsAndParens(const Expr *E) { 2510 if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E)) 2511 E = M->GetTemporaryExpr(); 2512 2513 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 2514 if (ICE->getCastKind() == CK_NoOp) 2515 E = ICE->getSubExpr(); 2516 else 2517 break; 2518 } 2519 2520 while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E)) 2521 E = BE->getSubExpr(); 2522 2523 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 2524 if (ICE->getCastKind() == CK_NoOp) 2525 E = ICE->getSubExpr(); 2526 else 2527 break; 2528 } 2529 2530 return E->IgnoreParens(); 2531} 2532 2533/// isTemporaryObject - Determines if this expression produces a 2534/// temporary of the given class type. 2535bool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const { 2536 if (!C.hasSameUnqualifiedType(getType(), C.getTypeDeclType(TempTy))) 2537 return false; 2538 2539 const Expr *E = skipTemporaryBindingsNoOpCastsAndParens(this); 2540 2541 // Temporaries are by definition pr-values of class type. 2542 if (!E->Classify(C).isPRValue()) { 2543 // In this context, property reference is a message call and is pr-value. 2544 if (!isa<ObjCPropertyRefExpr>(E)) 2545 return false; 2546 } 2547 2548 // Black-list a few cases which yield pr-values of class type that don't 2549 // refer to temporaries of that type: 2550 2551 // - implicit derived-to-base conversions 2552 if (isa<ImplicitCastExpr>(E)) { 2553 switch (cast<ImplicitCastExpr>(E)->getCastKind()) { 2554 case CK_DerivedToBase: 2555 case CK_UncheckedDerivedToBase: 2556 return false; 2557 default: 2558 break; 2559 } 2560 } 2561 2562 // - member expressions (all) 2563 if (isa<MemberExpr>(E)) 2564 return false; 2565 2566 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) 2567 if (BO->isPtrMemOp()) 2568 return false; 2569 2570 // - opaque values (all) 2571 if (isa<OpaqueValueExpr>(E)) 2572 return false; 2573 2574 return true; 2575} 2576 2577bool Expr::isImplicitCXXThis() const { 2578 const Expr *E = this; 2579 2580 // Strip away parentheses and casts we don't care about. 2581 while (true) { 2582 if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) { 2583 E = Paren->getSubExpr(); 2584 continue; 2585 } 2586 2587 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 2588 if (ICE->getCastKind() == CK_NoOp || 2589 ICE->getCastKind() == CK_LValueToRValue || 2590 ICE->getCastKind() == CK_DerivedToBase || 2591 ICE->getCastKind() == CK_UncheckedDerivedToBase) { 2592 E = ICE->getSubExpr(); 2593 continue; 2594 } 2595 } 2596 2597 if (const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) { 2598 if (UnOp->getOpcode() == UO_Extension) { 2599 E = UnOp->getSubExpr(); 2600 continue; 2601 } 2602 } 2603 2604 if (const MaterializeTemporaryExpr *M 2605 = dyn_cast<MaterializeTemporaryExpr>(E)) { 2606 E = M->GetTemporaryExpr(); 2607 continue; 2608 } 2609 2610 break; 2611 } 2612 2613 if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E)) 2614 return This->isImplicit(); 2615 2616 return false; 2617} 2618 2619/// hasAnyTypeDependentArguments - Determines if any of the expressions 2620/// in Exprs is type-dependent. 2621bool Expr::hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs) { 2622 for (unsigned I = 0; I < Exprs.size(); ++I) 2623 if (Exprs[I]->isTypeDependent()) 2624 return true; 2625 2626 return false; 2627} 2628 2629bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef) const { 2630 // This function is attempting whether an expression is an initializer 2631 // which can be evaluated at compile-time. isEvaluatable handles most 2632 // of the cases, but it can't deal with some initializer-specific 2633 // expressions, and it can't deal with aggregates; we deal with those here, 2634 // and fall back to isEvaluatable for the other cases. 2635 2636 // If we ever capture reference-binding directly in the AST, we can 2637 // kill the second parameter. 2638 2639 if (IsForRef) { 2640 EvalResult Result; 2641 return EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects; 2642 } 2643 2644 switch (getStmtClass()) { 2645 default: break; 2646 case IntegerLiteralClass: 2647 case FloatingLiteralClass: 2648 case StringLiteralClass: 2649 case ObjCStringLiteralClass: 2650 case ObjCEncodeExprClass: 2651 return true; 2652 case CXXTemporaryObjectExprClass: 2653 case CXXConstructExprClass: { 2654 const CXXConstructExpr *CE = cast<CXXConstructExpr>(this); 2655 2656 // Only if it's 2657 if (CE->getConstructor()->isTrivial()) { 2658 // 1) an application of the trivial default constructor or 2659 if (!CE->getNumArgs()) return true; 2660 2661 // 2) an elidable trivial copy construction of an operand which is 2662 // itself a constant initializer. Note that we consider the 2663 // operand on its own, *not* as a reference binding. 2664 if (CE->isElidable() && 2665 CE->getArg(0)->isConstantInitializer(Ctx, false)) 2666 return true; 2667 } 2668 2669 // 3) a foldable constexpr constructor. 2670 break; 2671 } 2672 case CompoundLiteralExprClass: { 2673 // This handles gcc's extension that allows global initializers like 2674 // "struct x {int x;} x = (struct x) {};". 2675 // FIXME: This accepts other cases it shouldn't! 2676 const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer(); 2677 return Exp->isConstantInitializer(Ctx, false); 2678 } 2679 case InitListExprClass: { 2680 // FIXME: This doesn't deal with fields with reference types correctly. 2681 // FIXME: This incorrectly allows pointers cast to integers to be assigned 2682 // to bitfields. 2683 const InitListExpr *Exp = cast<InitListExpr>(this); 2684 unsigned numInits = Exp->getNumInits(); 2685 for (unsigned i = 0; i < numInits; i++) { 2686 if (!Exp->getInit(i)->isConstantInitializer(Ctx, false)) 2687 return false; 2688 } 2689 return true; 2690 } 2691 case ImplicitValueInitExprClass: 2692 return true; 2693 case ParenExprClass: 2694 return cast<ParenExpr>(this)->getSubExpr() 2695 ->isConstantInitializer(Ctx, IsForRef); 2696 case GenericSelectionExprClass: 2697 if (cast<GenericSelectionExpr>(this)->isResultDependent()) 2698 return false; 2699 return cast<GenericSelectionExpr>(this)->getResultExpr() 2700 ->isConstantInitializer(Ctx, IsForRef); 2701 case ChooseExprClass: 2702 return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx) 2703 ->isConstantInitializer(Ctx, IsForRef); 2704 case UnaryOperatorClass: { 2705 const UnaryOperator* Exp = cast<UnaryOperator>(this); 2706 if (Exp->getOpcode() == UO_Extension) 2707 return Exp->getSubExpr()->isConstantInitializer(Ctx, false); 2708 break; 2709 } 2710 case CXXFunctionalCastExprClass: 2711 case CXXStaticCastExprClass: 2712 case ImplicitCastExprClass: 2713 case CStyleCastExprClass: { 2714 const CastExpr *CE = cast<CastExpr>(this); 2715 2716 // If we're promoting an integer to an _Atomic type then this is constant 2717 // if the integer is constant. We also need to check the converse in case 2718 // someone does something like: 2719 // 2720 // int a = (_Atomic(int))42; 2721 // 2722 // I doubt anyone would write code like this directly, but it's quite 2723 // possible as the result of macro expansions. 2724 if (CE->getCastKind() == CK_NonAtomicToAtomic || 2725 CE->getCastKind() == CK_AtomicToNonAtomic) 2726 return CE->getSubExpr()->isConstantInitializer(Ctx, false); 2727 2728 // Handle bitcasts of vector constants. 2729 if (getType()->isVectorType() && CE->getCastKind() == CK_BitCast) 2730 return CE->getSubExpr()->isConstantInitializer(Ctx, false); 2731 2732 // Handle misc casts we want to ignore. 2733 // FIXME: Is it really safe to ignore all these? 2734 if (CE->getCastKind() == CK_NoOp || 2735 CE->getCastKind() == CK_LValueToRValue || 2736 CE->getCastKind() == CK_ToUnion || 2737 CE->getCastKind() == CK_ConstructorConversion) 2738 return CE->getSubExpr()->isConstantInitializer(Ctx, false); 2739 2740 break; 2741 } 2742 case MaterializeTemporaryExprClass: 2743 return cast<MaterializeTemporaryExpr>(this)->GetTemporaryExpr() 2744 ->isConstantInitializer(Ctx, false); 2745 } 2746 return isEvaluatable(Ctx); 2747} 2748 2749bool Expr::HasSideEffects(const ASTContext &Ctx) const { 2750 if (isInstantiationDependent()) 2751 return true; 2752 2753 switch (getStmtClass()) { 2754 case NoStmtClass: 2755 #define ABSTRACT_STMT(Type) 2756 #define STMT(Type, Base) case Type##Class: 2757 #define EXPR(Type, Base) 2758 #include "clang/AST/StmtNodes.inc" 2759 llvm_unreachable("unexpected Expr kind"); 2760 2761 case DependentScopeDeclRefExprClass: 2762 case CXXUnresolvedConstructExprClass: 2763 case CXXDependentScopeMemberExprClass: 2764 case UnresolvedLookupExprClass: 2765 case UnresolvedMemberExprClass: 2766 case PackExpansionExprClass: 2767 case SubstNonTypeTemplateParmPackExprClass: 2768 case FunctionParmPackExprClass: 2769 llvm_unreachable("shouldn't see dependent / unresolved nodes here"); 2770 2771 case DeclRefExprClass: 2772 case ObjCIvarRefExprClass: 2773 case PredefinedExprClass: 2774 case IntegerLiteralClass: 2775 case FloatingLiteralClass: 2776 case ImaginaryLiteralClass: 2777 case StringLiteralClass: 2778 case CharacterLiteralClass: 2779 case OffsetOfExprClass: 2780 case ImplicitValueInitExprClass: 2781 case UnaryExprOrTypeTraitExprClass: 2782 case AddrLabelExprClass: 2783 case GNUNullExprClass: 2784 case CXXBoolLiteralExprClass: 2785 case CXXNullPtrLiteralExprClass: 2786 case CXXThisExprClass: 2787 case CXXScalarValueInitExprClass: 2788 case TypeTraitExprClass: 2789 case UnaryTypeTraitExprClass: 2790 case BinaryTypeTraitExprClass: 2791 case ArrayTypeTraitExprClass: 2792 case ExpressionTraitExprClass: 2793 case CXXNoexceptExprClass: 2794 case SizeOfPackExprClass: 2795 case ObjCStringLiteralClass: 2796 case ObjCEncodeExprClass: 2797 case ObjCBoolLiteralExprClass: 2798 case CXXUuidofExprClass: 2799 case OpaqueValueExprClass: 2800 // These never have a side-effect. 2801 return false; 2802 2803 case CallExprClass: 2804 case MSPropertyRefExprClass: 2805 case CompoundAssignOperatorClass: 2806 case VAArgExprClass: 2807 case AtomicExprClass: 2808 case StmtExprClass: 2809 case CXXOperatorCallExprClass: 2810 case CXXMemberCallExprClass: 2811 case UserDefinedLiteralClass: 2812 case CXXThrowExprClass: 2813 case CXXNewExprClass: 2814 case CXXDeleteExprClass: 2815 case ExprWithCleanupsClass: 2816 case CXXBindTemporaryExprClass: 2817 case BlockExprClass: 2818 case CUDAKernelCallExprClass: 2819 // These always have a side-effect. 2820 return true; 2821 2822 case ParenExprClass: 2823 case ArraySubscriptExprClass: 2824 case MemberExprClass: 2825 case ConditionalOperatorClass: 2826 case BinaryConditionalOperatorClass: 2827 case CompoundLiteralExprClass: 2828 case ExtVectorElementExprClass: 2829 case DesignatedInitExprClass: 2830 case ParenListExprClass: 2831 case CXXPseudoDestructorExprClass: 2832 case SubstNonTypeTemplateParmExprClass: 2833 case MaterializeTemporaryExprClass: 2834 case ShuffleVectorExprClass: 2835 case AsTypeExprClass: 2836 // These have a side-effect if any subexpression does. 2837 break; 2838 2839 case UnaryOperatorClass: 2840 if (cast<UnaryOperator>(this)->isIncrementDecrementOp()) 2841 return true; 2842 break; 2843 2844 case BinaryOperatorClass: 2845 if (cast<BinaryOperator>(this)->isAssignmentOp()) 2846 return true; 2847 break; 2848 2849 case InitListExprClass: 2850 // FIXME: The children for an InitListExpr doesn't include the array filler. 2851 if (const Expr *E = cast<InitListExpr>(this)->getArrayFiller()) 2852 if (E->HasSideEffects(Ctx)) 2853 return true; 2854 break; 2855 2856 case GenericSelectionExprClass: 2857 return cast<GenericSelectionExpr>(this)->getResultExpr()-> 2858 HasSideEffects(Ctx); 2859 2860 case ChooseExprClass: 2861 return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)->HasSideEffects(Ctx); 2862 2863 case CXXDefaultArgExprClass: 2864 return cast<CXXDefaultArgExpr>(this)->getExpr()->HasSideEffects(Ctx); 2865 2866 case CXXDefaultInitExprClass: 2867 if (const Expr *E = cast<CXXDefaultInitExpr>(this)->getExpr()) 2868 return E->HasSideEffects(Ctx); 2869 // If we've not yet parsed the initializer, assume it has side-effects. 2870 return true; 2871 2872 case CXXDynamicCastExprClass: { 2873 // A dynamic_cast expression has side-effects if it can throw. 2874 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(this); 2875 if (DCE->getTypeAsWritten()->isReferenceType() && 2876 DCE->getCastKind() == CK_Dynamic) 2877 return true; 2878 } // Fall through. 2879 case ImplicitCastExprClass: 2880 case CStyleCastExprClass: 2881 case CXXStaticCastExprClass: 2882 case CXXReinterpretCastExprClass: 2883 case CXXConstCastExprClass: 2884 case CXXFunctionalCastExprClass: { 2885 const CastExpr *CE = cast<CastExpr>(this); 2886 if (CE->getCastKind() == CK_LValueToRValue && 2887 CE->getSubExpr()->getType().isVolatileQualified()) 2888 return true; 2889 break; 2890 } 2891 2892 case CXXTypeidExprClass: 2893 // typeid might throw if its subexpression is potentially-evaluated, so has 2894 // side-effects in that case whether or not its subexpression does. 2895 return cast<CXXTypeidExpr>(this)->isPotentiallyEvaluated(); 2896 2897 case CXXConstructExprClass: 2898 case CXXTemporaryObjectExprClass: { 2899 const CXXConstructExpr *CE = cast<CXXConstructExpr>(this); 2900 if (!CE->getConstructor()->isTrivial()) 2901 return true; 2902 // A trivial constructor does not add any side-effects of its own. Just look 2903 // at its arguments. 2904 break; 2905 } 2906 2907 case LambdaExprClass: { 2908 const LambdaExpr *LE = cast<LambdaExpr>(this); 2909 for (LambdaExpr::capture_iterator I = LE->capture_begin(), 2910 E = LE->capture_end(); I != E; ++I) 2911 if (I->getCaptureKind() == LCK_ByCopy) 2912 // FIXME: Only has a side-effect if the variable is volatile or if 2913 // the copy would invoke a non-trivial copy constructor. 2914 return true; 2915 return false; 2916 } 2917 2918 case PseudoObjectExprClass: { 2919 // Only look for side-effects in the semantic form, and look past 2920 // OpaqueValueExpr bindings in that form. 2921 const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this); 2922 for (PseudoObjectExpr::const_semantics_iterator I = PO->semantics_begin(), 2923 E = PO->semantics_end(); 2924 I != E; ++I) { 2925 const Expr *Subexpr = *I; 2926 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Subexpr)) 2927 Subexpr = OVE->getSourceExpr(); 2928 if (Subexpr->HasSideEffects(Ctx)) 2929 return true; 2930 } 2931 return false; 2932 } 2933 2934 case ObjCBoxedExprClass: 2935 case ObjCArrayLiteralClass: 2936 case ObjCDictionaryLiteralClass: 2937 case ObjCMessageExprClass: 2938 case ObjCSelectorExprClass: 2939 case ObjCProtocolExprClass: 2940 case ObjCPropertyRefExprClass: 2941 case ObjCIsaExprClass: 2942 case ObjCIndirectCopyRestoreExprClass: 2943 case ObjCSubscriptRefExprClass: 2944 case ObjCBridgedCastExprClass: 2945 // FIXME: Classify these cases better. 2946 return true; 2947 } 2948 2949 // Recurse to children. 2950 for (const_child_range SubStmts = children(); SubStmts; ++SubStmts) 2951 if (const Stmt *S = *SubStmts) 2952 if (cast<Expr>(S)->HasSideEffects(Ctx)) 2953 return true; 2954 2955 return false; 2956} 2957 2958namespace { 2959 /// \brief Look for a call to a non-trivial function within an expression. 2960 class NonTrivialCallFinder : public EvaluatedExprVisitor<NonTrivialCallFinder> 2961 { 2962 typedef EvaluatedExprVisitor<NonTrivialCallFinder> Inherited; 2963 2964 bool NonTrivial; 2965 2966 public: 2967 explicit NonTrivialCallFinder(ASTContext &Context) 2968 : Inherited(Context), NonTrivial(false) { } 2969 2970 bool hasNonTrivialCall() const { return NonTrivial; } 2971 2972 void VisitCallExpr(CallExpr *E) { 2973 if (CXXMethodDecl *Method 2974 = dyn_cast_or_null<CXXMethodDecl>(E->getCalleeDecl())) { 2975 if (Method->isTrivial()) { 2976 // Recurse to children of the call. 2977 Inherited::VisitStmt(E); 2978 return; 2979 } 2980 } 2981 2982 NonTrivial = true; 2983 } 2984 2985 void VisitCXXConstructExpr(CXXConstructExpr *E) { 2986 if (E->getConstructor()->isTrivial()) { 2987 // Recurse to children of the call. 2988 Inherited::VisitStmt(E); 2989 return; 2990 } 2991 2992 NonTrivial = true; 2993 } 2994 2995 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 2996 if (E->getTemporary()->getDestructor()->isTrivial()) { 2997 Inherited::VisitStmt(E); 2998 return; 2999 } 3000 3001 NonTrivial = true; 3002 } 3003 }; 3004} 3005 3006bool Expr::hasNonTrivialCall(ASTContext &Ctx) { 3007 NonTrivialCallFinder Finder(Ctx); 3008 Finder.Visit(this); 3009 return Finder.hasNonTrivialCall(); 3010} 3011 3012/// isNullPointerConstant - C99 6.3.2.3p3 - Return whether this is a null 3013/// pointer constant or not, as well as the specific kind of constant detected. 3014/// Null pointer constants can be integer constant expressions with the 3015/// value zero, casts of zero to void*, nullptr (C++0X), or __null 3016/// (a GNU extension). 3017Expr::NullPointerConstantKind 3018Expr::isNullPointerConstant(ASTContext &Ctx, 3019 NullPointerConstantValueDependence NPC) const { 3020 if (isValueDependent()) { 3021 switch (NPC) { 3022 case NPC_NeverValueDependent: 3023 llvm_unreachable("Unexpected value dependent expression!"); 3024 case NPC_ValueDependentIsNull: 3025 if (isTypeDependent() || getType()->isIntegralType(Ctx)) 3026 return NPCK_ZeroExpression; 3027 else 3028 return NPCK_NotNull; 3029 3030 case NPC_ValueDependentIsNotNull: 3031 return NPCK_NotNull; 3032 } 3033 } 3034 3035 // Strip off a cast to void*, if it exists. Except in C++. 3036 if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 3037 if (!Ctx.getLangOpts().CPlusPlus) { 3038 // Check that it is a cast to void*. 3039 if (const PointerType *PT = CE->getType()->getAs<PointerType>()) { 3040 QualType Pointee = PT->getPointeeType(); 3041 if (!Pointee.hasQualifiers() && 3042 Pointee->isVoidType() && // to void* 3043 CE->getSubExpr()->getType()->isIntegerType()) // from int. 3044 return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 3045 } 3046 } 3047 } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 3048 // Ignore the ImplicitCastExpr type entirely. 3049 return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 3050 } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 3051 // Accept ((void*)0) as a null pointer constant, as many other 3052 // implementations do. 3053 return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 3054 } else if (const GenericSelectionExpr *GE = 3055 dyn_cast<GenericSelectionExpr>(this)) { 3056 return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC); 3057 } else if (const CXXDefaultArgExpr *DefaultArg 3058 = dyn_cast<CXXDefaultArgExpr>(this)) { 3059 // See through default argument expressions. 3060 return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC); 3061 } else if (const CXXDefaultInitExpr *DefaultInit 3062 = dyn_cast<CXXDefaultInitExpr>(this)) { 3063 // See through default initializer expressions. 3064 return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC); 3065 } else if (isa<GNUNullExpr>(this)) { 3066 // The GNU __null extension is always a null pointer constant. 3067 return NPCK_GNUNull; 3068 } else if (const MaterializeTemporaryExpr *M 3069 = dyn_cast<MaterializeTemporaryExpr>(this)) { 3070 return M->GetTemporaryExpr()->isNullPointerConstant(Ctx, NPC); 3071 } else if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(this)) { 3072 if (const Expr *Source = OVE->getSourceExpr()) 3073 return Source->isNullPointerConstant(Ctx, NPC); 3074 } 3075 3076 // C++11 nullptr_t is always a null pointer constant. 3077 if (getType()->isNullPtrType()) 3078 return NPCK_CXX11_nullptr; 3079 3080 if (const RecordType *UT = getType()->getAsUnionType()) 3081 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) 3082 if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){ 3083 const Expr *InitExpr = CLE->getInitializer(); 3084 if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr)) 3085 return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC); 3086 } 3087 // This expression must be an integer type. 3088 if (!getType()->isIntegerType() || 3089 (Ctx.getLangOpts().CPlusPlus && getType()->isEnumeralType())) 3090 return NPCK_NotNull; 3091 3092 // If we have an integer constant expression, we need to *evaluate* it and 3093 // test for the value 0. Don't use the C++11 constant expression semantics 3094 // for this, for now; once the dust settles on core issue 903, we might only 3095 // allow a literal 0 here in C++11 mode. 3096 if (Ctx.getLangOpts().CPlusPlus11) { 3097 if (!isCXX98IntegralConstantExpr(Ctx)) 3098 return NPCK_NotNull; 3099 } else { 3100 if (!isIntegerConstantExpr(Ctx)) 3101 return NPCK_NotNull; 3102 } 3103 3104 if (EvaluateKnownConstInt(Ctx) != 0) 3105 return NPCK_NotNull; 3106 3107 if (isa<IntegerLiteral>(this)) 3108 return NPCK_ZeroLiteral; 3109 return NPCK_ZeroExpression; 3110} 3111 3112/// \brief If this expression is an l-value for an Objective C 3113/// property, find the underlying property reference expression. 3114const ObjCPropertyRefExpr *Expr::getObjCProperty() const { 3115 const Expr *E = this; 3116 while (true) { 3117 assert((E->getValueKind() == VK_LValue && 3118 E->getObjectKind() == OK_ObjCProperty) && 3119 "expression is not a property reference"); 3120 E = E->IgnoreParenCasts(); 3121 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 3122 if (BO->getOpcode() == BO_Comma) { 3123 E = BO->getRHS(); 3124 continue; 3125 } 3126 } 3127 3128 break; 3129 } 3130 3131 return cast<ObjCPropertyRefExpr>(E); 3132} 3133 3134bool Expr::isObjCSelfExpr() const { 3135 const Expr *E = IgnoreParenImpCasts(); 3136 3137 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 3138 if (!DRE) 3139 return false; 3140 3141 const ImplicitParamDecl *Param = dyn_cast<ImplicitParamDecl>(DRE->getDecl()); 3142 if (!Param) 3143 return false; 3144 3145 const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(Param->getDeclContext()); 3146 if (!M) 3147 return false; 3148 3149 return M->getSelfDecl() == Param; 3150} 3151 3152FieldDecl *Expr::getSourceBitField() { 3153 Expr *E = this->IgnoreParens(); 3154 3155 while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 3156 if (ICE->getCastKind() == CK_LValueToRValue || 3157 (ICE->getValueKind() != VK_RValue && ICE->getCastKind() == CK_NoOp)) 3158 E = ICE->getSubExpr()->IgnoreParens(); 3159 else 3160 break; 3161 } 3162 3163 if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 3164 if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl())) 3165 if (Field->isBitField()) 3166 return Field; 3167 3168 if (ObjCIvarRefExpr *IvarRef = dyn_cast<ObjCIvarRefExpr>(E)) 3169 if (FieldDecl *Ivar = dyn_cast<FieldDecl>(IvarRef->getDecl())) 3170 if (Ivar->isBitField()) 3171 return Ivar; 3172 3173 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E)) 3174 if (FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl())) 3175 if (Field->isBitField()) 3176 return Field; 3177 3178 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) { 3179 if (BinOp->isAssignmentOp() && BinOp->getLHS()) 3180 return BinOp->getLHS()->getSourceBitField(); 3181 3182 if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS()) 3183 return BinOp->getRHS()->getSourceBitField(); 3184 } 3185 3186 return 0; 3187} 3188 3189bool Expr::refersToVectorElement() const { 3190 const Expr *E = this->IgnoreParens(); 3191 3192 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 3193 if (ICE->getValueKind() != VK_RValue && 3194 ICE->getCastKind() == CK_NoOp) 3195 E = ICE->getSubExpr()->IgnoreParens(); 3196 else 3197 break; 3198 } 3199 3200 if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) 3201 return ASE->getBase()->getType()->isVectorType(); 3202 3203 if (isa<ExtVectorElementExpr>(E)) 3204 return true; 3205 3206 return false; 3207} 3208 3209/// isArrow - Return true if the base expression is a pointer to vector, 3210/// return false if the base expression is a vector. 3211bool ExtVectorElementExpr::isArrow() const { 3212 return getBase()->getType()->isPointerType(); 3213} 3214 3215unsigned ExtVectorElementExpr::getNumElements() const { 3216 if (const VectorType *VT = getType()->getAs<VectorType>()) 3217 return VT->getNumElements(); 3218 return 1; 3219} 3220 3221/// containsDuplicateElements - Return true if any element access is repeated. 3222bool ExtVectorElementExpr::containsDuplicateElements() const { 3223 // FIXME: Refactor this code to an accessor on the AST node which returns the 3224 // "type" of component access, and share with code below and in Sema. 3225 StringRef Comp = Accessor->getName(); 3226 3227 // Halving swizzles do not contain duplicate elements. 3228 if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd") 3229 return false; 3230 3231 // Advance past s-char prefix on hex swizzles. 3232 if (Comp[0] == 's' || Comp[0] == 'S') 3233 Comp = Comp.substr(1); 3234 3235 for (unsigned i = 0, e = Comp.size(); i != e; ++i) 3236 if (Comp.substr(i + 1).find(Comp[i]) != StringRef::npos) 3237 return true; 3238 3239 return false; 3240} 3241 3242/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 3243void ExtVectorElementExpr::getEncodedElementAccess( 3244 SmallVectorImpl<unsigned> &Elts) const { 3245 StringRef Comp = Accessor->getName(); 3246 if (Comp[0] == 's' || Comp[0] == 'S') 3247 Comp = Comp.substr(1); 3248 3249 bool isHi = Comp == "hi"; 3250 bool isLo = Comp == "lo"; 3251 bool isEven = Comp == "even"; 3252 bool isOdd = Comp == "odd"; 3253 3254 for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 3255 uint64_t Index; 3256 3257 if (isHi) 3258 Index = e + i; 3259 else if (isLo) 3260 Index = i; 3261 else if (isEven) 3262 Index = 2 * i; 3263 else if (isOdd) 3264 Index = 2 * i + 1; 3265 else 3266 Index = ExtVectorType::getAccessorIdx(Comp[i]); 3267 3268 Elts.push_back(Index); 3269 } 3270} 3271 3272ObjCMessageExpr::ObjCMessageExpr(QualType T, 3273 ExprValueKind VK, 3274 SourceLocation LBracLoc, 3275 SourceLocation SuperLoc, 3276 bool IsInstanceSuper, 3277 QualType SuperType, 3278 Selector Sel, 3279 ArrayRef<SourceLocation> SelLocs, 3280 SelectorLocationsKind SelLocsK, 3281 ObjCMethodDecl *Method, 3282 ArrayRef<Expr *> Args, 3283 SourceLocation RBracLoc, 3284 bool isImplicit) 3285 : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, 3286 /*TypeDependent=*/false, /*ValueDependent=*/false, 3287 /*InstantiationDependent=*/false, 3288 /*ContainsUnexpandedParameterPack=*/false), 3289 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 3290 : Sel.getAsOpaquePtr())), 3291 Kind(IsInstanceSuper? SuperInstance : SuperClass), 3292 HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit), 3293 SuperLoc(SuperLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc) 3294{ 3295 initArgsAndSelLocs(Args, SelLocs, SelLocsK); 3296 setReceiverPointer(SuperType.getAsOpaquePtr()); 3297} 3298 3299ObjCMessageExpr::ObjCMessageExpr(QualType T, 3300 ExprValueKind VK, 3301 SourceLocation LBracLoc, 3302 TypeSourceInfo *Receiver, 3303 Selector Sel, 3304 ArrayRef<SourceLocation> SelLocs, 3305 SelectorLocationsKind SelLocsK, 3306 ObjCMethodDecl *Method, 3307 ArrayRef<Expr *> Args, 3308 SourceLocation RBracLoc, 3309 bool isImplicit) 3310 : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(), 3311 T->isDependentType(), T->isInstantiationDependentType(), 3312 T->containsUnexpandedParameterPack()), 3313 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 3314 : Sel.getAsOpaquePtr())), 3315 Kind(Class), 3316 HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit), 3317 LBracLoc(LBracLoc), RBracLoc(RBracLoc) 3318{ 3319 initArgsAndSelLocs(Args, SelLocs, SelLocsK); 3320 setReceiverPointer(Receiver); 3321} 3322 3323ObjCMessageExpr::ObjCMessageExpr(QualType T, 3324 ExprValueKind VK, 3325 SourceLocation LBracLoc, 3326 Expr *Receiver, 3327 Selector Sel, 3328 ArrayRef<SourceLocation> SelLocs, 3329 SelectorLocationsKind SelLocsK, 3330 ObjCMethodDecl *Method, 3331 ArrayRef<Expr *> Args, 3332 SourceLocation RBracLoc, 3333 bool isImplicit) 3334 : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, Receiver->isTypeDependent(), 3335 Receiver->isTypeDependent(), 3336 Receiver->isInstantiationDependent(), 3337 Receiver->containsUnexpandedParameterPack()), 3338 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 3339 : Sel.getAsOpaquePtr())), 3340 Kind(Instance), 3341 HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit), 3342 LBracLoc(LBracLoc), RBracLoc(RBracLoc) 3343{ 3344 initArgsAndSelLocs(Args, SelLocs, SelLocsK); 3345 setReceiverPointer(Receiver); 3346} 3347 3348void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef<Expr *> Args, 3349 ArrayRef<SourceLocation> SelLocs, 3350 SelectorLocationsKind SelLocsK) { 3351 setNumArgs(Args.size()); 3352 Expr **MyArgs = getArgs(); 3353 for (unsigned I = 0; I != Args.size(); ++I) { 3354 if (Args[I]->isTypeDependent()) 3355 ExprBits.TypeDependent = true; 3356 if (Args[I]->isValueDependent()) 3357 ExprBits.ValueDependent = true; 3358 if (Args[I]->isInstantiationDependent()) 3359 ExprBits.InstantiationDependent = true; 3360 if (Args[I]->containsUnexpandedParameterPack()) 3361 ExprBits.ContainsUnexpandedParameterPack = true; 3362 3363 MyArgs[I] = Args[I]; 3364 } 3365 3366 SelLocsKind = SelLocsK; 3367 if (!isImplicit()) { 3368 if (SelLocsK == SelLoc_NonStandard) 3369 std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs()); 3370 } 3371} 3372 3373ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T, 3374 ExprValueKind VK, 3375 SourceLocation LBracLoc, 3376 SourceLocation SuperLoc, 3377 bool IsInstanceSuper, 3378 QualType SuperType, 3379 Selector Sel, 3380 ArrayRef<SourceLocation> SelLocs, 3381 ObjCMethodDecl *Method, 3382 ArrayRef<Expr *> Args, 3383 SourceLocation RBracLoc, 3384 bool isImplicit) { 3385 assert((!SelLocs.empty() || isImplicit) && 3386 "No selector locs for non-implicit message"); 3387 ObjCMessageExpr *Mem; 3388 SelectorLocationsKind SelLocsK = SelectorLocationsKind(); 3389 if (isImplicit) 3390 Mem = alloc(Context, Args.size(), 0); 3391 else 3392 Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); 3393 return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, SuperLoc, IsInstanceSuper, 3394 SuperType, Sel, SelLocs, SelLocsK, 3395 Method, Args, RBracLoc, isImplicit); 3396} 3397 3398ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T, 3399 ExprValueKind VK, 3400 SourceLocation LBracLoc, 3401 TypeSourceInfo *Receiver, 3402 Selector Sel, 3403 ArrayRef<SourceLocation> SelLocs, 3404 ObjCMethodDecl *Method, 3405 ArrayRef<Expr *> Args, 3406 SourceLocation RBracLoc, 3407 bool isImplicit) { 3408 assert((!SelLocs.empty() || isImplicit) && 3409 "No selector locs for non-implicit message"); 3410 ObjCMessageExpr *Mem; 3411 SelectorLocationsKind SelLocsK = SelectorLocationsKind(); 3412 if (isImplicit) 3413 Mem = alloc(Context, Args.size(), 0); 3414 else 3415 Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); 3416 return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, 3417 SelLocs, SelLocsK, Method, Args, RBracLoc, 3418 isImplicit); 3419} 3420 3421ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T, 3422 ExprValueKind VK, 3423 SourceLocation LBracLoc, 3424 Expr *Receiver, 3425 Selector Sel, 3426 ArrayRef<SourceLocation> SelLocs, 3427 ObjCMethodDecl *Method, 3428 ArrayRef<Expr *> Args, 3429 SourceLocation RBracLoc, 3430 bool isImplicit) { 3431 assert((!SelLocs.empty() || isImplicit) && 3432 "No selector locs for non-implicit message"); 3433 ObjCMessageExpr *Mem; 3434 SelectorLocationsKind SelLocsK = SelectorLocationsKind(); 3435 if (isImplicit) 3436 Mem = alloc(Context, Args.size(), 0); 3437 else 3438 Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); 3439 return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, 3440 SelLocs, SelLocsK, Method, Args, RBracLoc, 3441 isImplicit); 3442} 3443 3444ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(ASTContext &Context, 3445 unsigned NumArgs, 3446 unsigned NumStoredSelLocs) { 3447 ObjCMessageExpr *Mem = alloc(Context, NumArgs, NumStoredSelLocs); 3448 return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs); 3449} 3450 3451ObjCMessageExpr *ObjCMessageExpr::alloc(ASTContext &C, 3452 ArrayRef<Expr *> Args, 3453 SourceLocation RBraceLoc, 3454 ArrayRef<SourceLocation> SelLocs, 3455 Selector Sel, 3456 SelectorLocationsKind &SelLocsK) { 3457 SelLocsK = hasStandardSelectorLocs(Sel, SelLocs, Args, RBraceLoc); 3458 unsigned NumStoredSelLocs = (SelLocsK == SelLoc_NonStandard) ? SelLocs.size() 3459 : 0; 3460 return alloc(C, Args.size(), NumStoredSelLocs); 3461} 3462 3463ObjCMessageExpr *ObjCMessageExpr::alloc(ASTContext &C, 3464 unsigned NumArgs, 3465 unsigned NumStoredSelLocs) { 3466 unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) + 3467 NumArgs * sizeof(Expr *) + NumStoredSelLocs * sizeof(SourceLocation); 3468 return (ObjCMessageExpr *)C.Allocate(Size, 3469 llvm::AlignOf<ObjCMessageExpr>::Alignment); 3470} 3471 3472void ObjCMessageExpr::getSelectorLocs( 3473 SmallVectorImpl<SourceLocation> &SelLocs) const { 3474 for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i) 3475 SelLocs.push_back(getSelectorLoc(i)); 3476} 3477 3478SourceRange ObjCMessageExpr::getReceiverRange() const { 3479 switch (getReceiverKind()) { 3480 case Instance: 3481 return getInstanceReceiver()->getSourceRange(); 3482 3483 case Class: 3484 return getClassReceiverTypeInfo()->getTypeLoc().getSourceRange(); 3485 3486 case SuperInstance: 3487 case SuperClass: 3488 return getSuperLoc(); 3489 } 3490 3491 llvm_unreachable("Invalid ReceiverKind!"); 3492} 3493 3494Selector ObjCMessageExpr::getSelector() const { 3495 if (HasMethod) 3496 return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod) 3497 ->getSelector(); 3498 return Selector(SelectorOrMethod); 3499} 3500 3501QualType ObjCMessageExpr::getReceiverType() const { 3502 switch (getReceiverKind()) { 3503 case Instance: 3504 return getInstanceReceiver()->getType(); 3505 case Class: 3506 return getClassReceiver(); 3507 case SuperInstance: 3508 case SuperClass: 3509 return getSuperType(); 3510 } 3511 3512 llvm_unreachable("unexpected receiver kind"); 3513} 3514 3515ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const { 3516 QualType T = getReceiverType(); 3517 3518 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>()) 3519 return Ptr->getInterfaceDecl(); 3520 3521 if (const ObjCObjectType *Ty = T->getAs<ObjCObjectType>()) 3522 return Ty->getInterface(); 3523 3524 return 0; 3525} 3526 3527StringRef ObjCBridgedCastExpr::getBridgeKindName() const { 3528 switch (getBridgeKind()) { 3529 case OBC_Bridge: 3530 return "__bridge"; 3531 case OBC_BridgeTransfer: 3532 return "__bridge_transfer"; 3533 case OBC_BridgeRetained: 3534 return "__bridge_retained"; 3535 } 3536 3537 llvm_unreachable("Invalid BridgeKind!"); 3538} 3539 3540bool ChooseExpr::isConditionTrue(const ASTContext &C) const { 3541 return getCond()->EvaluateKnownConstInt(C) != 0; 3542} 3543 3544ShuffleVectorExpr::ShuffleVectorExpr(ASTContext &C, ArrayRef<Expr*> args, 3545 QualType Type, SourceLocation BLoc, 3546 SourceLocation RP) 3547 : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary, 3548 Type->isDependentType(), Type->isDependentType(), 3549 Type->isInstantiationDependentType(), 3550 Type->containsUnexpandedParameterPack()), 3551 BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) 3552{ 3553 SubExprs = new (C) Stmt*[args.size()]; 3554 for (unsigned i = 0; i != args.size(); i++) { 3555 if (args[i]->isTypeDependent()) 3556 ExprBits.TypeDependent = true; 3557 if (args[i]->isValueDependent()) 3558 ExprBits.ValueDependent = true; 3559 if (args[i]->isInstantiationDependent()) 3560 ExprBits.InstantiationDependent = true; 3561 if (args[i]->containsUnexpandedParameterPack()) 3562 ExprBits.ContainsUnexpandedParameterPack = true; 3563 3564 SubExprs[i] = args[i]; 3565 } 3566} 3567 3568void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs, 3569 unsigned NumExprs) { 3570 if (SubExprs) C.Deallocate(SubExprs); 3571 3572 SubExprs = new (C) Stmt* [NumExprs]; 3573 this->NumExprs = NumExprs; 3574 memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs); 3575} 3576 3577GenericSelectionExpr::GenericSelectionExpr(ASTContext &Context, 3578 SourceLocation GenericLoc, Expr *ControllingExpr, 3579 ArrayRef<TypeSourceInfo*> AssocTypes, 3580 ArrayRef<Expr*> AssocExprs, 3581 SourceLocation DefaultLoc, 3582 SourceLocation RParenLoc, 3583 bool ContainsUnexpandedParameterPack, 3584 unsigned ResultIndex) 3585 : Expr(GenericSelectionExprClass, 3586 AssocExprs[ResultIndex]->getType(), 3587 AssocExprs[ResultIndex]->getValueKind(), 3588 AssocExprs[ResultIndex]->getObjectKind(), 3589 AssocExprs[ResultIndex]->isTypeDependent(), 3590 AssocExprs[ResultIndex]->isValueDependent(), 3591 AssocExprs[ResultIndex]->isInstantiationDependent(), 3592 ContainsUnexpandedParameterPack), 3593 AssocTypes(new (Context) TypeSourceInfo*[AssocTypes.size()]), 3594 SubExprs(new (Context) Stmt*[END_EXPR+AssocExprs.size()]), 3595 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex), 3596 GenericLoc(GenericLoc), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) { 3597 SubExprs[CONTROLLING] = ControllingExpr; 3598 assert(AssocTypes.size() == AssocExprs.size()); 3599 std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes); 3600 std::copy(AssocExprs.begin(), AssocExprs.end(), SubExprs+END_EXPR); 3601} 3602 3603GenericSelectionExpr::GenericSelectionExpr(ASTContext &Context, 3604 SourceLocation GenericLoc, Expr *ControllingExpr, 3605 ArrayRef<TypeSourceInfo*> AssocTypes, 3606 ArrayRef<Expr*> AssocExprs, 3607 SourceLocation DefaultLoc, 3608 SourceLocation RParenLoc, 3609 bool ContainsUnexpandedParameterPack) 3610 : Expr(GenericSelectionExprClass, 3611 Context.DependentTy, 3612 VK_RValue, 3613 OK_Ordinary, 3614 /*isTypeDependent=*/true, 3615 /*isValueDependent=*/true, 3616 /*isInstantiationDependent=*/true, 3617 ContainsUnexpandedParameterPack), 3618 AssocTypes(new (Context) TypeSourceInfo*[AssocTypes.size()]), 3619 SubExprs(new (Context) Stmt*[END_EXPR+AssocExprs.size()]), 3620 NumAssocs(AssocExprs.size()), ResultIndex(-1U), GenericLoc(GenericLoc), 3621 DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) { 3622 SubExprs[CONTROLLING] = ControllingExpr; 3623 assert(AssocTypes.size() == AssocExprs.size()); 3624 std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes); 3625 std::copy(AssocExprs.begin(), AssocExprs.end(), SubExprs+END_EXPR); 3626} 3627 3628//===----------------------------------------------------------------------===// 3629// DesignatedInitExpr 3630//===----------------------------------------------------------------------===// 3631 3632IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() const { 3633 assert(Kind == FieldDesignator && "Only valid on a field designator"); 3634 if (Field.NameOrField & 0x01) 3635 return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01); 3636 else 3637 return getField()->getIdentifier(); 3638} 3639 3640DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty, 3641 unsigned NumDesignators, 3642 const Designator *Designators, 3643 SourceLocation EqualOrColonLoc, 3644 bool GNUSyntax, 3645 ArrayRef<Expr*> IndexExprs, 3646 Expr *Init) 3647 : Expr(DesignatedInitExprClass, Ty, 3648 Init->getValueKind(), Init->getObjectKind(), 3649 Init->isTypeDependent(), Init->isValueDependent(), 3650 Init->isInstantiationDependent(), 3651 Init->containsUnexpandedParameterPack()), 3652 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax), 3653 NumDesignators(NumDesignators), NumSubExprs(IndexExprs.size() + 1) { 3654 this->Designators = new (C) Designator[NumDesignators]; 3655 3656 // Record the initializer itself. 3657 child_range Child = children(); 3658 *Child++ = Init; 3659 3660 // Copy the designators and their subexpressions, computing 3661 // value-dependence along the way. 3662 unsigned IndexIdx = 0; 3663 for (unsigned I = 0; I != NumDesignators; ++I) { 3664 this->Designators[I] = Designators[I]; 3665 3666 if (this->Designators[I].isArrayDesignator()) { 3667 // Compute type- and value-dependence. 3668 Expr *Index = IndexExprs[IndexIdx]; 3669 if (Index->isTypeDependent() || Index->isValueDependent()) 3670 ExprBits.ValueDependent = true; 3671 if (Index->isInstantiationDependent()) 3672 ExprBits.InstantiationDependent = true; 3673 // Propagate unexpanded parameter packs. 3674 if (Index->containsUnexpandedParameterPack()) 3675 ExprBits.ContainsUnexpandedParameterPack = true; 3676 3677 // Copy the index expressions into permanent storage. 3678 *Child++ = IndexExprs[IndexIdx++]; 3679 } else if (this->Designators[I].isArrayRangeDesignator()) { 3680 // Compute type- and value-dependence. 3681 Expr *Start = IndexExprs[IndexIdx]; 3682 Expr *End = IndexExprs[IndexIdx + 1]; 3683 if (Start->isTypeDependent() || Start->isValueDependent() || 3684 End->isTypeDependent() || End->isValueDependent()) { 3685 ExprBits.ValueDependent = true; 3686 ExprBits.InstantiationDependent = true; 3687 } else if (Start->isInstantiationDependent() || 3688 End->isInstantiationDependent()) { 3689 ExprBits.InstantiationDependent = true; 3690 } 3691 3692 // Propagate unexpanded parameter packs. 3693 if (Start->containsUnexpandedParameterPack() || 3694 End->containsUnexpandedParameterPack()) 3695 ExprBits.ContainsUnexpandedParameterPack = true; 3696 3697 // Copy the start/end expressions into permanent storage. 3698 *Child++ = IndexExprs[IndexIdx++]; 3699 *Child++ = IndexExprs[IndexIdx++]; 3700 } 3701 } 3702 3703 assert(IndexIdx == IndexExprs.size() && "Wrong number of index expressions"); 3704} 3705 3706DesignatedInitExpr * 3707DesignatedInitExpr::Create(ASTContext &C, Designator *Designators, 3708 unsigned NumDesignators, 3709 ArrayRef<Expr*> IndexExprs, 3710 SourceLocation ColonOrEqualLoc, 3711 bool UsesColonSyntax, Expr *Init) { 3712 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 3713 sizeof(Stmt *) * (IndexExprs.size() + 1), 8); 3714 return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators, 3715 ColonOrEqualLoc, UsesColonSyntax, 3716 IndexExprs, Init); 3717} 3718 3719DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C, 3720 unsigned NumIndexExprs) { 3721 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 3722 sizeof(Stmt *) * (NumIndexExprs + 1), 8); 3723 return new (Mem) DesignatedInitExpr(NumIndexExprs + 1); 3724} 3725 3726void DesignatedInitExpr::setDesignators(ASTContext &C, 3727 const Designator *Desigs, 3728 unsigned NumDesigs) { 3729 Designators = new (C) Designator[NumDesigs]; 3730 NumDesignators = NumDesigs; 3731 for (unsigned I = 0; I != NumDesigs; ++I) 3732 Designators[I] = Desigs[I]; 3733} 3734 3735SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const { 3736 DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this); 3737 if (size() == 1) 3738 return DIE->getDesignator(0)->getSourceRange(); 3739 return SourceRange(DIE->getDesignator(0)->getLocStart(), 3740 DIE->getDesignator(size()-1)->getLocEnd()); 3741} 3742 3743SourceLocation DesignatedInitExpr::getLocStart() const { 3744 SourceLocation StartLoc; 3745 Designator &First = 3746 *const_cast<DesignatedInitExpr*>(this)->designators_begin(); 3747 if (First.isFieldDesignator()) { 3748 if (GNUSyntax) 3749 StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc); 3750 else 3751 StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc); 3752 } else 3753 StartLoc = 3754 SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc); 3755 return StartLoc; 3756} 3757 3758SourceLocation DesignatedInitExpr::getLocEnd() const { 3759 return getInit()->getLocEnd(); 3760} 3761 3762Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) const { 3763 assert(D.Kind == Designator::ArrayDesignator && "Requires array designator"); 3764 char *Ptr = static_cast<char *>( 3765 const_cast<void *>(static_cast<const void *>(this))); 3766 Ptr += sizeof(DesignatedInitExpr); 3767 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 3768 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 3769} 3770 3771Expr *DesignatedInitExpr::getArrayRangeStart(const Designator &D) const { 3772 assert(D.Kind == Designator::ArrayRangeDesignator && 3773 "Requires array range designator"); 3774 char *Ptr = static_cast<char *>( 3775 const_cast<void *>(static_cast<const void *>(this))); 3776 Ptr += sizeof(DesignatedInitExpr); 3777 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 3778 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 3779} 3780 3781Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator &D) const { 3782 assert(D.Kind == Designator::ArrayRangeDesignator && 3783 "Requires array range designator"); 3784 char *Ptr = static_cast<char *>( 3785 const_cast<void *>(static_cast<const void *>(this))); 3786 Ptr += sizeof(DesignatedInitExpr); 3787 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 3788 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2)); 3789} 3790 3791/// \brief Replaces the designator at index @p Idx with the series 3792/// of designators in [First, Last). 3793void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx, 3794 const Designator *First, 3795 const Designator *Last) { 3796 unsigned NumNewDesignators = Last - First; 3797 if (NumNewDesignators == 0) { 3798 std::copy_backward(Designators + Idx + 1, 3799 Designators + NumDesignators, 3800 Designators + Idx); 3801 --NumNewDesignators; 3802 return; 3803 } else if (NumNewDesignators == 1) { 3804 Designators[Idx] = *First; 3805 return; 3806 } 3807 3808 Designator *NewDesignators 3809 = new (C) Designator[NumDesignators - 1 + NumNewDesignators]; 3810 std::copy(Designators, Designators + Idx, NewDesignators); 3811 std::copy(First, Last, NewDesignators + Idx); 3812 std::copy(Designators + Idx + 1, Designators + NumDesignators, 3813 NewDesignators + Idx + NumNewDesignators); 3814 Designators = NewDesignators; 3815 NumDesignators = NumDesignators - 1 + NumNewDesignators; 3816} 3817 3818ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc, 3819 ArrayRef<Expr*> exprs, 3820 SourceLocation rparenloc) 3821 : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary, 3822 false, false, false, false), 3823 NumExprs(exprs.size()), LParenLoc(lparenloc), RParenLoc(rparenloc) { 3824 Exprs = new (C) Stmt*[exprs.size()]; 3825 for (unsigned i = 0; i != exprs.size(); ++i) { 3826 if (exprs[i]->isTypeDependent()) 3827 ExprBits.TypeDependent = true; 3828 if (exprs[i]->isValueDependent()) 3829 ExprBits.ValueDependent = true; 3830 if (exprs[i]->isInstantiationDependent()) 3831 ExprBits.InstantiationDependent = true; 3832 if (exprs[i]->containsUnexpandedParameterPack()) 3833 ExprBits.ContainsUnexpandedParameterPack = true; 3834 3835 Exprs[i] = exprs[i]; 3836 } 3837} 3838 3839const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) { 3840 if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e)) 3841 e = ewc->getSubExpr(); 3842 if (const MaterializeTemporaryExpr *m = dyn_cast<MaterializeTemporaryExpr>(e)) 3843 e = m->GetTemporaryExpr(); 3844 e = cast<CXXConstructExpr>(e)->getArg(0); 3845 while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e)) 3846 e = ice->getSubExpr(); 3847 return cast<OpaqueValueExpr>(e); 3848} 3849 3850PseudoObjectExpr *PseudoObjectExpr::Create(ASTContext &Context, EmptyShell sh, 3851 unsigned numSemanticExprs) { 3852 void *buffer = Context.Allocate(sizeof(PseudoObjectExpr) + 3853 (1 + numSemanticExprs) * sizeof(Expr*), 3854 llvm::alignOf<PseudoObjectExpr>()); 3855 return new(buffer) PseudoObjectExpr(sh, numSemanticExprs); 3856} 3857 3858PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs) 3859 : Expr(PseudoObjectExprClass, shell) { 3860 PseudoObjectExprBits.NumSubExprs = numSemanticExprs + 1; 3861} 3862 3863PseudoObjectExpr *PseudoObjectExpr::Create(ASTContext &C, Expr *syntax, 3864 ArrayRef<Expr*> semantics, 3865 unsigned resultIndex) { 3866 assert(syntax && "no syntactic expression!"); 3867 assert(semantics.size() && "no semantic expressions!"); 3868 3869 QualType type; 3870 ExprValueKind VK; 3871 if (resultIndex == NoResult) { 3872 type = C.VoidTy; 3873 VK = VK_RValue; 3874 } else { 3875 assert(resultIndex < semantics.size()); 3876 type = semantics[resultIndex]->getType(); 3877 VK = semantics[resultIndex]->getValueKind(); 3878 assert(semantics[resultIndex]->getObjectKind() == OK_Ordinary); 3879 } 3880 3881 void *buffer = C.Allocate(sizeof(PseudoObjectExpr) + 3882 (1 + semantics.size()) * sizeof(Expr*), 3883 llvm::alignOf<PseudoObjectExpr>()); 3884 return new(buffer) PseudoObjectExpr(type, VK, syntax, semantics, 3885 resultIndex); 3886} 3887 3888PseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK, 3889 Expr *syntax, ArrayRef<Expr*> semantics, 3890 unsigned resultIndex) 3891 : Expr(PseudoObjectExprClass, type, VK, OK_Ordinary, 3892 /*filled in at end of ctor*/ false, false, false, false) { 3893 PseudoObjectExprBits.NumSubExprs = semantics.size() + 1; 3894 PseudoObjectExprBits.ResultIndex = resultIndex + 1; 3895 3896 for (unsigned i = 0, e = semantics.size() + 1; i != e; ++i) { 3897 Expr *E = (i == 0 ? syntax : semantics[i-1]); 3898 getSubExprsBuffer()[i] = E; 3899 3900 if (E->isTypeDependent()) 3901 ExprBits.TypeDependent = true; 3902 if (E->isValueDependent()) 3903 ExprBits.ValueDependent = true; 3904 if (E->isInstantiationDependent()) 3905 ExprBits.InstantiationDependent = true; 3906 if (E->containsUnexpandedParameterPack()) 3907 ExprBits.ContainsUnexpandedParameterPack = true; 3908 3909 if (isa<OpaqueValueExpr>(E)) 3910 assert(cast<OpaqueValueExpr>(E)->getSourceExpr() != 0 && 3911 "opaque-value semantic expressions for pseudo-object " 3912 "operations must have sources"); 3913 } 3914} 3915 3916//===----------------------------------------------------------------------===// 3917// ExprIterator. 3918//===----------------------------------------------------------------------===// 3919 3920Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 3921Expr* ExprIterator::operator*() const { return cast<Expr>(*I); } 3922Expr* ExprIterator::operator->() const { return cast<Expr>(*I); } 3923const Expr* ConstExprIterator::operator[](size_t idx) const { 3924 return cast<Expr>(I[idx]); 3925} 3926const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 3927const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 3928 3929//===----------------------------------------------------------------------===// 3930// Child Iterators for iterating over subexpressions/substatements 3931//===----------------------------------------------------------------------===// 3932 3933// UnaryExprOrTypeTraitExpr 3934Stmt::child_range UnaryExprOrTypeTraitExpr::children() { 3935 // If this is of a type and the type is a VLA type (and not a typedef), the 3936 // size expression of the VLA needs to be treated as an executable expression. 3937 // Why isn't this weirdness documented better in StmtIterator? 3938 if (isArgumentType()) { 3939 if (const VariableArrayType* T = dyn_cast<VariableArrayType>( 3940 getArgumentType().getTypePtr())) 3941 return child_range(child_iterator(T), child_iterator()); 3942 return child_range(); 3943 } 3944 return child_range(&Argument.Ex, &Argument.Ex + 1); 3945} 3946 3947// ObjCMessageExpr 3948Stmt::child_range ObjCMessageExpr::children() { 3949 Stmt **begin; 3950 if (getReceiverKind() == Instance) 3951 begin = reinterpret_cast<Stmt **>(this + 1); 3952 else 3953 begin = reinterpret_cast<Stmt **>(getArgs()); 3954 return child_range(begin, 3955 reinterpret_cast<Stmt **>(getArgs() + getNumArgs())); 3956} 3957 3958ObjCArrayLiteral::ObjCArrayLiteral(ArrayRef<Expr *> Elements, 3959 QualType T, ObjCMethodDecl *Method, 3960 SourceRange SR) 3961 : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary, 3962 false, false, false, false), 3963 NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method) 3964{ 3965 Expr **SaveElements = getElements(); 3966 for (unsigned I = 0, N = Elements.size(); I != N; ++I) { 3967 if (Elements[I]->isTypeDependent() || Elements[I]->isValueDependent()) 3968 ExprBits.ValueDependent = true; 3969 if (Elements[I]->isInstantiationDependent()) 3970 ExprBits.InstantiationDependent = true; 3971 if (Elements[I]->containsUnexpandedParameterPack()) 3972 ExprBits.ContainsUnexpandedParameterPack = true; 3973 3974 SaveElements[I] = Elements[I]; 3975 } 3976} 3977 3978ObjCArrayLiteral *ObjCArrayLiteral::Create(ASTContext &C, 3979 ArrayRef<Expr *> Elements, 3980 QualType T, ObjCMethodDecl * Method, 3981 SourceRange SR) { 3982 void *Mem = C.Allocate(sizeof(ObjCArrayLiteral) 3983 + Elements.size() * sizeof(Expr *)); 3984 return new (Mem) ObjCArrayLiteral(Elements, T, Method, SR); 3985} 3986 3987ObjCArrayLiteral *ObjCArrayLiteral::CreateEmpty(ASTContext &C, 3988 unsigned NumElements) { 3989 3990 void *Mem = C.Allocate(sizeof(ObjCArrayLiteral) 3991 + NumElements * sizeof(Expr *)); 3992 return new (Mem) ObjCArrayLiteral(EmptyShell(), NumElements); 3993} 3994 3995ObjCDictionaryLiteral::ObjCDictionaryLiteral( 3996 ArrayRef<ObjCDictionaryElement> VK, 3997 bool HasPackExpansions, 3998 QualType T, ObjCMethodDecl *method, 3999 SourceRange SR) 4000 : Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary, false, false, 4001 false, false), 4002 NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR), 4003 DictWithObjectsMethod(method) 4004{ 4005 KeyValuePair *KeyValues = getKeyValues(); 4006 ExpansionData *Expansions = getExpansionData(); 4007 for (unsigned I = 0; I < NumElements; I++) { 4008 if (VK[I].Key->isTypeDependent() || VK[I].Key->isValueDependent() || 4009 VK[I].Value->isTypeDependent() || VK[I].Value->isValueDependent()) 4010 ExprBits.ValueDependent = true; 4011 if (VK[I].Key->isInstantiationDependent() || 4012 VK[I].Value->isInstantiationDependent()) 4013 ExprBits.InstantiationDependent = true; 4014 if (VK[I].EllipsisLoc.isInvalid() && 4015 (VK[I].Key->containsUnexpandedParameterPack() || 4016 VK[I].Value->containsUnexpandedParameterPack())) 4017 ExprBits.ContainsUnexpandedParameterPack = true; 4018 4019 KeyValues[I].Key = VK[I].Key; 4020 KeyValues[I].Value = VK[I].Value; 4021 if (Expansions) { 4022 Expansions[I].EllipsisLoc = VK[I].EllipsisLoc; 4023 if (VK[I].NumExpansions) 4024 Expansions[I].NumExpansionsPlusOne = *VK[I].NumExpansions + 1; 4025 else 4026 Expansions[I].NumExpansionsPlusOne = 0; 4027 } 4028 } 4029} 4030 4031ObjCDictionaryLiteral * 4032ObjCDictionaryLiteral::Create(ASTContext &C, 4033 ArrayRef<ObjCDictionaryElement> VK, 4034 bool HasPackExpansions, 4035 QualType T, ObjCMethodDecl *method, 4036 SourceRange SR) { 4037 unsigned ExpansionsSize = 0; 4038 if (HasPackExpansions) 4039 ExpansionsSize = sizeof(ExpansionData) * VK.size(); 4040 4041 void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) + 4042 sizeof(KeyValuePair) * VK.size() + ExpansionsSize); 4043 return new (Mem) ObjCDictionaryLiteral(VK, HasPackExpansions, T, method, SR); 4044} 4045 4046ObjCDictionaryLiteral * 4047ObjCDictionaryLiteral::CreateEmpty(ASTContext &C, unsigned NumElements, 4048 bool HasPackExpansions) { 4049 unsigned ExpansionsSize = 0; 4050 if (HasPackExpansions) 4051 ExpansionsSize = sizeof(ExpansionData) * NumElements; 4052 void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) + 4053 sizeof(KeyValuePair) * NumElements + ExpansionsSize); 4054 return new (Mem) ObjCDictionaryLiteral(EmptyShell(), NumElements, 4055 HasPackExpansions); 4056} 4057 4058ObjCSubscriptRefExpr *ObjCSubscriptRefExpr::Create(ASTContext &C, 4059 Expr *base, 4060 Expr *key, QualType T, 4061 ObjCMethodDecl *getMethod, 4062 ObjCMethodDecl *setMethod, 4063 SourceLocation RB) { 4064 void *Mem = C.Allocate(sizeof(ObjCSubscriptRefExpr)); 4065 return new (Mem) ObjCSubscriptRefExpr(base, key, T, VK_LValue, 4066 OK_ObjCSubscript, 4067 getMethod, setMethod, RB); 4068} 4069 4070AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args, 4071 QualType t, AtomicOp op, SourceLocation RP) 4072 : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary, 4073 false, false, false, false), 4074 NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) 4075{ 4076 assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions"); 4077 for (unsigned i = 0; i != args.size(); i++) { 4078 if (args[i]->isTypeDependent()) 4079 ExprBits.TypeDependent = true; 4080 if (args[i]->isValueDependent()) 4081 ExprBits.ValueDependent = true; 4082 if (args[i]->isInstantiationDependent()) 4083 ExprBits.InstantiationDependent = true; 4084 if (args[i]->containsUnexpandedParameterPack()) 4085 ExprBits.ContainsUnexpandedParameterPack = true; 4086 4087 SubExprs[i] = args[i]; 4088 } 4089} 4090 4091unsigned AtomicExpr::getNumSubExprs(AtomicOp Op) { 4092 switch (Op) { 4093 case AO__c11_atomic_init: 4094 case AO__c11_atomic_load: 4095 case AO__atomic_load_n: 4096 return 2; 4097 4098 case AO__c11_atomic_store: 4099 case AO__c11_atomic_exchange: 4100 case AO__atomic_load: 4101 case AO__atomic_store: 4102 case AO__atomic_store_n: 4103 case AO__atomic_exchange_n: 4104 case AO__c11_atomic_fetch_add: 4105 case AO__c11_atomic_fetch_sub: 4106 case AO__c11_atomic_fetch_and: 4107 case AO__c11_atomic_fetch_or: 4108 case AO__c11_atomic_fetch_xor: 4109 case AO__atomic_fetch_add: 4110 case AO__atomic_fetch_sub: 4111 case AO__atomic_fetch_and: 4112 case AO__atomic_fetch_or: 4113 case AO__atomic_fetch_xor: 4114 case AO__atomic_fetch_nand: 4115 case AO__atomic_add_fetch: 4116 case AO__atomic_sub_fetch: 4117 case AO__atomic_and_fetch: 4118 case AO__atomic_or_fetch: 4119 case AO__atomic_xor_fetch: 4120 case AO__atomic_nand_fetch: 4121 return 3; 4122 4123 case AO__atomic_exchange: 4124 return 4; 4125 4126 case AO__c11_atomic_compare_exchange_strong: 4127 case AO__c11_atomic_compare_exchange_weak: 4128 return 5; 4129 4130 case AO__atomic_compare_exchange: 4131 case AO__atomic_compare_exchange_n: 4132 return 6; 4133 } 4134 llvm_unreachable("unknown atomic op"); 4135} 4136