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