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