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 const Expr *Init = getInit(0)->IgnoreParens(); 1896 return isa<StringLiteral>(Init) || isa<ObjCEncodeExpr>(Init); 1897} 1898 1899SourceLocation InitListExpr::getLocStart() const { 1900 if (InitListExpr *SyntacticForm = getSyntacticForm()) 1901 return SyntacticForm->getLocStart(); 1902 SourceLocation Beg = LBraceLoc; 1903 if (Beg.isInvalid()) { 1904 // Find the first non-null initializer. 1905 for (InitExprsTy::const_iterator I = InitExprs.begin(), 1906 E = InitExprs.end(); 1907 I != E; ++I) { 1908 if (Stmt *S = *I) { 1909 Beg = S->getLocStart(); 1910 break; 1911 } 1912 } 1913 } 1914 return Beg; 1915} 1916 1917SourceLocation InitListExpr::getLocEnd() const { 1918 if (InitListExpr *SyntacticForm = getSyntacticForm()) 1919 return SyntacticForm->getLocEnd(); 1920 SourceLocation End = RBraceLoc; 1921 if (End.isInvalid()) { 1922 // Find the first non-null initializer from the end. 1923 for (InitExprsTy::const_reverse_iterator I = InitExprs.rbegin(), 1924 E = InitExprs.rend(); 1925 I != E; ++I) { 1926 if (Stmt *S = *I) { 1927 End = S->getLocEnd(); 1928 break; 1929 } 1930 } 1931 } 1932 return End; 1933} 1934 1935/// getFunctionType - Return the underlying function type for this block. 1936/// 1937const FunctionProtoType *BlockExpr::getFunctionType() const { 1938 // The block pointer is never sugared, but the function type might be. 1939 return cast<BlockPointerType>(getType()) 1940 ->getPointeeType()->castAs<FunctionProtoType>(); 1941} 1942 1943SourceLocation BlockExpr::getCaretLocation() const { 1944 return TheBlock->getCaretLocation(); 1945} 1946const Stmt *BlockExpr::getBody() const { 1947 return TheBlock->getBody(); 1948} 1949Stmt *BlockExpr::getBody() { 1950 return TheBlock->getBody(); 1951} 1952 1953 1954//===----------------------------------------------------------------------===// 1955// Generic Expression Routines 1956//===----------------------------------------------------------------------===// 1957 1958/// isUnusedResultAWarning - Return true if this immediate expression should 1959/// be warned about if the result is unused. If so, fill in Loc and Ranges 1960/// with location to warn on and the source range[s] to report with the 1961/// warning. 1962bool Expr::isUnusedResultAWarning(const Expr *&WarnE, SourceLocation &Loc, 1963 SourceRange &R1, SourceRange &R2, 1964 ASTContext &Ctx) const { 1965 // Don't warn if the expr is type dependent. The type could end up 1966 // instantiating to void. 1967 if (isTypeDependent()) 1968 return false; 1969 1970 switch (getStmtClass()) { 1971 default: 1972 if (getType()->isVoidType()) 1973 return false; 1974 WarnE = this; 1975 Loc = getExprLoc(); 1976 R1 = getSourceRange(); 1977 return true; 1978 case ParenExprClass: 1979 return cast<ParenExpr>(this)->getSubExpr()-> 1980 isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 1981 case GenericSelectionExprClass: 1982 return cast<GenericSelectionExpr>(this)->getResultExpr()-> 1983 isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 1984 case ChooseExprClass: 1985 return cast<ChooseExpr>(this)->getChosenSubExpr()-> 1986 isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 1987 case UnaryOperatorClass: { 1988 const UnaryOperator *UO = cast<UnaryOperator>(this); 1989 1990 switch (UO->getOpcode()) { 1991 case UO_Plus: 1992 case UO_Minus: 1993 case UO_AddrOf: 1994 case UO_Not: 1995 case UO_LNot: 1996 case UO_Deref: 1997 break; 1998 case UO_PostInc: 1999 case UO_PostDec: 2000 case UO_PreInc: 2001 case UO_PreDec: // ++/-- 2002 return false; // Not a warning. 2003 case UO_Real: 2004 case UO_Imag: 2005 // accessing a piece of a volatile complex is a side-effect. 2006 if (Ctx.getCanonicalType(UO->getSubExpr()->getType()) 2007 .isVolatileQualified()) 2008 return false; 2009 break; 2010 case UO_Extension: 2011 return UO->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2012 } 2013 WarnE = this; 2014 Loc = UO->getOperatorLoc(); 2015 R1 = UO->getSubExpr()->getSourceRange(); 2016 return true; 2017 } 2018 case BinaryOperatorClass: { 2019 const BinaryOperator *BO = cast<BinaryOperator>(this); 2020 switch (BO->getOpcode()) { 2021 default: 2022 break; 2023 // Consider the RHS of comma for side effects. LHS was checked by 2024 // Sema::CheckCommaOperands. 2025 case BO_Comma: 2026 // ((foo = <blah>), 0) is an idiom for hiding the result (and 2027 // lvalue-ness) of an assignment written in a macro. 2028 if (IntegerLiteral *IE = 2029 dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens())) 2030 if (IE->getValue() == 0) 2031 return false; 2032 return BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2033 // Consider '||', '&&' to have side effects if the LHS or RHS does. 2034 case BO_LAnd: 2035 case BO_LOr: 2036 if (!BO->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) || 2037 !BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)) 2038 return false; 2039 break; 2040 } 2041 if (BO->isAssignmentOp()) 2042 return false; 2043 WarnE = this; 2044 Loc = BO->getOperatorLoc(); 2045 R1 = BO->getLHS()->getSourceRange(); 2046 R2 = BO->getRHS()->getSourceRange(); 2047 return true; 2048 } 2049 case CompoundAssignOperatorClass: 2050 case VAArgExprClass: 2051 case AtomicExprClass: 2052 return false; 2053 2054 case ConditionalOperatorClass: { 2055 // If only one of the LHS or RHS is a warning, the operator might 2056 // be being used for control flow. Only warn if both the LHS and 2057 // RHS are warnings. 2058 const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 2059 if (!Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)) 2060 return false; 2061 if (!Exp->getLHS()) 2062 return true; 2063 return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2064 } 2065 2066 case MemberExprClass: 2067 WarnE = this; 2068 Loc = cast<MemberExpr>(this)->getMemberLoc(); 2069 R1 = SourceRange(Loc, Loc); 2070 R2 = cast<MemberExpr>(this)->getBase()->getSourceRange(); 2071 return true; 2072 2073 case ArraySubscriptExprClass: 2074 WarnE = this; 2075 Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc(); 2076 R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange(); 2077 R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange(); 2078 return true; 2079 2080 case CXXOperatorCallExprClass: { 2081 // We warn about operator== and operator!= even when user-defined operator 2082 // overloads as there is no reasonable way to define these such that they 2083 // have non-trivial, desirable side-effects. See the -Wunused-comparison 2084 // warning: these operators are commonly typo'ed, and so warning on them 2085 // provides additional value as well. If this list is updated, 2086 // DiagnoseUnusedComparison should be as well. 2087 const CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(this); 2088 if (Op->getOperator() == OO_EqualEqual || 2089 Op->getOperator() == OO_ExclaimEqual) { 2090 WarnE = this; 2091 Loc = Op->getOperatorLoc(); 2092 R1 = Op->getSourceRange(); 2093 return true; 2094 } 2095 2096 // Fallthrough for generic call handling. 2097 } 2098 case CallExprClass: 2099 case CXXMemberCallExprClass: 2100 case UserDefinedLiteralClass: { 2101 // If this is a direct call, get the callee. 2102 const CallExpr *CE = cast<CallExpr>(this); 2103 if (const Decl *FD = CE->getCalleeDecl()) { 2104 // If the callee has attribute pure, const, or warn_unused_result, warn 2105 // about it. void foo() { strlen("bar"); } should warn. 2106 // 2107 // Note: If new cases are added here, DiagnoseUnusedExprResult should be 2108 // updated to match for QoI. 2109 if (FD->getAttr<WarnUnusedResultAttr>() || 2110 FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) { 2111 WarnE = this; 2112 Loc = CE->getCallee()->getLocStart(); 2113 R1 = CE->getCallee()->getSourceRange(); 2114 2115 if (unsigned NumArgs = CE->getNumArgs()) 2116 R2 = SourceRange(CE->getArg(0)->getLocStart(), 2117 CE->getArg(NumArgs-1)->getLocEnd()); 2118 return true; 2119 } 2120 } 2121 return false; 2122 } 2123 2124 // If we don't know precisely what we're looking at, let's not warn. 2125 case UnresolvedLookupExprClass: 2126 case CXXUnresolvedConstructExprClass: 2127 return false; 2128 2129 case CXXTemporaryObjectExprClass: 2130 case CXXConstructExprClass: { 2131 if (const CXXRecordDecl *Type = getType()->getAsCXXRecordDecl()) { 2132 if (Type->hasAttr<WarnUnusedAttr>()) { 2133 WarnE = this; 2134 Loc = getLocStart(); 2135 R1 = getSourceRange(); 2136 return true; 2137 } 2138 } 2139 return false; 2140 } 2141 2142 case ObjCMessageExprClass: { 2143 const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this); 2144 if (Ctx.getLangOpts().ObjCAutoRefCount && 2145 ME->isInstanceMessage() && 2146 !ME->getType()->isVoidType() && 2147 ME->getMethodFamily() == OMF_init) { 2148 WarnE = this; 2149 Loc = getExprLoc(); 2150 R1 = ME->getSourceRange(); 2151 return true; 2152 } 2153 2154 const ObjCMethodDecl *MD = ME->getMethodDecl(); 2155 if (MD && MD->getAttr<WarnUnusedResultAttr>()) { 2156 WarnE = this; 2157 Loc = getExprLoc(); 2158 return true; 2159 } 2160 return false; 2161 } 2162 2163 case ObjCPropertyRefExprClass: 2164 WarnE = this; 2165 Loc = getExprLoc(); 2166 R1 = getSourceRange(); 2167 return true; 2168 2169 case PseudoObjectExprClass: { 2170 const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this); 2171 2172 // Only complain about things that have the form of a getter. 2173 if (isa<UnaryOperator>(PO->getSyntacticForm()) || 2174 isa<BinaryOperator>(PO->getSyntacticForm())) 2175 return false; 2176 2177 WarnE = this; 2178 Loc = getExprLoc(); 2179 R1 = getSourceRange(); 2180 return true; 2181 } 2182 2183 case StmtExprClass: { 2184 // Statement exprs don't logically have side effects themselves, but are 2185 // sometimes used in macros in ways that give them a type that is unused. 2186 // For example ({ blah; foo(); }) will end up with a type if foo has a type. 2187 // however, if the result of the stmt expr is dead, we don't want to emit a 2188 // warning. 2189 const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 2190 if (!CS->body_empty()) { 2191 if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 2192 return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2193 if (const LabelStmt *Label = dyn_cast<LabelStmt>(CS->body_back())) 2194 if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt())) 2195 return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2196 } 2197 2198 if (getType()->isVoidType()) 2199 return false; 2200 WarnE = this; 2201 Loc = cast<StmtExpr>(this)->getLParenLoc(); 2202 R1 = getSourceRange(); 2203 return true; 2204 } 2205 case CXXFunctionalCastExprClass: 2206 case CStyleCastExprClass: { 2207 // Ignore an explicit cast to void unless the operand is a non-trivial 2208 // volatile lvalue. 2209 const CastExpr *CE = cast<CastExpr>(this); 2210 if (CE->getCastKind() == CK_ToVoid) { 2211 if (CE->getSubExpr()->isGLValue() && 2212 CE->getSubExpr()->getType().isVolatileQualified()) { 2213 const DeclRefExpr *DRE = 2214 dyn_cast<DeclRefExpr>(CE->getSubExpr()->IgnoreParens()); 2215 if (!(DRE && isa<VarDecl>(DRE->getDecl()) && 2216 cast<VarDecl>(DRE->getDecl())->hasLocalStorage())) { 2217 return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, 2218 R1, R2, Ctx); 2219 } 2220 } 2221 return false; 2222 } 2223 2224 // If this is a cast to a constructor conversion, check the operand. 2225 // Otherwise, the result of the cast is unused. 2226 if (CE->getCastKind() == CK_ConstructorConversion) 2227 return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2228 2229 WarnE = this; 2230 if (const CXXFunctionalCastExpr *CXXCE = 2231 dyn_cast<CXXFunctionalCastExpr>(this)) { 2232 Loc = CXXCE->getLocStart(); 2233 R1 = CXXCE->getSubExpr()->getSourceRange(); 2234 } else { 2235 const CStyleCastExpr *CStyleCE = cast<CStyleCastExpr>(this); 2236 Loc = CStyleCE->getLParenLoc(); 2237 R1 = CStyleCE->getSubExpr()->getSourceRange(); 2238 } 2239 return true; 2240 } 2241 case ImplicitCastExprClass: { 2242 const CastExpr *ICE = cast<ImplicitCastExpr>(this); 2243 2244 // lvalue-to-rvalue conversion on a volatile lvalue is a side-effect. 2245 if (ICE->getCastKind() == CK_LValueToRValue && 2246 ICE->getSubExpr()->getType().isVolatileQualified()) 2247 return false; 2248 2249 return ICE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2250 } 2251 case CXXDefaultArgExprClass: 2252 return (cast<CXXDefaultArgExpr>(this) 2253 ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2254 case CXXDefaultInitExprClass: 2255 return (cast<CXXDefaultInitExpr>(this) 2256 ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2257 2258 case CXXNewExprClass: 2259 // FIXME: In theory, there might be new expressions that don't have side 2260 // effects (e.g. a placement new with an uninitialized POD). 2261 case CXXDeleteExprClass: 2262 return false; 2263 case CXXBindTemporaryExprClass: 2264 return (cast<CXXBindTemporaryExpr>(this) 2265 ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2266 case ExprWithCleanupsClass: 2267 return (cast<ExprWithCleanups>(this) 2268 ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2269 } 2270} 2271 2272/// isOBJCGCCandidate - Check if an expression is objc gc'able. 2273/// returns true, if it is; false otherwise. 2274bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const { 2275 const Expr *E = IgnoreParens(); 2276 switch (E->getStmtClass()) { 2277 default: 2278 return false; 2279 case ObjCIvarRefExprClass: 2280 return true; 2281 case Expr::UnaryOperatorClass: 2282 return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx); 2283 case ImplicitCastExprClass: 2284 return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx); 2285 case MaterializeTemporaryExprClass: 2286 return cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr() 2287 ->isOBJCGCCandidate(Ctx); 2288 case CStyleCastExprClass: 2289 return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx); 2290 case DeclRefExprClass: { 2291 const Decl *D = cast<DeclRefExpr>(E)->getDecl(); 2292 2293 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 2294 if (VD->hasGlobalStorage()) 2295 return true; 2296 QualType T = VD->getType(); 2297 // dereferencing to a pointer is always a gc'able candidate, 2298 // unless it is __weak. 2299 return T->isPointerType() && 2300 (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak); 2301 } 2302 return false; 2303 } 2304 case MemberExprClass: { 2305 const MemberExpr *M = cast<MemberExpr>(E); 2306 return M->getBase()->isOBJCGCCandidate(Ctx); 2307 } 2308 case ArraySubscriptExprClass: 2309 return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx); 2310 } 2311} 2312 2313bool Expr::isBoundMemberFunction(ASTContext &Ctx) const { 2314 if (isTypeDependent()) 2315 return false; 2316 return ClassifyLValue(Ctx) == Expr::LV_MemberFunction; 2317} 2318 2319QualType Expr::findBoundMemberType(const Expr *expr) { 2320 assert(expr->hasPlaceholderType(BuiltinType::BoundMember)); 2321 2322 // Bound member expressions are always one of these possibilities: 2323 // x->m x.m x->*y x.*y 2324 // (possibly parenthesized) 2325 2326 expr = expr->IgnoreParens(); 2327 if (const MemberExpr *mem = dyn_cast<MemberExpr>(expr)) { 2328 assert(isa<CXXMethodDecl>(mem->getMemberDecl())); 2329 return mem->getMemberDecl()->getType(); 2330 } 2331 2332 if (const BinaryOperator *op = dyn_cast<BinaryOperator>(expr)) { 2333 QualType type = op->getRHS()->getType()->castAs<MemberPointerType>() 2334 ->getPointeeType(); 2335 assert(type->isFunctionType()); 2336 return type; 2337 } 2338 2339 assert(isa<UnresolvedMemberExpr>(expr)); 2340 return QualType(); 2341} 2342 2343Expr* Expr::IgnoreParens() { 2344 Expr* E = this; 2345 while (true) { 2346 if (ParenExpr* P = dyn_cast<ParenExpr>(E)) { 2347 E = P->getSubExpr(); 2348 continue; 2349 } 2350 if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) { 2351 if (P->getOpcode() == UO_Extension) { 2352 E = P->getSubExpr(); 2353 continue; 2354 } 2355 } 2356 if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) { 2357 if (!P->isResultDependent()) { 2358 E = P->getResultExpr(); 2359 continue; 2360 } 2361 } 2362 if (ChooseExpr* P = dyn_cast<ChooseExpr>(E)) { 2363 if (!P->isConditionDependent()) { 2364 E = P->getChosenSubExpr(); 2365 continue; 2366 } 2367 } 2368 return E; 2369 } 2370} 2371 2372/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 2373/// or CastExprs or ImplicitCastExprs, returning their operand. 2374Expr *Expr::IgnoreParenCasts() { 2375 Expr *E = this; 2376 while (true) { 2377 E = E->IgnoreParens(); 2378 if (CastExpr *P = dyn_cast<CastExpr>(E)) { 2379 E = P->getSubExpr(); 2380 continue; 2381 } 2382 if (MaterializeTemporaryExpr *Materialize 2383 = dyn_cast<MaterializeTemporaryExpr>(E)) { 2384 E = Materialize->GetTemporaryExpr(); 2385 continue; 2386 } 2387 if (SubstNonTypeTemplateParmExpr *NTTP 2388 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2389 E = NTTP->getReplacement(); 2390 continue; 2391 } 2392 return E; 2393 } 2394} 2395 2396/// IgnoreParenLValueCasts - Ignore parentheses and lvalue-to-rvalue 2397/// casts. This is intended purely as a temporary workaround for code 2398/// that hasn't yet been rewritten to do the right thing about those 2399/// casts, and may disappear along with the last internal use. 2400Expr *Expr::IgnoreParenLValueCasts() { 2401 Expr *E = this; 2402 while (true) { 2403 E = E->IgnoreParens(); 2404 if (CastExpr *P = dyn_cast<CastExpr>(E)) { 2405 if (P->getCastKind() == CK_LValueToRValue) { 2406 E = P->getSubExpr(); 2407 continue; 2408 } 2409 } else if (MaterializeTemporaryExpr *Materialize 2410 = dyn_cast<MaterializeTemporaryExpr>(E)) { 2411 E = Materialize->GetTemporaryExpr(); 2412 continue; 2413 } else if (SubstNonTypeTemplateParmExpr *NTTP 2414 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2415 E = NTTP->getReplacement(); 2416 continue; 2417 } 2418 break; 2419 } 2420 return E; 2421} 2422 2423Expr *Expr::ignoreParenBaseCasts() { 2424 Expr *E = this; 2425 while (true) { 2426 E = E->IgnoreParens(); 2427 if (CastExpr *CE = dyn_cast<CastExpr>(E)) { 2428 if (CE->getCastKind() == CK_DerivedToBase || 2429 CE->getCastKind() == CK_UncheckedDerivedToBase || 2430 CE->getCastKind() == CK_NoOp) { 2431 E = CE->getSubExpr(); 2432 continue; 2433 } 2434 } 2435 2436 return E; 2437 } 2438} 2439 2440Expr *Expr::IgnoreParenImpCasts() { 2441 Expr *E = this; 2442 while (true) { 2443 E = E->IgnoreParens(); 2444 if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) { 2445 E = P->getSubExpr(); 2446 continue; 2447 } 2448 if (MaterializeTemporaryExpr *Materialize 2449 = dyn_cast<MaterializeTemporaryExpr>(E)) { 2450 E = Materialize->GetTemporaryExpr(); 2451 continue; 2452 } 2453 if (SubstNonTypeTemplateParmExpr *NTTP 2454 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2455 E = NTTP->getReplacement(); 2456 continue; 2457 } 2458 return E; 2459 } 2460} 2461 2462Expr *Expr::IgnoreConversionOperator() { 2463 if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(this)) { 2464 if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl())) 2465 return MCE->getImplicitObjectArgument(); 2466 } 2467 return this; 2468} 2469 2470/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the 2471/// value (including ptr->int casts of the same size). Strip off any 2472/// ParenExpr or CastExprs, returning their operand. 2473Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) { 2474 Expr *E = this; 2475 while (true) { 2476 E = E->IgnoreParens(); 2477 2478 if (CastExpr *P = dyn_cast<CastExpr>(E)) { 2479 // We ignore integer <-> casts that are of the same width, ptr<->ptr and 2480 // ptr<->int casts of the same width. We also ignore all identity casts. 2481 Expr *SE = P->getSubExpr(); 2482 2483 if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) { 2484 E = SE; 2485 continue; 2486 } 2487 2488 if ((E->getType()->isPointerType() || 2489 E->getType()->isIntegralType(Ctx)) && 2490 (SE->getType()->isPointerType() || 2491 SE->getType()->isIntegralType(Ctx)) && 2492 Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) { 2493 E = SE; 2494 continue; 2495 } 2496 } 2497 2498 if (SubstNonTypeTemplateParmExpr *NTTP 2499 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2500 E = NTTP->getReplacement(); 2501 continue; 2502 } 2503 2504 return E; 2505 } 2506} 2507 2508bool Expr::isDefaultArgument() const { 2509 const Expr *E = this; 2510 if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E)) 2511 E = M->GetTemporaryExpr(); 2512 2513 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 2514 E = ICE->getSubExprAsWritten(); 2515 2516 return isa<CXXDefaultArgExpr>(E); 2517} 2518 2519/// \brief Skip over any no-op casts and any temporary-binding 2520/// expressions. 2521static const Expr *skipTemporaryBindingsNoOpCastsAndParens(const Expr *E) { 2522 if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E)) 2523 E = M->GetTemporaryExpr(); 2524 2525 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 2526 if (ICE->getCastKind() == CK_NoOp) 2527 E = ICE->getSubExpr(); 2528 else 2529 break; 2530 } 2531 2532 while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E)) 2533 E = BE->getSubExpr(); 2534 2535 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 2536 if (ICE->getCastKind() == CK_NoOp) 2537 E = ICE->getSubExpr(); 2538 else 2539 break; 2540 } 2541 2542 return E->IgnoreParens(); 2543} 2544 2545/// isTemporaryObject - Determines if this expression produces a 2546/// temporary of the given class type. 2547bool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const { 2548 if (!C.hasSameUnqualifiedType(getType(), C.getTypeDeclType(TempTy))) 2549 return false; 2550 2551 const Expr *E = skipTemporaryBindingsNoOpCastsAndParens(this); 2552 2553 // Temporaries are by definition pr-values of class type. 2554 if (!E->Classify(C).isPRValue()) { 2555 // In this context, property reference is a message call and is pr-value. 2556 if (!isa<ObjCPropertyRefExpr>(E)) 2557 return false; 2558 } 2559 2560 // Black-list a few cases which yield pr-values of class type that don't 2561 // refer to temporaries of that type: 2562 2563 // - implicit derived-to-base conversions 2564 if (isa<ImplicitCastExpr>(E)) { 2565 switch (cast<ImplicitCastExpr>(E)->getCastKind()) { 2566 case CK_DerivedToBase: 2567 case CK_UncheckedDerivedToBase: 2568 return false; 2569 default: 2570 break; 2571 } 2572 } 2573 2574 // - member expressions (all) 2575 if (isa<MemberExpr>(E)) 2576 return false; 2577 2578 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) 2579 if (BO->isPtrMemOp()) 2580 return false; 2581 2582 // - opaque values (all) 2583 if (isa<OpaqueValueExpr>(E)) 2584 return false; 2585 2586 return true; 2587} 2588 2589bool Expr::isImplicitCXXThis() const { 2590 const Expr *E = this; 2591 2592 // Strip away parentheses and casts we don't care about. 2593 while (true) { 2594 if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) { 2595 E = Paren->getSubExpr(); 2596 continue; 2597 } 2598 2599 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 2600 if (ICE->getCastKind() == CK_NoOp || 2601 ICE->getCastKind() == CK_LValueToRValue || 2602 ICE->getCastKind() == CK_DerivedToBase || 2603 ICE->getCastKind() == CK_UncheckedDerivedToBase) { 2604 E = ICE->getSubExpr(); 2605 continue; 2606 } 2607 } 2608 2609 if (const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) { 2610 if (UnOp->getOpcode() == UO_Extension) { 2611 E = UnOp->getSubExpr(); 2612 continue; 2613 } 2614 } 2615 2616 if (const MaterializeTemporaryExpr *M 2617 = dyn_cast<MaterializeTemporaryExpr>(E)) { 2618 E = M->GetTemporaryExpr(); 2619 continue; 2620 } 2621 2622 break; 2623 } 2624 2625 if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E)) 2626 return This->isImplicit(); 2627 2628 return false; 2629} 2630 2631/// hasAnyTypeDependentArguments - Determines if any of the expressions 2632/// in Exprs is type-dependent. 2633bool Expr::hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs) { 2634 for (unsigned I = 0; I < Exprs.size(); ++I) 2635 if (Exprs[I]->isTypeDependent()) 2636 return true; 2637 2638 return false; 2639} 2640 2641bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef) const { 2642 // This function is attempting whether an expression is an initializer 2643 // which can be evaluated at compile-time. It very closely parallels 2644 // ConstExprEmitter in CGExprConstant.cpp; if they don't match, it 2645 // will lead to unexpected results. Like ConstExprEmitter, it falls back 2646 // to isEvaluatable most of the time. 2647 // 2648 // If we ever capture reference-binding directly in the AST, we can 2649 // kill the second parameter. 2650 2651 if (IsForRef) { 2652 EvalResult Result; 2653 return EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects; 2654 } 2655 2656 switch (getStmtClass()) { 2657 default: break; 2658 case StringLiteralClass: 2659 case ObjCEncodeExprClass: 2660 return true; 2661 case CXXTemporaryObjectExprClass: 2662 case CXXConstructExprClass: { 2663 const CXXConstructExpr *CE = cast<CXXConstructExpr>(this); 2664 2665 if (CE->getConstructor()->isTrivial() && 2666 CE->getConstructor()->getParent()->hasTrivialDestructor()) { 2667 // Trivial default constructor 2668 if (!CE->getNumArgs()) return true; 2669 2670 // Trivial copy constructor 2671 assert(CE->getNumArgs() == 1 && "trivial ctor with > 1 argument"); 2672 return CE->getArg(0)->isConstantInitializer(Ctx, false); 2673 } 2674 2675 break; 2676 } 2677 case CompoundLiteralExprClass: { 2678 // This handles gcc's extension that allows global initializers like 2679 // "struct x {int x;} x = (struct x) {};". 2680 // FIXME: This accepts other cases it shouldn't! 2681 const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer(); 2682 return Exp->isConstantInitializer(Ctx, false); 2683 } 2684 case InitListExprClass: { 2685 const InitListExpr *ILE = cast<InitListExpr>(this); 2686 if (ILE->getType()->isArrayType()) { 2687 unsigned numInits = ILE->getNumInits(); 2688 for (unsigned i = 0; i < numInits; i++) { 2689 if (!ILE->getInit(i)->isConstantInitializer(Ctx, false)) 2690 return false; 2691 } 2692 return true; 2693 } 2694 2695 if (ILE->getType()->isRecordType()) { 2696 unsigned ElementNo = 0; 2697 RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl(); 2698 for (RecordDecl::field_iterator Field = RD->field_begin(), 2699 FieldEnd = RD->field_end(); Field != FieldEnd; ++Field) { 2700 // If this is a union, skip all the fields that aren't being initialized. 2701 if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field) 2702 continue; 2703 2704 // Don't emit anonymous bitfields, they just affect layout. 2705 if (Field->isUnnamedBitfield()) 2706 continue; 2707 2708 if (ElementNo < ILE->getNumInits()) { 2709 const Expr *Elt = ILE->getInit(ElementNo++); 2710 if (Field->isBitField()) { 2711 // Bitfields have to evaluate to an integer. 2712 llvm::APSInt ResultTmp; 2713 if (!Elt->EvaluateAsInt(ResultTmp, Ctx)) 2714 return false; 2715 } else { 2716 bool RefType = Field->getType()->isReferenceType(); 2717 if (!Elt->isConstantInitializer(Ctx, RefType)) 2718 return false; 2719 } 2720 } 2721 } 2722 return true; 2723 } 2724 2725 break; 2726 } 2727 case ImplicitValueInitExprClass: 2728 return true; 2729 case ParenExprClass: 2730 return cast<ParenExpr>(this)->getSubExpr() 2731 ->isConstantInitializer(Ctx, IsForRef); 2732 case GenericSelectionExprClass: 2733 return cast<GenericSelectionExpr>(this)->getResultExpr() 2734 ->isConstantInitializer(Ctx, IsForRef); 2735 case ChooseExprClass: 2736 if (cast<ChooseExpr>(this)->isConditionDependent()) 2737 return false; 2738 return cast<ChooseExpr>(this)->getChosenSubExpr() 2739 ->isConstantInitializer(Ctx, IsForRef); 2740 case UnaryOperatorClass: { 2741 const UnaryOperator* Exp = cast<UnaryOperator>(this); 2742 if (Exp->getOpcode() == UO_Extension) 2743 return Exp->getSubExpr()->isConstantInitializer(Ctx, false); 2744 break; 2745 } 2746 case CXXFunctionalCastExprClass: 2747 case CXXStaticCastExprClass: 2748 case ImplicitCastExprClass: 2749 case CStyleCastExprClass: 2750 case ObjCBridgedCastExprClass: 2751 case CXXDynamicCastExprClass: 2752 case CXXReinterpretCastExprClass: 2753 case CXXConstCastExprClass: { 2754 const CastExpr *CE = cast<CastExpr>(this); 2755 2756 // Handle misc casts we want to ignore. 2757 if (CE->getCastKind() == CK_NoOp || 2758 CE->getCastKind() == CK_LValueToRValue || 2759 CE->getCastKind() == CK_ToUnion || 2760 CE->getCastKind() == CK_ConstructorConversion || 2761 CE->getCastKind() == CK_NonAtomicToAtomic || 2762 CE->getCastKind() == CK_AtomicToNonAtomic) 2763 return CE->getSubExpr()->isConstantInitializer(Ctx, false); 2764 2765 break; 2766 } 2767 case MaterializeTemporaryExprClass: 2768 return cast<MaterializeTemporaryExpr>(this)->GetTemporaryExpr() 2769 ->isConstantInitializer(Ctx, false); 2770 2771 case SubstNonTypeTemplateParmExprClass: 2772 return cast<SubstNonTypeTemplateParmExpr>(this)->getReplacement() 2773 ->isConstantInitializer(Ctx, false); 2774 case CXXDefaultArgExprClass: 2775 return cast<CXXDefaultArgExpr>(this)->getExpr() 2776 ->isConstantInitializer(Ctx, false); 2777 case CXXDefaultInitExprClass: 2778 return cast<CXXDefaultInitExpr>(this)->getExpr() 2779 ->isConstantInitializer(Ctx, false); 2780 } 2781 return isEvaluatable(Ctx); 2782} 2783 2784bool Expr::HasSideEffects(const ASTContext &Ctx) const { 2785 if (isInstantiationDependent()) 2786 return true; 2787 2788 switch (getStmtClass()) { 2789 case NoStmtClass: 2790 #define ABSTRACT_STMT(Type) 2791 #define STMT(Type, Base) case Type##Class: 2792 #define EXPR(Type, Base) 2793 #include "clang/AST/StmtNodes.inc" 2794 llvm_unreachable("unexpected Expr kind"); 2795 2796 case DependentScopeDeclRefExprClass: 2797 case CXXUnresolvedConstructExprClass: 2798 case CXXDependentScopeMemberExprClass: 2799 case UnresolvedLookupExprClass: 2800 case UnresolvedMemberExprClass: 2801 case PackExpansionExprClass: 2802 case SubstNonTypeTemplateParmPackExprClass: 2803 case FunctionParmPackExprClass: 2804 llvm_unreachable("shouldn't see dependent / unresolved nodes here"); 2805 2806 case DeclRefExprClass: 2807 case ObjCIvarRefExprClass: 2808 case PredefinedExprClass: 2809 case IntegerLiteralClass: 2810 case FloatingLiteralClass: 2811 case ImaginaryLiteralClass: 2812 case StringLiteralClass: 2813 case CharacterLiteralClass: 2814 case OffsetOfExprClass: 2815 case ImplicitValueInitExprClass: 2816 case UnaryExprOrTypeTraitExprClass: 2817 case AddrLabelExprClass: 2818 case GNUNullExprClass: 2819 case CXXBoolLiteralExprClass: 2820 case CXXNullPtrLiteralExprClass: 2821 case CXXThisExprClass: 2822 case CXXScalarValueInitExprClass: 2823 case TypeTraitExprClass: 2824 case UnaryTypeTraitExprClass: 2825 case BinaryTypeTraitExprClass: 2826 case ArrayTypeTraitExprClass: 2827 case ExpressionTraitExprClass: 2828 case CXXNoexceptExprClass: 2829 case SizeOfPackExprClass: 2830 case ObjCStringLiteralClass: 2831 case ObjCEncodeExprClass: 2832 case ObjCBoolLiteralExprClass: 2833 case CXXUuidofExprClass: 2834 case OpaqueValueExprClass: 2835 // These never have a side-effect. 2836 return false; 2837 2838 case CallExprClass: 2839 case MSPropertyRefExprClass: 2840 case CompoundAssignOperatorClass: 2841 case VAArgExprClass: 2842 case AtomicExprClass: 2843 case StmtExprClass: 2844 case CXXOperatorCallExprClass: 2845 case CXXMemberCallExprClass: 2846 case UserDefinedLiteralClass: 2847 case CXXThrowExprClass: 2848 case CXXNewExprClass: 2849 case CXXDeleteExprClass: 2850 case ExprWithCleanupsClass: 2851 case CXXBindTemporaryExprClass: 2852 case BlockExprClass: 2853 case CUDAKernelCallExprClass: 2854 // These always have a side-effect. 2855 return true; 2856 2857 case ParenExprClass: 2858 case ArraySubscriptExprClass: 2859 case MemberExprClass: 2860 case ConditionalOperatorClass: 2861 case BinaryConditionalOperatorClass: 2862 case CompoundLiteralExprClass: 2863 case ExtVectorElementExprClass: 2864 case DesignatedInitExprClass: 2865 case ParenListExprClass: 2866 case CXXPseudoDestructorExprClass: 2867 case CXXStdInitializerListExprClass: 2868 case SubstNonTypeTemplateParmExprClass: 2869 case MaterializeTemporaryExprClass: 2870 case ShuffleVectorExprClass: 2871 case ConvertVectorExprClass: 2872 case AsTypeExprClass: 2873 // These have a side-effect if any subexpression does. 2874 break; 2875 2876 case UnaryOperatorClass: 2877 if (cast<UnaryOperator>(this)->isIncrementDecrementOp()) 2878 return true; 2879 break; 2880 2881 case BinaryOperatorClass: 2882 if (cast<BinaryOperator>(this)->isAssignmentOp()) 2883 return true; 2884 break; 2885 2886 case InitListExprClass: 2887 // FIXME: The children for an InitListExpr doesn't include the array filler. 2888 if (const Expr *E = cast<InitListExpr>(this)->getArrayFiller()) 2889 if (E->HasSideEffects(Ctx)) 2890 return true; 2891 break; 2892 2893 case GenericSelectionExprClass: 2894 return cast<GenericSelectionExpr>(this)->getResultExpr()-> 2895 HasSideEffects(Ctx); 2896 2897 case ChooseExprClass: 2898 return cast<ChooseExpr>(this)->getChosenSubExpr()->HasSideEffects(Ctx); 2899 2900 case CXXDefaultArgExprClass: 2901 return cast<CXXDefaultArgExpr>(this)->getExpr()->HasSideEffects(Ctx); 2902 2903 case CXXDefaultInitExprClass: 2904 if (const Expr *E = cast<CXXDefaultInitExpr>(this)->getExpr()) 2905 return E->HasSideEffects(Ctx); 2906 // If we've not yet parsed the initializer, assume it has side-effects. 2907 return true; 2908 2909 case CXXDynamicCastExprClass: { 2910 // A dynamic_cast expression has side-effects if it can throw. 2911 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(this); 2912 if (DCE->getTypeAsWritten()->isReferenceType() && 2913 DCE->getCastKind() == CK_Dynamic) 2914 return true; 2915 } // Fall through. 2916 case ImplicitCastExprClass: 2917 case CStyleCastExprClass: 2918 case CXXStaticCastExprClass: 2919 case CXXReinterpretCastExprClass: 2920 case CXXConstCastExprClass: 2921 case CXXFunctionalCastExprClass: { 2922 const CastExpr *CE = cast<CastExpr>(this); 2923 if (CE->getCastKind() == CK_LValueToRValue && 2924 CE->getSubExpr()->getType().isVolatileQualified()) 2925 return true; 2926 break; 2927 } 2928 2929 case CXXTypeidExprClass: 2930 // typeid might throw if its subexpression is potentially-evaluated, so has 2931 // side-effects in that case whether or not its subexpression does. 2932 return cast<CXXTypeidExpr>(this)->isPotentiallyEvaluated(); 2933 2934 case CXXConstructExprClass: 2935 case CXXTemporaryObjectExprClass: { 2936 const CXXConstructExpr *CE = cast<CXXConstructExpr>(this); 2937 if (!CE->getConstructor()->isTrivial()) 2938 return true; 2939 // A trivial constructor does not add any side-effects of its own. Just look 2940 // at its arguments. 2941 break; 2942 } 2943 2944 case LambdaExprClass: { 2945 const LambdaExpr *LE = cast<LambdaExpr>(this); 2946 for (LambdaExpr::capture_iterator I = LE->capture_begin(), 2947 E = LE->capture_end(); I != E; ++I) 2948 if (I->getCaptureKind() == LCK_ByCopy) 2949 // FIXME: Only has a side-effect if the variable is volatile or if 2950 // the copy would invoke a non-trivial copy constructor. 2951 return true; 2952 return false; 2953 } 2954 2955 case PseudoObjectExprClass: { 2956 // Only look for side-effects in the semantic form, and look past 2957 // OpaqueValueExpr bindings in that form. 2958 const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this); 2959 for (PseudoObjectExpr::const_semantics_iterator I = PO->semantics_begin(), 2960 E = PO->semantics_end(); 2961 I != E; ++I) { 2962 const Expr *Subexpr = *I; 2963 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Subexpr)) 2964 Subexpr = OVE->getSourceExpr(); 2965 if (Subexpr->HasSideEffects(Ctx)) 2966 return true; 2967 } 2968 return false; 2969 } 2970 2971 case ObjCBoxedExprClass: 2972 case ObjCArrayLiteralClass: 2973 case ObjCDictionaryLiteralClass: 2974 case ObjCMessageExprClass: 2975 case ObjCSelectorExprClass: 2976 case ObjCProtocolExprClass: 2977 case ObjCPropertyRefExprClass: 2978 case ObjCIsaExprClass: 2979 case ObjCIndirectCopyRestoreExprClass: 2980 case ObjCSubscriptRefExprClass: 2981 case ObjCBridgedCastExprClass: 2982 // FIXME: Classify these cases better. 2983 return true; 2984 } 2985 2986 // Recurse to children. 2987 for (const_child_range SubStmts = children(); SubStmts; ++SubStmts) 2988 if (const Stmt *S = *SubStmts) 2989 if (cast<Expr>(S)->HasSideEffects(Ctx)) 2990 return true; 2991 2992 return false; 2993} 2994 2995namespace { 2996 /// \brief Look for a call to a non-trivial function within an expression. 2997 class NonTrivialCallFinder : public EvaluatedExprVisitor<NonTrivialCallFinder> 2998 { 2999 typedef EvaluatedExprVisitor<NonTrivialCallFinder> Inherited; 3000 3001 bool NonTrivial; 3002 3003 public: 3004 explicit NonTrivialCallFinder(ASTContext &Context) 3005 : Inherited(Context), NonTrivial(false) { } 3006 3007 bool hasNonTrivialCall() const { return NonTrivial; } 3008 3009 void VisitCallExpr(CallExpr *E) { 3010 if (CXXMethodDecl *Method 3011 = dyn_cast_or_null<CXXMethodDecl>(E->getCalleeDecl())) { 3012 if (Method->isTrivial()) { 3013 // Recurse to children of the call. 3014 Inherited::VisitStmt(E); 3015 return; 3016 } 3017 } 3018 3019 NonTrivial = true; 3020 } 3021 3022 void VisitCXXConstructExpr(CXXConstructExpr *E) { 3023 if (E->getConstructor()->isTrivial()) { 3024 // Recurse to children of the call. 3025 Inherited::VisitStmt(E); 3026 return; 3027 } 3028 3029 NonTrivial = true; 3030 } 3031 3032 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 3033 if (E->getTemporary()->getDestructor()->isTrivial()) { 3034 Inherited::VisitStmt(E); 3035 return; 3036 } 3037 3038 NonTrivial = true; 3039 } 3040 }; 3041} 3042 3043bool Expr::hasNonTrivialCall(ASTContext &Ctx) { 3044 NonTrivialCallFinder Finder(Ctx); 3045 Finder.Visit(this); 3046 return Finder.hasNonTrivialCall(); 3047} 3048 3049/// isNullPointerConstant - C99 6.3.2.3p3 - Return whether this is a null 3050/// pointer constant or not, as well as the specific kind of constant detected. 3051/// Null pointer constants can be integer constant expressions with the 3052/// value zero, casts of zero to void*, nullptr (C++0X), or __null 3053/// (a GNU extension). 3054Expr::NullPointerConstantKind 3055Expr::isNullPointerConstant(ASTContext &Ctx, 3056 NullPointerConstantValueDependence NPC) const { 3057 if (isValueDependent() && 3058 (!Ctx.getLangOpts().CPlusPlus11 || Ctx.getLangOpts().MicrosoftMode)) { 3059 switch (NPC) { 3060 case NPC_NeverValueDependent: 3061 llvm_unreachable("Unexpected value dependent expression!"); 3062 case NPC_ValueDependentIsNull: 3063 if (isTypeDependent() || getType()->isIntegralType(Ctx)) 3064 return NPCK_ZeroExpression; 3065 else 3066 return NPCK_NotNull; 3067 3068 case NPC_ValueDependentIsNotNull: 3069 return NPCK_NotNull; 3070 } 3071 } 3072 3073 // Strip off a cast to void*, if it exists. Except in C++. 3074 if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 3075 if (!Ctx.getLangOpts().CPlusPlus) { 3076 // Check that it is a cast to void*. 3077 if (const PointerType *PT = CE->getType()->getAs<PointerType>()) { 3078 QualType Pointee = PT->getPointeeType(); 3079 if (!Pointee.hasQualifiers() && 3080 Pointee->isVoidType() && // to void* 3081 CE->getSubExpr()->getType()->isIntegerType()) // from int. 3082 return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 3083 } 3084 } 3085 } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 3086 // Ignore the ImplicitCastExpr type entirely. 3087 return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 3088 } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 3089 // Accept ((void*)0) as a null pointer constant, as many other 3090 // implementations do. 3091 return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 3092 } else if (const GenericSelectionExpr *GE = 3093 dyn_cast<GenericSelectionExpr>(this)) { 3094 if (GE->isResultDependent()) 3095 return NPCK_NotNull; 3096 return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC); 3097 } else if (const ChooseExpr *CE = dyn_cast<ChooseExpr>(this)) { 3098 if (CE->isConditionDependent()) 3099 return NPCK_NotNull; 3100 return CE->getChosenSubExpr()->isNullPointerConstant(Ctx, NPC); 3101 } else if (const CXXDefaultArgExpr *DefaultArg 3102 = dyn_cast<CXXDefaultArgExpr>(this)) { 3103 // See through default argument expressions. 3104 return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC); 3105 } else if (const CXXDefaultInitExpr *DefaultInit 3106 = dyn_cast<CXXDefaultInitExpr>(this)) { 3107 // See through default initializer expressions. 3108 return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC); 3109 } else if (isa<GNUNullExpr>(this)) { 3110 // The GNU __null extension is always a null pointer constant. 3111 return NPCK_GNUNull; 3112 } else if (const MaterializeTemporaryExpr *M 3113 = dyn_cast<MaterializeTemporaryExpr>(this)) { 3114 return M->GetTemporaryExpr()->isNullPointerConstant(Ctx, NPC); 3115 } else if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(this)) { 3116 if (const Expr *Source = OVE->getSourceExpr()) 3117 return Source->isNullPointerConstant(Ctx, NPC); 3118 } 3119 3120 // C++11 nullptr_t is always a null pointer constant. 3121 if (getType()->isNullPtrType()) 3122 return NPCK_CXX11_nullptr; 3123 3124 if (const RecordType *UT = getType()->getAsUnionType()) 3125 if (!Ctx.getLangOpts().CPlusPlus11 && 3126 UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) 3127 if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){ 3128 const Expr *InitExpr = CLE->getInitializer(); 3129 if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr)) 3130 return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC); 3131 } 3132 // This expression must be an integer type. 3133 if (!getType()->isIntegerType() || 3134 (Ctx.getLangOpts().CPlusPlus && getType()->isEnumeralType())) 3135 return NPCK_NotNull; 3136 3137 if (Ctx.getLangOpts().CPlusPlus11) { 3138 // C++11 [conv.ptr]p1: A null pointer constant is an integer literal with 3139 // value zero or a prvalue of type std::nullptr_t. 3140 // Microsoft mode permits C++98 rules reflecting MSVC behavior. 3141 const IntegerLiteral *Lit = dyn_cast<IntegerLiteral>(this); 3142 if (Lit && !Lit->getValue()) 3143 return NPCK_ZeroLiteral; 3144 else if (!Ctx.getLangOpts().MicrosoftMode || 3145 !isCXX98IntegralConstantExpr(Ctx)) 3146 return NPCK_NotNull; 3147 } else { 3148 // If we have an integer constant expression, we need to *evaluate* it and 3149 // test for the value 0. 3150 if (!isIntegerConstantExpr(Ctx)) 3151 return NPCK_NotNull; 3152 } 3153 3154 if (EvaluateKnownConstInt(Ctx) != 0) 3155 return NPCK_NotNull; 3156 3157 if (isa<IntegerLiteral>(this)) 3158 return NPCK_ZeroLiteral; 3159 return NPCK_ZeroExpression; 3160} 3161 3162/// \brief If this expression is an l-value for an Objective C 3163/// property, find the underlying property reference expression. 3164const ObjCPropertyRefExpr *Expr::getObjCProperty() const { 3165 const Expr *E = this; 3166 while (true) { 3167 assert((E->getValueKind() == VK_LValue && 3168 E->getObjectKind() == OK_ObjCProperty) && 3169 "expression is not a property reference"); 3170 E = E->IgnoreParenCasts(); 3171 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 3172 if (BO->getOpcode() == BO_Comma) { 3173 E = BO->getRHS(); 3174 continue; 3175 } 3176 } 3177 3178 break; 3179 } 3180 3181 return cast<ObjCPropertyRefExpr>(E); 3182} 3183 3184bool Expr::isObjCSelfExpr() const { 3185 const Expr *E = IgnoreParenImpCasts(); 3186 3187 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 3188 if (!DRE) 3189 return false; 3190 3191 const ImplicitParamDecl *Param = dyn_cast<ImplicitParamDecl>(DRE->getDecl()); 3192 if (!Param) 3193 return false; 3194 3195 const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(Param->getDeclContext()); 3196 if (!M) 3197 return false; 3198 3199 return M->getSelfDecl() == Param; 3200} 3201 3202FieldDecl *Expr::getSourceBitField() { 3203 Expr *E = this->IgnoreParens(); 3204 3205 while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 3206 if (ICE->getCastKind() == CK_LValueToRValue || 3207 (ICE->getValueKind() != VK_RValue && ICE->getCastKind() == CK_NoOp)) 3208 E = ICE->getSubExpr()->IgnoreParens(); 3209 else 3210 break; 3211 } 3212 3213 if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 3214 if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl())) 3215 if (Field->isBitField()) 3216 return Field; 3217 3218 if (ObjCIvarRefExpr *IvarRef = dyn_cast<ObjCIvarRefExpr>(E)) 3219 if (FieldDecl *Ivar = dyn_cast<FieldDecl>(IvarRef->getDecl())) 3220 if (Ivar->isBitField()) 3221 return Ivar; 3222 3223 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E)) 3224 if (FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl())) 3225 if (Field->isBitField()) 3226 return Field; 3227 3228 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) { 3229 if (BinOp->isAssignmentOp() && BinOp->getLHS()) 3230 return BinOp->getLHS()->getSourceBitField(); 3231 3232 if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS()) 3233 return BinOp->getRHS()->getSourceBitField(); 3234 } 3235 3236 return 0; 3237} 3238 3239bool Expr::refersToVectorElement() const { 3240 const Expr *E = this->IgnoreParens(); 3241 3242 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 3243 if (ICE->getValueKind() != VK_RValue && 3244 ICE->getCastKind() == CK_NoOp) 3245 E = ICE->getSubExpr()->IgnoreParens(); 3246 else 3247 break; 3248 } 3249 3250 if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) 3251 return ASE->getBase()->getType()->isVectorType(); 3252 3253 if (isa<ExtVectorElementExpr>(E)) 3254 return true; 3255 3256 return false; 3257} 3258 3259/// isArrow - Return true if the base expression is a pointer to vector, 3260/// return false if the base expression is a vector. 3261bool ExtVectorElementExpr::isArrow() const { 3262 return getBase()->getType()->isPointerType(); 3263} 3264 3265unsigned ExtVectorElementExpr::getNumElements() const { 3266 if (const VectorType *VT = getType()->getAs<VectorType>()) 3267 return VT->getNumElements(); 3268 return 1; 3269} 3270 3271/// containsDuplicateElements - Return true if any element access is repeated. 3272bool ExtVectorElementExpr::containsDuplicateElements() const { 3273 // FIXME: Refactor this code to an accessor on the AST node which returns the 3274 // "type" of component access, and share with code below and in Sema. 3275 StringRef Comp = Accessor->getName(); 3276 3277 // Halving swizzles do not contain duplicate elements. 3278 if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd") 3279 return false; 3280 3281 // Advance past s-char prefix on hex swizzles. 3282 if (Comp[0] == 's' || Comp[0] == 'S') 3283 Comp = Comp.substr(1); 3284 3285 for (unsigned i = 0, e = Comp.size(); i != e; ++i) 3286 if (Comp.substr(i + 1).find(Comp[i]) != StringRef::npos) 3287 return true; 3288 3289 return false; 3290} 3291 3292/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 3293void ExtVectorElementExpr::getEncodedElementAccess( 3294 SmallVectorImpl<unsigned> &Elts) const { 3295 StringRef Comp = Accessor->getName(); 3296 if (Comp[0] == 's' || Comp[0] == 'S') 3297 Comp = Comp.substr(1); 3298 3299 bool isHi = Comp == "hi"; 3300 bool isLo = Comp == "lo"; 3301 bool isEven = Comp == "even"; 3302 bool isOdd = Comp == "odd"; 3303 3304 for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 3305 uint64_t Index; 3306 3307 if (isHi) 3308 Index = e + i; 3309 else if (isLo) 3310 Index = i; 3311 else if (isEven) 3312 Index = 2 * i; 3313 else if (isOdd) 3314 Index = 2 * i + 1; 3315 else 3316 Index = ExtVectorType::getAccessorIdx(Comp[i]); 3317 3318 Elts.push_back(Index); 3319 } 3320} 3321 3322ObjCMessageExpr::ObjCMessageExpr(QualType T, 3323 ExprValueKind VK, 3324 SourceLocation LBracLoc, 3325 SourceLocation SuperLoc, 3326 bool IsInstanceSuper, 3327 QualType SuperType, 3328 Selector Sel, 3329 ArrayRef<SourceLocation> SelLocs, 3330 SelectorLocationsKind SelLocsK, 3331 ObjCMethodDecl *Method, 3332 ArrayRef<Expr *> Args, 3333 SourceLocation RBracLoc, 3334 bool isImplicit) 3335 : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, 3336 /*TypeDependent=*/false, /*ValueDependent=*/false, 3337 /*InstantiationDependent=*/false, 3338 /*ContainsUnexpandedParameterPack=*/false), 3339 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 3340 : Sel.getAsOpaquePtr())), 3341 Kind(IsInstanceSuper? SuperInstance : SuperClass), 3342 HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit), 3343 SuperLoc(SuperLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc) 3344{ 3345 initArgsAndSelLocs(Args, SelLocs, SelLocsK); 3346 setReceiverPointer(SuperType.getAsOpaquePtr()); 3347} 3348 3349ObjCMessageExpr::ObjCMessageExpr(QualType T, 3350 ExprValueKind VK, 3351 SourceLocation LBracLoc, 3352 TypeSourceInfo *Receiver, 3353 Selector Sel, 3354 ArrayRef<SourceLocation> SelLocs, 3355 SelectorLocationsKind SelLocsK, 3356 ObjCMethodDecl *Method, 3357 ArrayRef<Expr *> Args, 3358 SourceLocation RBracLoc, 3359 bool isImplicit) 3360 : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(), 3361 T->isDependentType(), T->isInstantiationDependentType(), 3362 T->containsUnexpandedParameterPack()), 3363 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 3364 : Sel.getAsOpaquePtr())), 3365 Kind(Class), 3366 HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit), 3367 LBracLoc(LBracLoc), RBracLoc(RBracLoc) 3368{ 3369 initArgsAndSelLocs(Args, SelLocs, SelLocsK); 3370 setReceiverPointer(Receiver); 3371} 3372 3373ObjCMessageExpr::ObjCMessageExpr(QualType T, 3374 ExprValueKind VK, 3375 SourceLocation LBracLoc, 3376 Expr *Receiver, 3377 Selector Sel, 3378 ArrayRef<SourceLocation> SelLocs, 3379 SelectorLocationsKind SelLocsK, 3380 ObjCMethodDecl *Method, 3381 ArrayRef<Expr *> Args, 3382 SourceLocation RBracLoc, 3383 bool isImplicit) 3384 : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, Receiver->isTypeDependent(), 3385 Receiver->isTypeDependent(), 3386 Receiver->isInstantiationDependent(), 3387 Receiver->containsUnexpandedParameterPack()), 3388 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 3389 : Sel.getAsOpaquePtr())), 3390 Kind(Instance), 3391 HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit), 3392 LBracLoc(LBracLoc), RBracLoc(RBracLoc) 3393{ 3394 initArgsAndSelLocs(Args, SelLocs, SelLocsK); 3395 setReceiverPointer(Receiver); 3396} 3397 3398void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef<Expr *> Args, 3399 ArrayRef<SourceLocation> SelLocs, 3400 SelectorLocationsKind SelLocsK) { 3401 setNumArgs(Args.size()); 3402 Expr **MyArgs = getArgs(); 3403 for (unsigned I = 0; I != Args.size(); ++I) { 3404 if (Args[I]->isTypeDependent()) 3405 ExprBits.TypeDependent = true; 3406 if (Args[I]->isValueDependent()) 3407 ExprBits.ValueDependent = true; 3408 if (Args[I]->isInstantiationDependent()) 3409 ExprBits.InstantiationDependent = true; 3410 if (Args[I]->containsUnexpandedParameterPack()) 3411 ExprBits.ContainsUnexpandedParameterPack = true; 3412 3413 MyArgs[I] = Args[I]; 3414 } 3415 3416 SelLocsKind = SelLocsK; 3417 if (!isImplicit()) { 3418 if (SelLocsK == SelLoc_NonStandard) 3419 std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs()); 3420 } 3421} 3422 3423ObjCMessageExpr *ObjCMessageExpr::Create(const ASTContext &Context, QualType T, 3424 ExprValueKind VK, 3425 SourceLocation LBracLoc, 3426 SourceLocation SuperLoc, 3427 bool IsInstanceSuper, 3428 QualType SuperType, 3429 Selector Sel, 3430 ArrayRef<SourceLocation> SelLocs, 3431 ObjCMethodDecl *Method, 3432 ArrayRef<Expr *> Args, 3433 SourceLocation RBracLoc, 3434 bool isImplicit) { 3435 assert((!SelLocs.empty() || isImplicit) && 3436 "No selector locs for non-implicit message"); 3437 ObjCMessageExpr *Mem; 3438 SelectorLocationsKind SelLocsK = SelectorLocationsKind(); 3439 if (isImplicit) 3440 Mem = alloc(Context, Args.size(), 0); 3441 else 3442 Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); 3443 return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, SuperLoc, IsInstanceSuper, 3444 SuperType, Sel, SelLocs, SelLocsK, 3445 Method, Args, RBracLoc, isImplicit); 3446} 3447 3448ObjCMessageExpr *ObjCMessageExpr::Create(const ASTContext &Context, QualType T, 3449 ExprValueKind VK, 3450 SourceLocation LBracLoc, 3451 TypeSourceInfo *Receiver, 3452 Selector Sel, 3453 ArrayRef<SourceLocation> SelLocs, 3454 ObjCMethodDecl *Method, 3455 ArrayRef<Expr *> Args, 3456 SourceLocation RBracLoc, 3457 bool isImplicit) { 3458 assert((!SelLocs.empty() || isImplicit) && 3459 "No selector locs for non-implicit message"); 3460 ObjCMessageExpr *Mem; 3461 SelectorLocationsKind SelLocsK = SelectorLocationsKind(); 3462 if (isImplicit) 3463 Mem = alloc(Context, Args.size(), 0); 3464 else 3465 Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); 3466 return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, 3467 SelLocs, SelLocsK, Method, Args, RBracLoc, 3468 isImplicit); 3469} 3470 3471ObjCMessageExpr *ObjCMessageExpr::Create(const ASTContext &Context, QualType T, 3472 ExprValueKind VK, 3473 SourceLocation LBracLoc, 3474 Expr *Receiver, 3475 Selector Sel, 3476 ArrayRef<SourceLocation> SelLocs, 3477 ObjCMethodDecl *Method, 3478 ArrayRef<Expr *> Args, 3479 SourceLocation RBracLoc, 3480 bool isImplicit) { 3481 assert((!SelLocs.empty() || isImplicit) && 3482 "No selector locs for non-implicit message"); 3483 ObjCMessageExpr *Mem; 3484 SelectorLocationsKind SelLocsK = SelectorLocationsKind(); 3485 if (isImplicit) 3486 Mem = alloc(Context, Args.size(), 0); 3487 else 3488 Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); 3489 return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, 3490 SelLocs, SelLocsK, Method, Args, RBracLoc, 3491 isImplicit); 3492} 3493 3494ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(const ASTContext &Context, 3495 unsigned NumArgs, 3496 unsigned NumStoredSelLocs) { 3497 ObjCMessageExpr *Mem = alloc(Context, NumArgs, NumStoredSelLocs); 3498 return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs); 3499} 3500 3501ObjCMessageExpr *ObjCMessageExpr::alloc(const ASTContext &C, 3502 ArrayRef<Expr *> Args, 3503 SourceLocation RBraceLoc, 3504 ArrayRef<SourceLocation> SelLocs, 3505 Selector Sel, 3506 SelectorLocationsKind &SelLocsK) { 3507 SelLocsK = hasStandardSelectorLocs(Sel, SelLocs, Args, RBraceLoc); 3508 unsigned NumStoredSelLocs = (SelLocsK == SelLoc_NonStandard) ? SelLocs.size() 3509 : 0; 3510 return alloc(C, Args.size(), NumStoredSelLocs); 3511} 3512 3513ObjCMessageExpr *ObjCMessageExpr::alloc(const ASTContext &C, 3514 unsigned NumArgs, 3515 unsigned NumStoredSelLocs) { 3516 unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) + 3517 NumArgs * sizeof(Expr *) + NumStoredSelLocs * sizeof(SourceLocation); 3518 return (ObjCMessageExpr *)C.Allocate(Size, 3519 llvm::AlignOf<ObjCMessageExpr>::Alignment); 3520} 3521 3522void ObjCMessageExpr::getSelectorLocs( 3523 SmallVectorImpl<SourceLocation> &SelLocs) const { 3524 for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i) 3525 SelLocs.push_back(getSelectorLoc(i)); 3526} 3527 3528SourceRange ObjCMessageExpr::getReceiverRange() const { 3529 switch (getReceiverKind()) { 3530 case Instance: 3531 return getInstanceReceiver()->getSourceRange(); 3532 3533 case Class: 3534 return getClassReceiverTypeInfo()->getTypeLoc().getSourceRange(); 3535 3536 case SuperInstance: 3537 case SuperClass: 3538 return getSuperLoc(); 3539 } 3540 3541 llvm_unreachable("Invalid ReceiverKind!"); 3542} 3543 3544Selector ObjCMessageExpr::getSelector() const { 3545 if (HasMethod) 3546 return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod) 3547 ->getSelector(); 3548 return Selector(SelectorOrMethod); 3549} 3550 3551QualType ObjCMessageExpr::getReceiverType() const { 3552 switch (getReceiverKind()) { 3553 case Instance: 3554 return getInstanceReceiver()->getType(); 3555 case Class: 3556 return getClassReceiver(); 3557 case SuperInstance: 3558 case SuperClass: 3559 return getSuperType(); 3560 } 3561 3562 llvm_unreachable("unexpected receiver kind"); 3563} 3564 3565ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const { 3566 QualType T = getReceiverType(); 3567 3568 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>()) 3569 return Ptr->getInterfaceDecl(); 3570 3571 if (const ObjCObjectType *Ty = T->getAs<ObjCObjectType>()) 3572 return Ty->getInterface(); 3573 3574 return 0; 3575} 3576 3577StringRef ObjCBridgedCastExpr::getBridgeKindName() const { 3578 switch (getBridgeKind()) { 3579 case OBC_Bridge: 3580 return "__bridge"; 3581 case OBC_BridgeTransfer: 3582 return "__bridge_transfer"; 3583 case OBC_BridgeRetained: 3584 return "__bridge_retained"; 3585 } 3586 3587 llvm_unreachable("Invalid BridgeKind!"); 3588} 3589 3590ShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args, 3591 QualType Type, SourceLocation BLoc, 3592 SourceLocation RP) 3593 : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary, 3594 Type->isDependentType(), Type->isDependentType(), 3595 Type->isInstantiationDependentType(), 3596 Type->containsUnexpandedParameterPack()), 3597 BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) 3598{ 3599 SubExprs = new (C) Stmt*[args.size()]; 3600 for (unsigned i = 0; i != args.size(); i++) { 3601 if (args[i]->isTypeDependent()) 3602 ExprBits.TypeDependent = true; 3603 if (args[i]->isValueDependent()) 3604 ExprBits.ValueDependent = true; 3605 if (args[i]->isInstantiationDependent()) 3606 ExprBits.InstantiationDependent = true; 3607 if (args[i]->containsUnexpandedParameterPack()) 3608 ExprBits.ContainsUnexpandedParameterPack = true; 3609 3610 SubExprs[i] = args[i]; 3611 } 3612} 3613 3614void ShuffleVectorExpr::setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs) { 3615 if (SubExprs) C.Deallocate(SubExprs); 3616 3617 this->NumExprs = Exprs.size(); 3618 SubExprs = new (C) Stmt*[NumExprs]; 3619 memcpy(SubExprs, Exprs.data(), sizeof(Expr *) * Exprs.size()); 3620} 3621 3622GenericSelectionExpr::GenericSelectionExpr(const ASTContext &Context, 3623 SourceLocation GenericLoc, Expr *ControllingExpr, 3624 ArrayRef<TypeSourceInfo*> AssocTypes, 3625 ArrayRef<Expr*> AssocExprs, 3626 SourceLocation DefaultLoc, 3627 SourceLocation RParenLoc, 3628 bool ContainsUnexpandedParameterPack, 3629 unsigned ResultIndex) 3630 : Expr(GenericSelectionExprClass, 3631 AssocExprs[ResultIndex]->getType(), 3632 AssocExprs[ResultIndex]->getValueKind(), 3633 AssocExprs[ResultIndex]->getObjectKind(), 3634 AssocExprs[ResultIndex]->isTypeDependent(), 3635 AssocExprs[ResultIndex]->isValueDependent(), 3636 AssocExprs[ResultIndex]->isInstantiationDependent(), 3637 ContainsUnexpandedParameterPack), 3638 AssocTypes(new (Context) TypeSourceInfo*[AssocTypes.size()]), 3639 SubExprs(new (Context) Stmt*[END_EXPR+AssocExprs.size()]), 3640 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex), 3641 GenericLoc(GenericLoc), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) { 3642 SubExprs[CONTROLLING] = ControllingExpr; 3643 assert(AssocTypes.size() == AssocExprs.size()); 3644 std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes); 3645 std::copy(AssocExprs.begin(), AssocExprs.end(), SubExprs+END_EXPR); 3646} 3647 3648GenericSelectionExpr::GenericSelectionExpr(const ASTContext &Context, 3649 SourceLocation GenericLoc, Expr *ControllingExpr, 3650 ArrayRef<TypeSourceInfo*> AssocTypes, 3651 ArrayRef<Expr*> AssocExprs, 3652 SourceLocation DefaultLoc, 3653 SourceLocation RParenLoc, 3654 bool ContainsUnexpandedParameterPack) 3655 : Expr(GenericSelectionExprClass, 3656 Context.DependentTy, 3657 VK_RValue, 3658 OK_Ordinary, 3659 /*isTypeDependent=*/true, 3660 /*isValueDependent=*/true, 3661 /*isInstantiationDependent=*/true, 3662 ContainsUnexpandedParameterPack), 3663 AssocTypes(new (Context) TypeSourceInfo*[AssocTypes.size()]), 3664 SubExprs(new (Context) Stmt*[END_EXPR+AssocExprs.size()]), 3665 NumAssocs(AssocExprs.size()), ResultIndex(-1U), GenericLoc(GenericLoc), 3666 DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) { 3667 SubExprs[CONTROLLING] = ControllingExpr; 3668 assert(AssocTypes.size() == AssocExprs.size()); 3669 std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes); 3670 std::copy(AssocExprs.begin(), AssocExprs.end(), SubExprs+END_EXPR); 3671} 3672 3673//===----------------------------------------------------------------------===// 3674// DesignatedInitExpr 3675//===----------------------------------------------------------------------===// 3676 3677IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() const { 3678 assert(Kind == FieldDesignator && "Only valid on a field designator"); 3679 if (Field.NameOrField & 0x01) 3680 return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01); 3681 else 3682 return getField()->getIdentifier(); 3683} 3684 3685DesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty, 3686 unsigned NumDesignators, 3687 const Designator *Designators, 3688 SourceLocation EqualOrColonLoc, 3689 bool GNUSyntax, 3690 ArrayRef<Expr*> IndexExprs, 3691 Expr *Init) 3692 : Expr(DesignatedInitExprClass, Ty, 3693 Init->getValueKind(), Init->getObjectKind(), 3694 Init->isTypeDependent(), Init->isValueDependent(), 3695 Init->isInstantiationDependent(), 3696 Init->containsUnexpandedParameterPack()), 3697 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax), 3698 NumDesignators(NumDesignators), NumSubExprs(IndexExprs.size() + 1) { 3699 this->Designators = new (C) Designator[NumDesignators]; 3700 3701 // Record the initializer itself. 3702 child_range Child = children(); 3703 *Child++ = Init; 3704 3705 // Copy the designators and their subexpressions, computing 3706 // value-dependence along the way. 3707 unsigned IndexIdx = 0; 3708 for (unsigned I = 0; I != NumDesignators; ++I) { 3709 this->Designators[I] = Designators[I]; 3710 3711 if (this->Designators[I].isArrayDesignator()) { 3712 // Compute type- and value-dependence. 3713 Expr *Index = IndexExprs[IndexIdx]; 3714 if (Index->isTypeDependent() || Index->isValueDependent()) 3715 ExprBits.ValueDependent = true; 3716 if (Index->isInstantiationDependent()) 3717 ExprBits.InstantiationDependent = true; 3718 // Propagate unexpanded parameter packs. 3719 if (Index->containsUnexpandedParameterPack()) 3720 ExprBits.ContainsUnexpandedParameterPack = true; 3721 3722 // Copy the index expressions into permanent storage. 3723 *Child++ = IndexExprs[IndexIdx++]; 3724 } else if (this->Designators[I].isArrayRangeDesignator()) { 3725 // Compute type- and value-dependence. 3726 Expr *Start = IndexExprs[IndexIdx]; 3727 Expr *End = IndexExprs[IndexIdx + 1]; 3728 if (Start->isTypeDependent() || Start->isValueDependent() || 3729 End->isTypeDependent() || End->isValueDependent()) { 3730 ExprBits.ValueDependent = true; 3731 ExprBits.InstantiationDependent = true; 3732 } else if (Start->isInstantiationDependent() || 3733 End->isInstantiationDependent()) { 3734 ExprBits.InstantiationDependent = true; 3735 } 3736 3737 // Propagate unexpanded parameter packs. 3738 if (Start->containsUnexpandedParameterPack() || 3739 End->containsUnexpandedParameterPack()) 3740 ExprBits.ContainsUnexpandedParameterPack = true; 3741 3742 // Copy the start/end expressions into permanent storage. 3743 *Child++ = IndexExprs[IndexIdx++]; 3744 *Child++ = IndexExprs[IndexIdx++]; 3745 } 3746 } 3747 3748 assert(IndexIdx == IndexExprs.size() && "Wrong number of index expressions"); 3749} 3750 3751DesignatedInitExpr * 3752DesignatedInitExpr::Create(const ASTContext &C, Designator *Designators, 3753 unsigned NumDesignators, 3754 ArrayRef<Expr*> IndexExprs, 3755 SourceLocation ColonOrEqualLoc, 3756 bool UsesColonSyntax, Expr *Init) { 3757 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 3758 sizeof(Stmt *) * (IndexExprs.size() + 1), 8); 3759 return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators, 3760 ColonOrEqualLoc, UsesColonSyntax, 3761 IndexExprs, Init); 3762} 3763 3764DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(const ASTContext &C, 3765 unsigned NumIndexExprs) { 3766 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 3767 sizeof(Stmt *) * (NumIndexExprs + 1), 8); 3768 return new (Mem) DesignatedInitExpr(NumIndexExprs + 1); 3769} 3770 3771void DesignatedInitExpr::setDesignators(const ASTContext &C, 3772 const Designator *Desigs, 3773 unsigned NumDesigs) { 3774 Designators = new (C) Designator[NumDesigs]; 3775 NumDesignators = NumDesigs; 3776 for (unsigned I = 0; I != NumDesigs; ++I) 3777 Designators[I] = Desigs[I]; 3778} 3779 3780SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const { 3781 DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this); 3782 if (size() == 1) 3783 return DIE->getDesignator(0)->getSourceRange(); 3784 return SourceRange(DIE->getDesignator(0)->getLocStart(), 3785 DIE->getDesignator(size()-1)->getLocEnd()); 3786} 3787 3788SourceLocation DesignatedInitExpr::getLocStart() const { 3789 SourceLocation StartLoc; 3790 Designator &First = 3791 *const_cast<DesignatedInitExpr*>(this)->designators_begin(); 3792 if (First.isFieldDesignator()) { 3793 if (GNUSyntax) 3794 StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc); 3795 else 3796 StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc); 3797 } else 3798 StartLoc = 3799 SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc); 3800 return StartLoc; 3801} 3802 3803SourceLocation DesignatedInitExpr::getLocEnd() const { 3804 return getInit()->getLocEnd(); 3805} 3806 3807Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) const { 3808 assert(D.Kind == Designator::ArrayDesignator && "Requires array designator"); 3809 char *Ptr = static_cast<char *>( 3810 const_cast<void *>(static_cast<const void *>(this))); 3811 Ptr += sizeof(DesignatedInitExpr); 3812 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 3813 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 3814} 3815 3816Expr *DesignatedInitExpr::getArrayRangeStart(const Designator &D) const { 3817 assert(D.Kind == Designator::ArrayRangeDesignator && 3818 "Requires array range designator"); 3819 char *Ptr = static_cast<char *>( 3820 const_cast<void *>(static_cast<const void *>(this))); 3821 Ptr += sizeof(DesignatedInitExpr); 3822 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 3823 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 3824} 3825 3826Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator &D) const { 3827 assert(D.Kind == Designator::ArrayRangeDesignator && 3828 "Requires array range designator"); 3829 char *Ptr = static_cast<char *>( 3830 const_cast<void *>(static_cast<const void *>(this))); 3831 Ptr += sizeof(DesignatedInitExpr); 3832 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 3833 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2)); 3834} 3835 3836/// \brief Replaces the designator at index @p Idx with the series 3837/// of designators in [First, Last). 3838void DesignatedInitExpr::ExpandDesignator(const ASTContext &C, unsigned Idx, 3839 const Designator *First, 3840 const Designator *Last) { 3841 unsigned NumNewDesignators = Last - First; 3842 if (NumNewDesignators == 0) { 3843 std::copy_backward(Designators + Idx + 1, 3844 Designators + NumDesignators, 3845 Designators + Idx); 3846 --NumNewDesignators; 3847 return; 3848 } else if (NumNewDesignators == 1) { 3849 Designators[Idx] = *First; 3850 return; 3851 } 3852 3853 Designator *NewDesignators 3854 = new (C) Designator[NumDesignators - 1 + NumNewDesignators]; 3855 std::copy(Designators, Designators + Idx, NewDesignators); 3856 std::copy(First, Last, NewDesignators + Idx); 3857 std::copy(Designators + Idx + 1, Designators + NumDesignators, 3858 NewDesignators + Idx + NumNewDesignators); 3859 Designators = NewDesignators; 3860 NumDesignators = NumDesignators - 1 + NumNewDesignators; 3861} 3862 3863ParenListExpr::ParenListExpr(const ASTContext& C, SourceLocation lparenloc, 3864 ArrayRef<Expr*> exprs, 3865 SourceLocation rparenloc) 3866 : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary, 3867 false, false, false, false), 3868 NumExprs(exprs.size()), LParenLoc(lparenloc), RParenLoc(rparenloc) { 3869 Exprs = new (C) Stmt*[exprs.size()]; 3870 for (unsigned i = 0; i != exprs.size(); ++i) { 3871 if (exprs[i]->isTypeDependent()) 3872 ExprBits.TypeDependent = true; 3873 if (exprs[i]->isValueDependent()) 3874 ExprBits.ValueDependent = true; 3875 if (exprs[i]->isInstantiationDependent()) 3876 ExprBits.InstantiationDependent = true; 3877 if (exprs[i]->containsUnexpandedParameterPack()) 3878 ExprBits.ContainsUnexpandedParameterPack = true; 3879 3880 Exprs[i] = exprs[i]; 3881 } 3882} 3883 3884const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) { 3885 if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e)) 3886 e = ewc->getSubExpr(); 3887 if (const MaterializeTemporaryExpr *m = dyn_cast<MaterializeTemporaryExpr>(e)) 3888 e = m->GetTemporaryExpr(); 3889 e = cast<CXXConstructExpr>(e)->getArg(0); 3890 while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e)) 3891 e = ice->getSubExpr(); 3892 return cast<OpaqueValueExpr>(e); 3893} 3894 3895PseudoObjectExpr *PseudoObjectExpr::Create(const ASTContext &Context, 3896 EmptyShell sh, 3897 unsigned numSemanticExprs) { 3898 void *buffer = Context.Allocate(sizeof(PseudoObjectExpr) + 3899 (1 + numSemanticExprs) * sizeof(Expr*), 3900 llvm::alignOf<PseudoObjectExpr>()); 3901 return new(buffer) PseudoObjectExpr(sh, numSemanticExprs); 3902} 3903 3904PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs) 3905 : Expr(PseudoObjectExprClass, shell) { 3906 PseudoObjectExprBits.NumSubExprs = numSemanticExprs + 1; 3907} 3908 3909PseudoObjectExpr *PseudoObjectExpr::Create(const ASTContext &C, Expr *syntax, 3910 ArrayRef<Expr*> semantics, 3911 unsigned resultIndex) { 3912 assert(syntax && "no syntactic expression!"); 3913 assert(semantics.size() && "no semantic expressions!"); 3914 3915 QualType type; 3916 ExprValueKind VK; 3917 if (resultIndex == NoResult) { 3918 type = C.VoidTy; 3919 VK = VK_RValue; 3920 } else { 3921 assert(resultIndex < semantics.size()); 3922 type = semantics[resultIndex]->getType(); 3923 VK = semantics[resultIndex]->getValueKind(); 3924 assert(semantics[resultIndex]->getObjectKind() == OK_Ordinary); 3925 } 3926 3927 void *buffer = C.Allocate(sizeof(PseudoObjectExpr) + 3928 (1 + semantics.size()) * sizeof(Expr*), 3929 llvm::alignOf<PseudoObjectExpr>()); 3930 return new(buffer) PseudoObjectExpr(type, VK, syntax, semantics, 3931 resultIndex); 3932} 3933 3934PseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK, 3935 Expr *syntax, ArrayRef<Expr*> semantics, 3936 unsigned resultIndex) 3937 : Expr(PseudoObjectExprClass, type, VK, OK_Ordinary, 3938 /*filled in at end of ctor*/ false, false, false, false) { 3939 PseudoObjectExprBits.NumSubExprs = semantics.size() + 1; 3940 PseudoObjectExprBits.ResultIndex = resultIndex + 1; 3941 3942 for (unsigned i = 0, e = semantics.size() + 1; i != e; ++i) { 3943 Expr *E = (i == 0 ? syntax : semantics[i-1]); 3944 getSubExprsBuffer()[i] = E; 3945 3946 if (E->isTypeDependent()) 3947 ExprBits.TypeDependent = true; 3948 if (E->isValueDependent()) 3949 ExprBits.ValueDependent = true; 3950 if (E->isInstantiationDependent()) 3951 ExprBits.InstantiationDependent = true; 3952 if (E->containsUnexpandedParameterPack()) 3953 ExprBits.ContainsUnexpandedParameterPack = true; 3954 3955 if (isa<OpaqueValueExpr>(E)) 3956 assert(cast<OpaqueValueExpr>(E)->getSourceExpr() != 0 && 3957 "opaque-value semantic expressions for pseudo-object " 3958 "operations must have sources"); 3959 } 3960} 3961 3962//===----------------------------------------------------------------------===// 3963// ExprIterator. 3964//===----------------------------------------------------------------------===// 3965 3966Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 3967Expr* ExprIterator::operator*() const { return cast<Expr>(*I); } 3968Expr* ExprIterator::operator->() const { return cast<Expr>(*I); } 3969const Expr* ConstExprIterator::operator[](size_t idx) const { 3970 return cast<Expr>(I[idx]); 3971} 3972const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 3973const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 3974 3975//===----------------------------------------------------------------------===// 3976// Child Iterators for iterating over subexpressions/substatements 3977//===----------------------------------------------------------------------===// 3978 3979// UnaryExprOrTypeTraitExpr 3980Stmt::child_range UnaryExprOrTypeTraitExpr::children() { 3981 // If this is of a type and the type is a VLA type (and not a typedef), the 3982 // size expression of the VLA needs to be treated as an executable expression. 3983 // Why isn't this weirdness documented better in StmtIterator? 3984 if (isArgumentType()) { 3985 if (const VariableArrayType* T = dyn_cast<VariableArrayType>( 3986 getArgumentType().getTypePtr())) 3987 return child_range(child_iterator(T), child_iterator()); 3988 return child_range(); 3989 } 3990 return child_range(&Argument.Ex, &Argument.Ex + 1); 3991} 3992 3993// ObjCMessageExpr 3994Stmt::child_range ObjCMessageExpr::children() { 3995 Stmt **begin; 3996 if (getReceiverKind() == Instance) 3997 begin = reinterpret_cast<Stmt **>(this + 1); 3998 else 3999 begin = reinterpret_cast<Stmt **>(getArgs()); 4000 return child_range(begin, 4001 reinterpret_cast<Stmt **>(getArgs() + getNumArgs())); 4002} 4003 4004ObjCArrayLiteral::ObjCArrayLiteral(ArrayRef<Expr *> Elements, 4005 QualType T, ObjCMethodDecl *Method, 4006 SourceRange SR) 4007 : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary, 4008 false, false, false, false), 4009 NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method) 4010{ 4011 Expr **SaveElements = getElements(); 4012 for (unsigned I = 0, N = Elements.size(); I != N; ++I) { 4013 if (Elements[I]->isTypeDependent() || Elements[I]->isValueDependent()) 4014 ExprBits.ValueDependent = true; 4015 if (Elements[I]->isInstantiationDependent()) 4016 ExprBits.InstantiationDependent = true; 4017 if (Elements[I]->containsUnexpandedParameterPack()) 4018 ExprBits.ContainsUnexpandedParameterPack = true; 4019 4020 SaveElements[I] = Elements[I]; 4021 } 4022} 4023 4024ObjCArrayLiteral *ObjCArrayLiteral::Create(const ASTContext &C, 4025 ArrayRef<Expr *> Elements, 4026 QualType T, ObjCMethodDecl * Method, 4027 SourceRange SR) { 4028 void *Mem = C.Allocate(sizeof(ObjCArrayLiteral) 4029 + Elements.size() * sizeof(Expr *)); 4030 return new (Mem) ObjCArrayLiteral(Elements, T, Method, SR); 4031} 4032 4033ObjCArrayLiteral *ObjCArrayLiteral::CreateEmpty(const ASTContext &C, 4034 unsigned NumElements) { 4035 4036 void *Mem = C.Allocate(sizeof(ObjCArrayLiteral) 4037 + NumElements * sizeof(Expr *)); 4038 return new (Mem) ObjCArrayLiteral(EmptyShell(), NumElements); 4039} 4040 4041ObjCDictionaryLiteral::ObjCDictionaryLiteral( 4042 ArrayRef<ObjCDictionaryElement> VK, 4043 bool HasPackExpansions, 4044 QualType T, ObjCMethodDecl *method, 4045 SourceRange SR) 4046 : Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary, false, false, 4047 false, false), 4048 NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR), 4049 DictWithObjectsMethod(method) 4050{ 4051 KeyValuePair *KeyValues = getKeyValues(); 4052 ExpansionData *Expansions = getExpansionData(); 4053 for (unsigned I = 0; I < NumElements; I++) { 4054 if (VK[I].Key->isTypeDependent() || VK[I].Key->isValueDependent() || 4055 VK[I].Value->isTypeDependent() || VK[I].Value->isValueDependent()) 4056 ExprBits.ValueDependent = true; 4057 if (VK[I].Key->isInstantiationDependent() || 4058 VK[I].Value->isInstantiationDependent()) 4059 ExprBits.InstantiationDependent = true; 4060 if (VK[I].EllipsisLoc.isInvalid() && 4061 (VK[I].Key->containsUnexpandedParameterPack() || 4062 VK[I].Value->containsUnexpandedParameterPack())) 4063 ExprBits.ContainsUnexpandedParameterPack = true; 4064 4065 KeyValues[I].Key = VK[I].Key; 4066 KeyValues[I].Value = VK[I].Value; 4067 if (Expansions) { 4068 Expansions[I].EllipsisLoc = VK[I].EllipsisLoc; 4069 if (VK[I].NumExpansions) 4070 Expansions[I].NumExpansionsPlusOne = *VK[I].NumExpansions + 1; 4071 else 4072 Expansions[I].NumExpansionsPlusOne = 0; 4073 } 4074 } 4075} 4076 4077ObjCDictionaryLiteral * 4078ObjCDictionaryLiteral::Create(const ASTContext &C, 4079 ArrayRef<ObjCDictionaryElement> VK, 4080 bool HasPackExpansions, 4081 QualType T, ObjCMethodDecl *method, 4082 SourceRange SR) { 4083 unsigned ExpansionsSize = 0; 4084 if (HasPackExpansions) 4085 ExpansionsSize = sizeof(ExpansionData) * VK.size(); 4086 4087 void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) + 4088 sizeof(KeyValuePair) * VK.size() + ExpansionsSize); 4089 return new (Mem) ObjCDictionaryLiteral(VK, HasPackExpansions, T, method, SR); 4090} 4091 4092ObjCDictionaryLiteral * 4093ObjCDictionaryLiteral::CreateEmpty(const ASTContext &C, unsigned NumElements, 4094 bool HasPackExpansions) { 4095 unsigned ExpansionsSize = 0; 4096 if (HasPackExpansions) 4097 ExpansionsSize = sizeof(ExpansionData) * NumElements; 4098 void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) + 4099 sizeof(KeyValuePair) * NumElements + ExpansionsSize); 4100 return new (Mem) ObjCDictionaryLiteral(EmptyShell(), NumElements, 4101 HasPackExpansions); 4102} 4103 4104ObjCSubscriptRefExpr *ObjCSubscriptRefExpr::Create(const ASTContext &C, 4105 Expr *base, 4106 Expr *key, QualType T, 4107 ObjCMethodDecl *getMethod, 4108 ObjCMethodDecl *setMethod, 4109 SourceLocation RB) { 4110 void *Mem = C.Allocate(sizeof(ObjCSubscriptRefExpr)); 4111 return new (Mem) ObjCSubscriptRefExpr(base, key, T, VK_LValue, 4112 OK_ObjCSubscript, 4113 getMethod, setMethod, RB); 4114} 4115 4116AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args, 4117 QualType t, AtomicOp op, SourceLocation RP) 4118 : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary, 4119 false, false, false, false), 4120 NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) 4121{ 4122 assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions"); 4123 for (unsigned i = 0; i != args.size(); i++) { 4124 if (args[i]->isTypeDependent()) 4125 ExprBits.TypeDependent = true; 4126 if (args[i]->isValueDependent()) 4127 ExprBits.ValueDependent = true; 4128 if (args[i]->isInstantiationDependent()) 4129 ExprBits.InstantiationDependent = true; 4130 if (args[i]->containsUnexpandedParameterPack()) 4131 ExprBits.ContainsUnexpandedParameterPack = true; 4132 4133 SubExprs[i] = args[i]; 4134 } 4135} 4136 4137unsigned AtomicExpr::getNumSubExprs(AtomicOp Op) { 4138 switch (Op) { 4139 case AO__c11_atomic_init: 4140 case AO__c11_atomic_load: 4141 case AO__atomic_load_n: 4142 return 2; 4143 4144 case AO__c11_atomic_store: 4145 case AO__c11_atomic_exchange: 4146 case AO__atomic_load: 4147 case AO__atomic_store: 4148 case AO__atomic_store_n: 4149 case AO__atomic_exchange_n: 4150 case AO__c11_atomic_fetch_add: 4151 case AO__c11_atomic_fetch_sub: 4152 case AO__c11_atomic_fetch_and: 4153 case AO__c11_atomic_fetch_or: 4154 case AO__c11_atomic_fetch_xor: 4155 case AO__atomic_fetch_add: 4156 case AO__atomic_fetch_sub: 4157 case AO__atomic_fetch_and: 4158 case AO__atomic_fetch_or: 4159 case AO__atomic_fetch_xor: 4160 case AO__atomic_fetch_nand: 4161 case AO__atomic_add_fetch: 4162 case AO__atomic_sub_fetch: 4163 case AO__atomic_and_fetch: 4164 case AO__atomic_or_fetch: 4165 case AO__atomic_xor_fetch: 4166 case AO__atomic_nand_fetch: 4167 return 3; 4168 4169 case AO__atomic_exchange: 4170 return 4; 4171 4172 case AO__c11_atomic_compare_exchange_strong: 4173 case AO__c11_atomic_compare_exchange_weak: 4174 return 5; 4175 4176 case AO__atomic_compare_exchange: 4177 case AO__atomic_compare_exchange_n: 4178 return 6; 4179 } 4180 llvm_unreachable("unknown atomic op"); 4181} 4182