1193326Sed//===--- Expr.cpp - Expression AST Node Implementation --------------------===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This file implements the Expr class and subclasses. 11193326Sed// 12193326Sed//===----------------------------------------------------------------------===// 13193326Sed 14193326Sed#include "clang/AST/APValue.h" 15193326Sed#include "clang/AST/ASTContext.h" 16249423Sdim#include "clang/AST/Attr.h" 17249423Sdim#include "clang/AST/DeclCXX.h" 18193326Sed#include "clang/AST/DeclObjC.h" 19193326Sed#include "clang/AST/DeclTemplate.h" 20234353Sdim#include "clang/AST/EvaluatedExprVisitor.h" 21249423Sdim#include "clang/AST/Expr.h" 22249423Sdim#include "clang/AST/ExprCXX.h" 23263508Sdim#include "clang/AST/Mangle.h" 24193326Sed#include "clang/AST/RecordLayout.h" 25193326Sed#include "clang/AST/StmtVisitor.h" 26194179Sed#include "clang/Basic/Builtins.h" 27249423Sdim#include "clang/Basic/CharInfo.h" 28218893Sdim#include "clang/Basic/SourceManager.h" 29193326Sed#include "clang/Basic/TargetInfo.h" 30249423Sdim#include "clang/Lex/Lexer.h" 31249423Sdim#include "clang/Lex/LiteralSupport.h" 32249423Sdim#include "clang/Sema/SemaDiagnostic.h" 33198893Srdivacky#include "llvm/Support/ErrorHandling.h" 34198092Srdivacky#include "llvm/Support/raw_ostream.h" 35193326Sed#include <algorithm> 36234353Sdim#include <cstring> 37193326Sedusing namespace clang; 38193326Sed 39239462Sdimconst CXXRecordDecl *Expr::getBestDynamicClassType() const { 40239462Sdim const Expr *E = ignoreParenBaseCasts(); 41239462Sdim 42239462Sdim QualType DerivedType = E->getType(); 43239462Sdim if (const PointerType *PTy = DerivedType->getAs<PointerType>()) 44239462Sdim DerivedType = PTy->getPointeeType(); 45239462Sdim 46239462Sdim if (DerivedType->isDependentType()) 47239462Sdim return NULL; 48239462Sdim 49239462Sdim const RecordType *Ty = DerivedType->castAs<RecordType>(); 50239462Sdim Decl *D = Ty->getDecl(); 51239462Sdim return cast<CXXRecordDecl>(D); 52239462Sdim} 53239462Sdim 54263508Sdimconst Expr *Expr::skipRValueSubobjectAdjustments( 55263508Sdim SmallVectorImpl<const Expr *> &CommaLHSs, 56263508Sdim SmallVectorImpl<SubobjectAdjustment> &Adjustments) const { 57243830Sdim const Expr *E = this; 58243830Sdim while (true) { 59243830Sdim E = E->IgnoreParens(); 60243830Sdim 61243830Sdim if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { 62243830Sdim if ((CE->getCastKind() == CK_DerivedToBase || 63243830Sdim CE->getCastKind() == CK_UncheckedDerivedToBase) && 64243830Sdim E->getType()->isRecordType()) { 65243830Sdim E = CE->getSubExpr(); 66243830Sdim CXXRecordDecl *Derived 67243830Sdim = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl()); 68243830Sdim Adjustments.push_back(SubobjectAdjustment(CE, Derived)); 69243830Sdim continue; 70243830Sdim } 71243830Sdim 72243830Sdim if (CE->getCastKind() == CK_NoOp) { 73243830Sdim E = CE->getSubExpr(); 74243830Sdim continue; 75243830Sdim } 76243830Sdim } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 77263508Sdim if (!ME->isArrow()) { 78243830Sdim assert(ME->getBase()->getType()->isRecordType()); 79243830Sdim if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) { 80263508Sdim if (!Field->isBitField() && !Field->getType()->isReferenceType()) { 81263508Sdim E = ME->getBase(); 82263508Sdim Adjustments.push_back(SubobjectAdjustment(Field)); 83263508Sdim continue; 84263508Sdim } 85243830Sdim } 86243830Sdim } 87243830Sdim } else if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 88243830Sdim if (BO->isPtrMemOp()) { 89243830Sdim assert(BO->getRHS()->isRValue()); 90243830Sdim E = BO->getLHS(); 91243830Sdim const MemberPointerType *MPT = 92243830Sdim BO->getRHS()->getType()->getAs<MemberPointerType>(); 93243830Sdim Adjustments.push_back(SubobjectAdjustment(MPT, BO->getRHS())); 94263508Sdim continue; 95263508Sdim } else if (BO->getOpcode() == BO_Comma) { 96263508Sdim CommaLHSs.push_back(BO->getLHS()); 97263508Sdim E = BO->getRHS(); 98263508Sdim continue; 99243830Sdim } 100243830Sdim } 101243830Sdim 102243830Sdim // Nothing changed. 103243830Sdim break; 104243830Sdim } 105243830Sdim return E; 106243830Sdim} 107243830Sdim 108243830Sdimconst Expr * 109243830SdimExpr::findMaterializedTemporary(const MaterializeTemporaryExpr *&MTE) const { 110243830Sdim const Expr *E = this; 111251662Sdim 112251662Sdim // This might be a default initializer for a reference member. Walk over the 113251662Sdim // wrapper node for that. 114251662Sdim if (const CXXDefaultInitExpr *DAE = dyn_cast<CXXDefaultInitExpr>(E)) 115251662Sdim E = DAE->getExpr(); 116251662Sdim 117243830Sdim // Look through single-element init lists that claim to be lvalues. They're 118243830Sdim // just syntactic wrappers in this case. 119243830Sdim if (const InitListExpr *ILE = dyn_cast<InitListExpr>(E)) { 120251662Sdim if (ILE->getNumInits() == 1 && ILE->isGLValue()) { 121243830Sdim E = ILE->getInit(0); 122251662Sdim if (const CXXDefaultInitExpr *DAE = dyn_cast<CXXDefaultInitExpr>(E)) 123251662Sdim E = DAE->getExpr(); 124251662Sdim } 125243830Sdim } 126243830Sdim 127243830Sdim // Look through expressions for materialized temporaries (for now). 128243830Sdim if (const MaterializeTemporaryExpr *M 129243830Sdim = dyn_cast<MaterializeTemporaryExpr>(E)) { 130243830Sdim MTE = M; 131243830Sdim E = M->GetTemporaryExpr(); 132243830Sdim } 133243830Sdim 134243830Sdim if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E)) 135243830Sdim E = DAE->getExpr(); 136243830Sdim return E; 137243830Sdim} 138243830Sdim 139207619Srdivacky/// isKnownToHaveBooleanValue - Return true if this is an integer expression 140207619Srdivacky/// that is known to return 0 or 1. This happens for _Bool/bool expressions 141207619Srdivacky/// but also int expressions which are produced by things like comparisons in 142207619Srdivacky/// C. 143207619Srdivackybool Expr::isKnownToHaveBooleanValue() const { 144221345Sdim const Expr *E = IgnoreParens(); 145221345Sdim 146207619Srdivacky // If this value has _Bool type, it is obvious 0/1. 147221345Sdim if (E->getType()->isBooleanType()) return true; 148207619Srdivacky // If this is a non-scalar-integer type, we don't care enough to try. 149221345Sdim if (!E->getType()->isIntegralOrEnumerationType()) return false; 150207619Srdivacky 151221345Sdim if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { 152207619Srdivacky switch (UO->getOpcode()) { 153212904Sdim case UO_Plus: 154207619Srdivacky return UO->getSubExpr()->isKnownToHaveBooleanValue(); 155207619Srdivacky default: 156207619Srdivacky return false; 157207619Srdivacky } 158207619Srdivacky } 159207619Srdivacky 160210299Sed // Only look through implicit casts. If the user writes 161210299Sed // '(int) (a && b)' treat it as an arbitrary int. 162221345Sdim if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E)) 163207619Srdivacky return CE->getSubExpr()->isKnownToHaveBooleanValue(); 164207619Srdivacky 165221345Sdim if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 166207619Srdivacky switch (BO->getOpcode()) { 167207619Srdivacky default: return false; 168212904Sdim case BO_LT: // Relational operators. 169212904Sdim case BO_GT: 170212904Sdim case BO_LE: 171212904Sdim case BO_GE: 172212904Sdim case BO_EQ: // Equality operators. 173212904Sdim case BO_NE: 174212904Sdim case BO_LAnd: // AND operator. 175212904Sdim case BO_LOr: // Logical OR operator. 176207619Srdivacky return true; 177207619Srdivacky 178212904Sdim case BO_And: // Bitwise AND operator. 179212904Sdim case BO_Xor: // Bitwise XOR operator. 180212904Sdim case BO_Or: // Bitwise OR operator. 181207619Srdivacky // Handle things like (x==2)|(y==12). 182207619Srdivacky return BO->getLHS()->isKnownToHaveBooleanValue() && 183207619Srdivacky BO->getRHS()->isKnownToHaveBooleanValue(); 184207619Srdivacky 185212904Sdim case BO_Comma: 186212904Sdim case BO_Assign: 187207619Srdivacky return BO->getRHS()->isKnownToHaveBooleanValue(); 188207619Srdivacky } 189207619Srdivacky } 190207619Srdivacky 191221345Sdim if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) 192207619Srdivacky return CO->getTrueExpr()->isKnownToHaveBooleanValue() && 193207619Srdivacky CO->getFalseExpr()->isKnownToHaveBooleanValue(); 194207619Srdivacky 195207619Srdivacky return false; 196207619Srdivacky} 197207619Srdivacky 198218893Sdim// Amusing macro metaprogramming hack: check whether a class provides 199218893Sdim// a more specific implementation of getExprLoc(). 200234353Sdim// 201234353Sdim// See also Stmt.cpp:{getLocStart(),getLocEnd()}. 202218893Sdimnamespace { 203218893Sdim /// This implementation is used when a class provides a custom 204218893Sdim /// implementation of getExprLoc. 205218893Sdim template <class E, class T> 206218893Sdim SourceLocation getExprLocImpl(const Expr *expr, 207218893Sdim SourceLocation (T::*v)() const) { 208218893Sdim return static_cast<const E*>(expr)->getExprLoc(); 209218893Sdim } 210218893Sdim 211218893Sdim /// This implementation is used when a class doesn't provide 212218893Sdim /// a custom implementation of getExprLoc. Overload resolution 213218893Sdim /// should pick it over the implementation above because it's 214218893Sdim /// more specialized according to function template partial ordering. 215218893Sdim template <class E> 216218893Sdim SourceLocation getExprLocImpl(const Expr *expr, 217218893Sdim SourceLocation (Expr::*v)() const) { 218234353Sdim return static_cast<const E*>(expr)->getLocStart(); 219218893Sdim } 220218893Sdim} 221218893Sdim 222218893SdimSourceLocation Expr::getExprLoc() const { 223218893Sdim switch (getStmtClass()) { 224218893Sdim case Stmt::NoStmtClass: llvm_unreachable("statement without class"); 225218893Sdim#define ABSTRACT_STMT(type) 226218893Sdim#define STMT(type, base) \ 227218893Sdim case Stmt::type##Class: llvm_unreachable(#type " is not an Expr"); break; 228218893Sdim#define EXPR(type, base) \ 229218893Sdim case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc); 230218893Sdim#include "clang/AST/StmtNodes.inc" 231218893Sdim } 232218893Sdim llvm_unreachable("unknown statement kind"); 233218893Sdim} 234218893Sdim 235193326Sed//===----------------------------------------------------------------------===// 236193326Sed// Primary Expressions. 237193326Sed//===----------------------------------------------------------------------===// 238193326Sed 239224145Sdim/// \brief Compute the type-, value-, and instantiation-dependence of a 240224145Sdim/// declaration reference 241218893Sdim/// based on the declaration being referenced. 242263508Sdimstatic void computeDeclRefDependence(const ASTContext &Ctx, NamedDecl *D, 243263508Sdim QualType T, bool &TypeDependent, 244224145Sdim bool &ValueDependent, 245224145Sdim bool &InstantiationDependent) { 246199990Srdivacky TypeDependent = false; 247199990Srdivacky ValueDependent = false; 248224145Sdim InstantiationDependent = false; 249199990Srdivacky 250199990Srdivacky // (TD) C++ [temp.dep.expr]p3: 251199990Srdivacky // An id-expression is type-dependent if it contains: 252199990Srdivacky // 253199990Srdivacky // and 254199990Srdivacky // 255199990Srdivacky // (VD) C++ [temp.dep.constexpr]p2: 256199990Srdivacky // An identifier is value-dependent if it is: 257218893Sdim 258199990Srdivacky // (TD) - an identifier that was declared with dependent type 259199990Srdivacky // (VD) - a name declared with a dependent type, 260218893Sdim if (T->isDependentType()) { 261199990Srdivacky TypeDependent = true; 262199990Srdivacky ValueDependent = true; 263224145Sdim InstantiationDependent = true; 264218893Sdim return; 265224145Sdim } else if (T->isInstantiationDependentType()) { 266224145Sdim InstantiationDependent = true; 267199990Srdivacky } 268218893Sdim 269199990Srdivacky // (TD) - a conversion-function-id that specifies a dependent type 270218893Sdim if (D->getDeclName().getNameKind() 271224145Sdim == DeclarationName::CXXConversionFunctionName) { 272224145Sdim QualType T = D->getDeclName().getCXXNameType(); 273224145Sdim if (T->isDependentType()) { 274224145Sdim TypeDependent = true; 275224145Sdim ValueDependent = true; 276224145Sdim InstantiationDependent = true; 277224145Sdim return; 278224145Sdim } 279224145Sdim 280224145Sdim if (T->isInstantiationDependentType()) 281224145Sdim InstantiationDependent = true; 282199990Srdivacky } 283224145Sdim 284218893Sdim // (VD) - the name of a non-type template parameter, 285218893Sdim if (isa<NonTypeTemplateParmDecl>(D)) { 286199990Srdivacky ValueDependent = true; 287224145Sdim InstantiationDependent = true; 288218893Sdim return; 289199990Srdivacky } 290218893Sdim 291199990Srdivacky // (VD) - a constant with integral or enumeration type and is 292199990Srdivacky // initialized with an expression that is value-dependent. 293234353Sdim // (VD) - a constant with literal type and is initialized with an 294234353Sdim // expression that is value-dependent [C++11]. 295234353Sdim // (VD) - FIXME: Missing from the standard: 296234353Sdim // - an entity with reference type and is initialized with an 297234353Sdim // expression that is value-dependent [C++11] 298218893Sdim if (VarDecl *Var = dyn_cast<VarDecl>(D)) { 299249423Sdim if ((Ctx.getLangOpts().CPlusPlus11 ? 300251662Sdim Var->getType()->isLiteralType(Ctx) : 301234353Sdim Var->getType()->isIntegralOrEnumerationType()) && 302239462Sdim (Var->getType().isConstQualified() || 303234353Sdim Var->getType()->isReferenceType())) { 304203955Srdivacky if (const Expr *Init = Var->getAnyInitializer()) 305224145Sdim if (Init->isValueDependent()) { 306202879Srdivacky ValueDependent = true; 307224145Sdim InstantiationDependent = true; 308224145Sdim } 309234353Sdim } 310234353Sdim 311208600Srdivacky // (VD) - FIXME: Missing from the standard: 312208600Srdivacky // - a member function or a static data member of the current 313208600Srdivacky // instantiation 314234353Sdim if (Var->isStaticDataMember() && 315234353Sdim Var->getDeclContext()->isDependentContext()) { 316208600Srdivacky ValueDependent = true; 317224145Sdim InstantiationDependent = true; 318263508Sdim TypeSourceInfo *TInfo = Var->getFirstDecl()->getTypeSourceInfo(); 319263508Sdim if (TInfo->getType()->isIncompleteArrayType()) 320263508Sdim TypeDependent = true; 321224145Sdim } 322218893Sdim 323218893Sdim return; 324218893Sdim } 325218893Sdim 326208600Srdivacky // (VD) - FIXME: Missing from the standard: 327208600Srdivacky // - a member function or a static data member of the current 328208600Srdivacky // instantiation 329218893Sdim if (isa<CXXMethodDecl>(D) && D->getDeclContext()->isDependentContext()) { 330208600Srdivacky ValueDependent = true; 331224145Sdim InstantiationDependent = true; 332234353Sdim } 333199990Srdivacky} 334199990Srdivacky 335263508Sdimvoid DeclRefExpr::computeDependence(const ASTContext &Ctx) { 336218893Sdim bool TypeDependent = false; 337218893Sdim bool ValueDependent = false; 338224145Sdim bool InstantiationDependent = false; 339234353Sdim computeDeclRefDependence(Ctx, getDecl(), getType(), TypeDependent, 340234353Sdim ValueDependent, InstantiationDependent); 341218893Sdim 342218893Sdim // (TD) C++ [temp.dep.expr]p3: 343218893Sdim // An id-expression is type-dependent if it contains: 344218893Sdim // 345218893Sdim // and 346218893Sdim // 347218893Sdim // (VD) C++ [temp.dep.constexpr]p2: 348218893Sdim // An identifier is value-dependent if it is: 349218893Sdim if (!TypeDependent && !ValueDependent && 350218893Sdim hasExplicitTemplateArgs() && 351218893Sdim TemplateSpecializationType::anyDependentTemplateArguments( 352218893Sdim getTemplateArgs(), 353224145Sdim getNumTemplateArgs(), 354224145Sdim InstantiationDependent)) { 355218893Sdim TypeDependent = true; 356218893Sdim ValueDependent = true; 357224145Sdim InstantiationDependent = true; 358218893Sdim } 359218893Sdim 360218893Sdim ExprBits.TypeDependent = TypeDependent; 361218893Sdim ExprBits.ValueDependent = ValueDependent; 362224145Sdim ExprBits.InstantiationDependent = InstantiationDependent; 363218893Sdim 364218893Sdim // Is the declaration a parameter pack? 365218893Sdim if (getDecl()->isParameterPack()) 366218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 367218893Sdim} 368218893Sdim 369263508SdimDeclRefExpr::DeclRefExpr(const ASTContext &Ctx, 370234353Sdim NestedNameSpecifierLoc QualifierLoc, 371234353Sdim SourceLocation TemplateKWLoc, 372234353Sdim ValueDecl *D, bool RefersToEnclosingLocal, 373234353Sdim const DeclarationNameInfo &NameInfo, 374221345Sdim NamedDecl *FoundD, 375212904Sdim const TemplateArgumentListInfo *TemplateArgs, 376218893Sdim QualType T, ExprValueKind VK) 377224145Sdim : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false), 378221345Sdim D(D), Loc(NameInfo.getLoc()), DNLoc(NameInfo.getInfo()) { 379221345Sdim DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0; 380221345Sdim if (QualifierLoc) 381221345Sdim getInternalQualifierLoc() = QualifierLoc; 382221345Sdim DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0; 383221345Sdim if (FoundD) 384221345Sdim getInternalFoundDecl() = FoundD; 385234353Sdim DeclRefExprBits.HasTemplateKWAndArgsInfo 386234353Sdim = (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0; 387234353Sdim DeclRefExprBits.RefersToEnclosingLocal = RefersToEnclosingLocal; 388224145Sdim if (TemplateArgs) { 389224145Sdim bool Dependent = false; 390224145Sdim bool InstantiationDependent = false; 391224145Sdim bool ContainsUnexpandedParameterPack = false; 392234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs, 393234353Sdim Dependent, 394234353Sdim InstantiationDependent, 395234353Sdim ContainsUnexpandedParameterPack); 396224145Sdim if (InstantiationDependent) 397224145Sdim setInstantiationDependent(true); 398234353Sdim } else if (TemplateKWLoc.isValid()) { 399234353Sdim getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 400224145Sdim } 401226633Sdim DeclRefExprBits.HadMultipleCandidates = 0; 402226633Sdim 403234353Sdim computeDependence(Ctx); 404212904Sdim} 405212904Sdim 406263508SdimDeclRefExpr *DeclRefExpr::Create(const ASTContext &Context, 407221345Sdim NestedNameSpecifierLoc QualifierLoc, 408234353Sdim SourceLocation TemplateKWLoc, 409200583Srdivacky ValueDecl *D, 410234353Sdim bool RefersToEnclosingLocal, 411198893Srdivacky SourceLocation NameLoc, 412199990Srdivacky QualType T, 413218893Sdim ExprValueKind VK, 414221345Sdim NamedDecl *FoundD, 415199990Srdivacky const TemplateArgumentListInfo *TemplateArgs) { 416234353Sdim return Create(Context, QualifierLoc, TemplateKWLoc, D, 417234353Sdim RefersToEnclosingLocal, 418212904Sdim DeclarationNameInfo(D->getDeclName(), NameLoc), 419221345Sdim T, VK, FoundD, TemplateArgs); 420212904Sdim} 421212904Sdim 422263508SdimDeclRefExpr *DeclRefExpr::Create(const ASTContext &Context, 423221345Sdim NestedNameSpecifierLoc QualifierLoc, 424234353Sdim SourceLocation TemplateKWLoc, 425212904Sdim ValueDecl *D, 426234353Sdim bool RefersToEnclosingLocal, 427212904Sdim const DeclarationNameInfo &NameInfo, 428212904Sdim QualType T, 429218893Sdim ExprValueKind VK, 430221345Sdim NamedDecl *FoundD, 431212904Sdim const TemplateArgumentListInfo *TemplateArgs) { 432221345Sdim // Filter out cases where the found Decl is the same as the value refenenced. 433221345Sdim if (D == FoundD) 434221345Sdim FoundD = 0; 435221345Sdim 436198893Srdivacky std::size_t Size = sizeof(DeclRefExpr); 437263508Sdim if (QualifierLoc) 438221345Sdim Size += sizeof(NestedNameSpecifierLoc); 439221345Sdim if (FoundD) 440221345Sdim Size += sizeof(NamedDecl *); 441199990Srdivacky if (TemplateArgs) 442234353Sdim Size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size()); 443234353Sdim else if (TemplateKWLoc.isValid()) 444234353Sdim Size += ASTTemplateKWAndArgsInfo::sizeFor(0); 445221345Sdim 446218893Sdim void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>()); 447234353Sdim return new (Mem) DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D, 448234353Sdim RefersToEnclosingLocal, 449234353Sdim NameInfo, FoundD, TemplateArgs, T, VK); 450198893Srdivacky} 451198893Srdivacky 452263508SdimDeclRefExpr *DeclRefExpr::CreateEmpty(const ASTContext &Context, 453218893Sdim bool HasQualifier, 454221345Sdim bool HasFoundDecl, 455234353Sdim bool HasTemplateKWAndArgsInfo, 456210299Sed unsigned NumTemplateArgs) { 457210299Sed std::size_t Size = sizeof(DeclRefExpr); 458210299Sed if (HasQualifier) 459221345Sdim Size += sizeof(NestedNameSpecifierLoc); 460221345Sdim if (HasFoundDecl) 461221345Sdim Size += sizeof(NamedDecl *); 462234353Sdim if (HasTemplateKWAndArgsInfo) 463234353Sdim Size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs); 464221345Sdim 465218893Sdim void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>()); 466210299Sed return new (Mem) DeclRefExpr(EmptyShell()); 467210299Sed} 468210299Sed 469234353SdimSourceLocation DeclRefExpr::getLocStart() const { 470234353Sdim if (hasQualifier()) 471234353Sdim return getQualifierLoc().getBeginLoc(); 472234353Sdim return getNameInfo().getLocStart(); 473234353Sdim} 474234353SdimSourceLocation DeclRefExpr::getLocEnd() const { 475234353Sdim if (hasExplicitTemplateArgs()) 476234353Sdim return getRAngleLoc(); 477234353Sdim return getNameInfo().getLocEnd(); 478234353Sdim} 479198893Srdivacky 480198092Srdivacky// FIXME: Maybe this should use DeclPrinter with a special "print predefined 481198092Srdivacky// expr" policy instead. 482203955Srdivackystd::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) { 483203955Srdivacky ASTContext &Context = CurrentDecl->getASTContext(); 484203955Srdivacky 485263508Sdim if (IT == PredefinedExpr::FuncDName) { 486263508Sdim if (const NamedDecl *ND = dyn_cast<NamedDecl>(CurrentDecl)) { 487263508Sdim OwningPtr<MangleContext> MC; 488263508Sdim MC.reset(Context.createMangleContext()); 489263508Sdim 490263508Sdim if (MC->shouldMangleDeclName(ND)) { 491263508Sdim SmallString<256> Buffer; 492263508Sdim llvm::raw_svector_ostream Out(Buffer); 493263508Sdim if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(ND)) 494263508Sdim MC->mangleCXXCtor(CD, Ctor_Base, Out); 495263508Sdim else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(ND)) 496263508Sdim MC->mangleCXXDtor(DD, Dtor_Base, Out); 497263508Sdim else 498263508Sdim MC->mangleName(ND, Out); 499263508Sdim 500263508Sdim Out.flush(); 501263508Sdim if (!Buffer.empty() && Buffer.front() == '\01') 502263508Sdim return Buffer.substr(1); 503263508Sdim return Buffer.str(); 504263508Sdim } else 505263508Sdim return ND->getIdentifier()->getName(); 506263508Sdim } 507263508Sdim return ""; 508263508Sdim } 509198092Srdivacky if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) { 510203955Srdivacky if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual) 511198092Srdivacky return FD->getNameAsString(); 512193326Sed 513234353Sdim SmallString<256> Name; 514198092Srdivacky llvm::raw_svector_ostream Out(Name); 515193326Sed 516198092Srdivacky if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 517203955Srdivacky if (MD->isVirtual() && IT != PrettyFunctionNoVirtual) 518198092Srdivacky Out << "virtual "; 519201361Srdivacky if (MD->isStatic()) 520201361Srdivacky Out << "static "; 521198092Srdivacky } 522193326Sed 523234353Sdim PrintingPolicy Policy(Context.getLangOpts()); 524249423Sdim std::string Proto; 525234353Sdim llvm::raw_string_ostream POut(Proto); 526249423Sdim FD->printQualifiedName(POut, Policy); 527193326Sed 528234353Sdim const FunctionDecl *Decl = FD; 529234353Sdim if (const FunctionDecl* Pattern = FD->getTemplateInstantiationPattern()) 530234353Sdim Decl = Pattern; 531234353Sdim const FunctionType *AFT = Decl->getType()->getAs<FunctionType>(); 532198092Srdivacky const FunctionProtoType *FT = 0; 533198092Srdivacky if (FD->hasWrittenPrototype()) 534198092Srdivacky FT = dyn_cast<FunctionProtoType>(AFT); 535198092Srdivacky 536234353Sdim POut << "("; 537198092Srdivacky if (FT) { 538234353Sdim for (unsigned i = 0, e = Decl->getNumParams(); i != e; ++i) { 539198092Srdivacky if (i) POut << ", "; 540239462Sdim POut << Decl->getParamDecl(i)->getType().stream(Policy); 541198092Srdivacky } 542198092Srdivacky 543198092Srdivacky if (FT->isVariadic()) { 544198092Srdivacky if (FD->getNumParams()) POut << ", "; 545198092Srdivacky POut << "..."; 546198092Srdivacky } 547198092Srdivacky } 548234353Sdim POut << ")"; 549198092Srdivacky 550201361Srdivacky if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 551249423Sdim const FunctionType *FT = MD->getType()->castAs<FunctionType>(); 552239462Sdim if (FT->isConst()) 553234353Sdim POut << " const"; 554239462Sdim if (FT->isVolatile()) 555234353Sdim POut << " volatile"; 556234353Sdim RefQualifierKind Ref = MD->getRefQualifier(); 557234353Sdim if (Ref == RQ_LValue) 558234353Sdim POut << " &"; 559234353Sdim else if (Ref == RQ_RValue) 560234353Sdim POut << " &&"; 561201361Srdivacky } 562201361Srdivacky 563234353Sdim typedef SmallVector<const ClassTemplateSpecializationDecl *, 8> SpecsTy; 564234353Sdim SpecsTy Specs; 565234353Sdim const DeclContext *Ctx = FD->getDeclContext(); 566234353Sdim while (Ctx && isa<NamedDecl>(Ctx)) { 567234353Sdim const ClassTemplateSpecializationDecl *Spec 568234353Sdim = dyn_cast<ClassTemplateSpecializationDecl>(Ctx); 569234353Sdim if (Spec && !Spec->isExplicitSpecialization()) 570234353Sdim Specs.push_back(Spec); 571234353Sdim Ctx = Ctx->getParent(); 572234353Sdim } 573234353Sdim 574234353Sdim std::string TemplateParams; 575234353Sdim llvm::raw_string_ostream TOut(TemplateParams); 576234353Sdim for (SpecsTy::reverse_iterator I = Specs.rbegin(), E = Specs.rend(); 577234353Sdim I != E; ++I) { 578234353Sdim const TemplateParameterList *Params 579234353Sdim = (*I)->getSpecializedTemplate()->getTemplateParameters(); 580234353Sdim const TemplateArgumentList &Args = (*I)->getTemplateArgs(); 581234353Sdim assert(Params->size() == Args.size()); 582234353Sdim for (unsigned i = 0, numParams = Params->size(); i != numParams; ++i) { 583234353Sdim StringRef Param = Params->getParam(i)->getName(); 584234353Sdim if (Param.empty()) continue; 585234353Sdim TOut << Param << " = "; 586234353Sdim Args.get(i).print(Policy, TOut); 587234353Sdim TOut << ", "; 588234353Sdim } 589234353Sdim } 590234353Sdim 591234353Sdim FunctionTemplateSpecializationInfo *FSI 592234353Sdim = FD->getTemplateSpecializationInfo(); 593234353Sdim if (FSI && !FSI->isExplicitSpecialization()) { 594234353Sdim const TemplateParameterList* Params 595234353Sdim = FSI->getTemplate()->getTemplateParameters(); 596234353Sdim const TemplateArgumentList* Args = FSI->TemplateArguments; 597234353Sdim assert(Params->size() == Args->size()); 598234353Sdim for (unsigned i = 0, e = Params->size(); i != e; ++i) { 599234353Sdim StringRef Param = Params->getParam(i)->getName(); 600234353Sdim if (Param.empty()) continue; 601234353Sdim TOut << Param << " = "; 602234353Sdim Args->get(i).print(Policy, TOut); 603234353Sdim TOut << ", "; 604234353Sdim } 605234353Sdim } 606234353Sdim 607234353Sdim TOut.flush(); 608234353Sdim if (!TemplateParams.empty()) { 609234353Sdim // remove the trailing comma and space 610234353Sdim TemplateParams.resize(TemplateParams.size() - 2); 611234353Sdim POut << " [" << TemplateParams << "]"; 612234353Sdim } 613234353Sdim 614234353Sdim POut.flush(); 615234353Sdim 616263508Sdim // Print "auto" for all deduced return types. This includes C++1y return 617263508Sdim // type deduction and lambdas. For trailing return types resolve the 618263508Sdim // decltype expression. Otherwise print the real type when this is 619263508Sdim // not a constructor or destructor. 620263508Sdim if ((isa<CXXMethodDecl>(FD) && 621263508Sdim cast<CXXMethodDecl>(FD)->getParent()->isLambda()) || 622263508Sdim (FT && FT->getResultType()->getAs<AutoType>())) 623263508Sdim Proto = "auto " + Proto; 624263508Sdim else if (FT && FT->getResultType()->getAs<DecltypeType>()) 625263508Sdim FT->getResultType()->getAs<DecltypeType>()->getUnderlyingType() 626263508Sdim .getAsStringInternal(Proto, Policy); 627263508Sdim else if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD)) 628200583Srdivacky AFT->getResultType().getAsStringInternal(Proto, Policy); 629198092Srdivacky 630198092Srdivacky Out << Proto; 631198092Srdivacky 632198092Srdivacky Out.flush(); 633198092Srdivacky return Name.str().str(); 634198092Srdivacky } 635263508Sdim if (const CapturedDecl *CD = dyn_cast<CapturedDecl>(CurrentDecl)) { 636263508Sdim for (const DeclContext *DC = CD->getParent(); DC; DC = DC->getParent()) 637263508Sdim // Skip to its enclosing function or method, but not its enclosing 638263508Sdim // CapturedDecl. 639263508Sdim if (DC->isFunctionOrMethod() && (DC->getDeclKind() != Decl::Captured)) { 640263508Sdim const Decl *D = Decl::castFromDeclContext(DC); 641263508Sdim return ComputeName(IT, D); 642263508Sdim } 643263508Sdim llvm_unreachable("CapturedDecl not inside a function or method"); 644263508Sdim } 645198092Srdivacky if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) { 646234353Sdim SmallString<256> Name; 647198092Srdivacky llvm::raw_svector_ostream Out(Name); 648198092Srdivacky Out << (MD->isInstanceMethod() ? '-' : '+'); 649198092Srdivacky Out << '['; 650205408Srdivacky 651205408Srdivacky // For incorrect code, there might not be an ObjCInterfaceDecl. Do 652205408Srdivacky // a null check to avoid a crash. 653205408Srdivacky if (const ObjCInterfaceDecl *ID = MD->getClassInterface()) 654226633Sdim Out << *ID; 655205408Srdivacky 656198092Srdivacky if (const ObjCCategoryImplDecl *CID = 657207619Srdivacky dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext())) 658234353Sdim Out << '(' << *CID << ')'; 659207619Srdivacky 660198092Srdivacky Out << ' '; 661198092Srdivacky Out << MD->getSelector().getAsString(); 662198092Srdivacky Out << ']'; 663198092Srdivacky 664198092Srdivacky Out.flush(); 665198092Srdivacky return Name.str().str(); 666198092Srdivacky } 667198092Srdivacky if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) { 668198092Srdivacky // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string. 669198092Srdivacky return "top level"; 670198092Srdivacky } 671198092Srdivacky return ""; 672193326Sed} 673193326Sed 674263508Sdimvoid APNumericStorage::setIntValue(const ASTContext &C, 675263508Sdim const llvm::APInt &Val) { 676212904Sdim if (hasAllocation()) 677212904Sdim C.Deallocate(pVal); 678212904Sdim 679212904Sdim BitWidth = Val.getBitWidth(); 680212904Sdim unsigned NumWords = Val.getNumWords(); 681212904Sdim const uint64_t* Words = Val.getRawData(); 682212904Sdim if (NumWords > 1) { 683212904Sdim pVal = new (C) uint64_t[NumWords]; 684212904Sdim std::copy(Words, Words + NumWords, pVal); 685212904Sdim } else if (NumWords == 1) 686212904Sdim VAL = Words[0]; 687212904Sdim else 688212904Sdim VAL = 0; 689212904Sdim} 690212904Sdim 691263508SdimIntegerLiteral::IntegerLiteral(const ASTContext &C, const llvm::APInt &V, 692239462Sdim QualType type, SourceLocation l) 693239462Sdim : Expr(IntegerLiteralClass, type, VK_RValue, OK_Ordinary, false, false, 694239462Sdim false, false), 695239462Sdim Loc(l) { 696239462Sdim assert(type->isIntegerType() && "Illegal type in IntegerLiteral"); 697239462Sdim assert(V.getBitWidth() == C.getIntWidth(type) && 698239462Sdim "Integer type is not the correct size for constant."); 699239462Sdim setValue(C, V); 700239462Sdim} 701239462Sdim 702212904SdimIntegerLiteral * 703263508SdimIntegerLiteral::Create(const ASTContext &C, const llvm::APInt &V, 704212904Sdim QualType type, SourceLocation l) { 705212904Sdim return new (C) IntegerLiteral(C, V, type, l); 706212904Sdim} 707212904Sdim 708212904SdimIntegerLiteral * 709263508SdimIntegerLiteral::Create(const ASTContext &C, EmptyShell Empty) { 710212904Sdim return new (C) IntegerLiteral(Empty); 711212904Sdim} 712212904Sdim 713263508SdimFloatingLiteral::FloatingLiteral(const ASTContext &C, const llvm::APFloat &V, 714239462Sdim bool isexact, QualType Type, SourceLocation L) 715239462Sdim : Expr(FloatingLiteralClass, Type, VK_RValue, OK_Ordinary, false, false, 716239462Sdim false, false), Loc(L) { 717249423Sdim setSemantics(V.getSemantics()); 718239462Sdim FloatingLiteralBits.IsExact = isexact; 719239462Sdim setValue(C, V); 720239462Sdim} 721239462Sdim 722263508SdimFloatingLiteral::FloatingLiteral(const ASTContext &C, EmptyShell Empty) 723239462Sdim : Expr(FloatingLiteralClass, Empty) { 724249423Sdim setRawSemantics(IEEEhalf); 725239462Sdim FloatingLiteralBits.IsExact = false; 726239462Sdim} 727239462Sdim 728212904SdimFloatingLiteral * 729263508SdimFloatingLiteral::Create(const ASTContext &C, const llvm::APFloat &V, 730212904Sdim bool isexact, QualType Type, SourceLocation L) { 731212904Sdim return new (C) FloatingLiteral(C, V, isexact, Type, L); 732212904Sdim} 733212904Sdim 734212904SdimFloatingLiteral * 735263508SdimFloatingLiteral::Create(const ASTContext &C, EmptyShell Empty) { 736234353Sdim return new (C) FloatingLiteral(C, Empty); 737212904Sdim} 738212904Sdim 739249423Sdimconst llvm::fltSemantics &FloatingLiteral::getSemantics() const { 740249423Sdim switch(FloatingLiteralBits.Semantics) { 741249423Sdim case IEEEhalf: 742249423Sdim return llvm::APFloat::IEEEhalf; 743249423Sdim case IEEEsingle: 744249423Sdim return llvm::APFloat::IEEEsingle; 745249423Sdim case IEEEdouble: 746249423Sdim return llvm::APFloat::IEEEdouble; 747249423Sdim case x87DoubleExtended: 748249423Sdim return llvm::APFloat::x87DoubleExtended; 749249423Sdim case IEEEquad: 750249423Sdim return llvm::APFloat::IEEEquad; 751249423Sdim case PPCDoubleDouble: 752249423Sdim return llvm::APFloat::PPCDoubleDouble; 753249423Sdim } 754249423Sdim llvm_unreachable("Unrecognised floating semantics"); 755249423Sdim} 756249423Sdim 757249423Sdimvoid FloatingLiteral::setSemantics(const llvm::fltSemantics &Sem) { 758249423Sdim if (&Sem == &llvm::APFloat::IEEEhalf) 759249423Sdim FloatingLiteralBits.Semantics = IEEEhalf; 760249423Sdim else if (&Sem == &llvm::APFloat::IEEEsingle) 761249423Sdim FloatingLiteralBits.Semantics = IEEEsingle; 762249423Sdim else if (&Sem == &llvm::APFloat::IEEEdouble) 763249423Sdim FloatingLiteralBits.Semantics = IEEEdouble; 764249423Sdim else if (&Sem == &llvm::APFloat::x87DoubleExtended) 765249423Sdim FloatingLiteralBits.Semantics = x87DoubleExtended; 766249423Sdim else if (&Sem == &llvm::APFloat::IEEEquad) 767249423Sdim FloatingLiteralBits.Semantics = IEEEquad; 768249423Sdim else if (&Sem == &llvm::APFloat::PPCDoubleDouble) 769249423Sdim FloatingLiteralBits.Semantics = PPCDoubleDouble; 770249423Sdim else 771249423Sdim llvm_unreachable("Unknown floating semantics"); 772249423Sdim} 773249423Sdim 774193326Sed/// getValueAsApproximateDouble - This returns the value as an inaccurate 775193326Sed/// double. Note that this may cause loss of precision, but is useful for 776193326Sed/// debugging dumps, etc. 777193326Seddouble FloatingLiteral::getValueAsApproximateDouble() const { 778193326Sed llvm::APFloat V = getValue(); 779193326Sed bool ignored; 780193326Sed V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 781193326Sed &ignored); 782193326Sed return V.convertToDouble(); 783193326Sed} 784193326Sed 785234353Sdimint StringLiteral::mapCharByteWidth(TargetInfo const &target,StringKind k) { 786234353Sdim int CharByteWidth = 0; 787234353Sdim switch(k) { 788234353Sdim case Ascii: 789234353Sdim case UTF8: 790234353Sdim CharByteWidth = target.getCharWidth(); 791234353Sdim break; 792234353Sdim case Wide: 793234353Sdim CharByteWidth = target.getWCharWidth(); 794234353Sdim break; 795234353Sdim case UTF16: 796234353Sdim CharByteWidth = target.getChar16Width(); 797234353Sdim break; 798234353Sdim case UTF32: 799234353Sdim CharByteWidth = target.getChar32Width(); 800234353Sdim break; 801234353Sdim } 802234353Sdim assert((CharByteWidth & 7) == 0 && "Assumes character size is byte multiple"); 803234353Sdim CharByteWidth /= 8; 804234353Sdim assert((CharByteWidth==1 || CharByteWidth==2 || CharByteWidth==4) 805234353Sdim && "character byte widths supported are 1, 2, and 4 only"); 806234353Sdim return CharByteWidth; 807234353Sdim} 808234353Sdim 809263508SdimStringLiteral *StringLiteral::Create(const ASTContext &C, StringRef Str, 810226633Sdim StringKind Kind, bool Pascal, QualType Ty, 811198092Srdivacky const SourceLocation *Loc, 812193326Sed unsigned NumStrs) { 813193326Sed // Allocate enough space for the StringLiteral plus an array of locations for 814193326Sed // any concatenated string tokens. 815193326Sed void *Mem = C.Allocate(sizeof(StringLiteral)+ 816193326Sed sizeof(SourceLocation)*(NumStrs-1), 817218893Sdim llvm::alignOf<StringLiteral>()); 818193326Sed StringLiteral *SL = new (Mem) StringLiteral(Ty); 819198092Srdivacky 820193326Sed // OPTIMIZE: could allocate this appended to the StringLiteral. 821234353Sdim SL->setString(C,Str,Kind,Pascal); 822234353Sdim 823193326Sed SL->TokLocs[0] = Loc[0]; 824193326Sed SL->NumConcatenated = NumStrs; 825193326Sed 826193326Sed if (NumStrs != 1) 827193326Sed memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1)); 828193326Sed return SL; 829193326Sed} 830193326Sed 831263508SdimStringLiteral *StringLiteral::CreateEmpty(const ASTContext &C, 832263508Sdim unsigned NumStrs) { 833193326Sed void *Mem = C.Allocate(sizeof(StringLiteral)+ 834193326Sed sizeof(SourceLocation)*(NumStrs-1), 835218893Sdim llvm::alignOf<StringLiteral>()); 836193326Sed StringLiteral *SL = new (Mem) StringLiteral(QualType()); 837234353Sdim SL->CharByteWidth = 0; 838234353Sdim SL->Length = 0; 839193326Sed SL->NumConcatenated = NumStrs; 840193326Sed return SL; 841193326Sed} 842193326Sed 843249423Sdimvoid StringLiteral::outputString(raw_ostream &OS) const { 844239462Sdim switch (getKind()) { 845239462Sdim case Ascii: break; // no prefix. 846239462Sdim case Wide: OS << 'L'; break; 847239462Sdim case UTF8: OS << "u8"; break; 848239462Sdim case UTF16: OS << 'u'; break; 849239462Sdim case UTF32: OS << 'U'; break; 850239462Sdim } 851239462Sdim OS << '"'; 852239462Sdim static const char Hex[] = "0123456789ABCDEF"; 853239462Sdim 854239462Sdim unsigned LastSlashX = getLength(); 855239462Sdim for (unsigned I = 0, N = getLength(); I != N; ++I) { 856239462Sdim switch (uint32_t Char = getCodeUnit(I)) { 857239462Sdim default: 858239462Sdim // FIXME: Convert UTF-8 back to codepoints before rendering. 859239462Sdim 860239462Sdim // Convert UTF-16 surrogate pairs back to codepoints before rendering. 861239462Sdim // Leave invalid surrogates alone; we'll use \x for those. 862239462Sdim if (getKind() == UTF16 && I != N - 1 && Char >= 0xd800 && 863239462Sdim Char <= 0xdbff) { 864239462Sdim uint32_t Trail = getCodeUnit(I + 1); 865239462Sdim if (Trail >= 0xdc00 && Trail <= 0xdfff) { 866239462Sdim Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00); 867239462Sdim ++I; 868239462Sdim } 869239462Sdim } 870239462Sdim 871239462Sdim if (Char > 0xff) { 872239462Sdim // If this is a wide string, output characters over 0xff using \x 873239462Sdim // escapes. Otherwise, this is a UTF-16 or UTF-32 string, and Char is a 874239462Sdim // codepoint: use \x escapes for invalid codepoints. 875239462Sdim if (getKind() == Wide || 876239462Sdim (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) { 877239462Sdim // FIXME: Is this the best way to print wchar_t? 878239462Sdim OS << "\\x"; 879239462Sdim int Shift = 28; 880239462Sdim while ((Char >> Shift) == 0) 881239462Sdim Shift -= 4; 882239462Sdim for (/**/; Shift >= 0; Shift -= 4) 883239462Sdim OS << Hex[(Char >> Shift) & 15]; 884239462Sdim LastSlashX = I; 885239462Sdim break; 886239462Sdim } 887239462Sdim 888239462Sdim if (Char > 0xffff) 889239462Sdim OS << "\\U00" 890239462Sdim << Hex[(Char >> 20) & 15] 891239462Sdim << Hex[(Char >> 16) & 15]; 892239462Sdim else 893239462Sdim OS << "\\u"; 894239462Sdim OS << Hex[(Char >> 12) & 15] 895239462Sdim << Hex[(Char >> 8) & 15] 896239462Sdim << Hex[(Char >> 4) & 15] 897239462Sdim << Hex[(Char >> 0) & 15]; 898239462Sdim break; 899239462Sdim } 900239462Sdim 901239462Sdim // If we used \x... for the previous character, and this character is a 902239462Sdim // hexadecimal digit, prevent it being slurped as part of the \x. 903239462Sdim if (LastSlashX + 1 == I) { 904239462Sdim switch (Char) { 905239462Sdim case '0': case '1': case '2': case '3': case '4': 906239462Sdim case '5': case '6': case '7': case '8': case '9': 907239462Sdim case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': 908239462Sdim case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': 909239462Sdim OS << "\"\""; 910239462Sdim } 911239462Sdim } 912239462Sdim 913239462Sdim assert(Char <= 0xff && 914239462Sdim "Characters above 0xff should already have been handled."); 915239462Sdim 916249423Sdim if (isPrintable(Char)) 917239462Sdim OS << (char)Char; 918239462Sdim else // Output anything hard as an octal escape. 919239462Sdim OS << '\\' 920239462Sdim << (char)('0' + ((Char >> 6) & 7)) 921239462Sdim << (char)('0' + ((Char >> 3) & 7)) 922239462Sdim << (char)('0' + ((Char >> 0) & 7)); 923239462Sdim break; 924239462Sdim // Handle some common non-printable cases to make dumps prettier. 925239462Sdim case '\\': OS << "\\\\"; break; 926239462Sdim case '"': OS << "\\\""; break; 927239462Sdim case '\n': OS << "\\n"; break; 928239462Sdim case '\t': OS << "\\t"; break; 929239462Sdim case '\a': OS << "\\a"; break; 930239462Sdim case '\b': OS << "\\b"; break; 931239462Sdim } 932239462Sdim } 933239462Sdim OS << '"'; 934239462Sdim} 935239462Sdim 936263508Sdimvoid StringLiteral::setString(const ASTContext &C, StringRef Str, 937234353Sdim StringKind Kind, bool IsPascal) { 938234353Sdim //FIXME: we assume that the string data comes from a target that uses the same 939234353Sdim // code unit size and endianess for the type of string. 940234353Sdim this->Kind = Kind; 941234353Sdim this->IsPascal = IsPascal; 942234353Sdim 943234353Sdim CharByteWidth = mapCharByteWidth(C.getTargetInfo(),Kind); 944234353Sdim assert((Str.size()%CharByteWidth == 0) 945234353Sdim && "size of data must be multiple of CharByteWidth"); 946234353Sdim Length = Str.size()/CharByteWidth; 947234353Sdim 948234353Sdim switch(CharByteWidth) { 949234353Sdim case 1: { 950234353Sdim char *AStrData = new (C) char[Length]; 951243830Sdim std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData)); 952234353Sdim StrData.asChar = AStrData; 953234353Sdim break; 954234353Sdim } 955234353Sdim case 2: { 956234353Sdim uint16_t *AStrData = new (C) uint16_t[Length]; 957243830Sdim std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData)); 958234353Sdim StrData.asUInt16 = AStrData; 959234353Sdim break; 960234353Sdim } 961234353Sdim case 4: { 962234353Sdim uint32_t *AStrData = new (C) uint32_t[Length]; 963243830Sdim std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData)); 964234353Sdim StrData.asUInt32 = AStrData; 965234353Sdim break; 966234353Sdim } 967234353Sdim default: 968234353Sdim assert(false && "unsupported CharByteWidth"); 969234353Sdim } 970193326Sed} 971193326Sed 972218893Sdim/// getLocationOfByte - Return a source location that points to the specified 973218893Sdim/// byte of this string literal. 974218893Sdim/// 975218893Sdim/// Strings are amazingly complex. They can be formed from multiple tokens and 976218893Sdim/// can have escape sequences in them in addition to the usual trigraph and 977218893Sdim/// escaped newline business. This routine handles this complexity. 978218893Sdim/// 979218893SdimSourceLocation StringLiteral:: 980218893SdimgetLocationOfByte(unsigned ByteNo, const SourceManager &SM, 981218893Sdim const LangOptions &Features, const TargetInfo &Target) const { 982239462Sdim assert((Kind == StringLiteral::Ascii || Kind == StringLiteral::UTF8) && 983239462Sdim "Only narrow string literals are currently supported"); 984226633Sdim 985218893Sdim // Loop over all of the tokens in this string until we find the one that 986218893Sdim // contains the byte we're looking for. 987218893Sdim unsigned TokNo = 0; 988218893Sdim while (1) { 989218893Sdim assert(TokNo < getNumConcatenated() && "Invalid byte number!"); 990218893Sdim SourceLocation StrTokLoc = getStrTokenLoc(TokNo); 991218893Sdim 992218893Sdim // Get the spelling of the string so that we can get the data that makes up 993218893Sdim // the string literal, not the identifier for the macro it is potentially 994218893Sdim // expanded through. 995218893Sdim SourceLocation StrTokSpellingLoc = SM.getSpellingLoc(StrTokLoc); 996218893Sdim 997218893Sdim // Re-lex the token to get its length and original spelling. 998218893Sdim std::pair<FileID, unsigned> LocInfo =SM.getDecomposedLoc(StrTokSpellingLoc); 999218893Sdim bool Invalid = false; 1000226633Sdim StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid); 1001218893Sdim if (Invalid) 1002218893Sdim return StrTokSpellingLoc; 1003218893Sdim 1004218893Sdim const char *StrData = Buffer.data()+LocInfo.second; 1005218893Sdim 1006218893Sdim // Create a lexer starting at the beginning of this token. 1007239462Sdim Lexer TheLexer(SM.getLocForStartOfFile(LocInfo.first), Features, 1008239462Sdim Buffer.begin(), StrData, Buffer.end()); 1009218893Sdim Token TheTok; 1010218893Sdim TheLexer.LexFromRawLexer(TheTok); 1011218893Sdim 1012218893Sdim // Use the StringLiteralParser to compute the length of the string in bytes. 1013218893Sdim StringLiteralParser SLP(&TheTok, 1, SM, Features, Target); 1014218893Sdim unsigned TokNumBytes = SLP.GetStringLength(); 1015218893Sdim 1016218893Sdim // If the byte is in this token, return the location of the byte. 1017218893Sdim if (ByteNo < TokNumBytes || 1018224145Sdim (ByteNo == TokNumBytes && TokNo == getNumConcatenated() - 1)) { 1019218893Sdim unsigned Offset = SLP.getOffsetOfStringByte(TheTok, ByteNo); 1020218893Sdim 1021218893Sdim // Now that we know the offset of the token in the spelling, use the 1022218893Sdim // preprocessor to get the offset in the original source. 1023218893Sdim return Lexer::AdvanceToTokenCharacter(StrTokLoc, Offset, SM, Features); 1024218893Sdim } 1025218893Sdim 1026218893Sdim // Move to the next string token. 1027218893Sdim ++TokNo; 1028218893Sdim ByteNo -= TokNumBytes; 1029218893Sdim } 1030218893Sdim} 1031218893Sdim 1032218893Sdim 1033218893Sdim 1034193326Sed/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 1035193326Sed/// corresponds to, e.g. "sizeof" or "[pre]++". 1036243830SdimStringRef UnaryOperator::getOpcodeStr(Opcode Op) { 1037193326Sed switch (Op) { 1038212904Sdim case UO_PostInc: return "++"; 1039212904Sdim case UO_PostDec: return "--"; 1040212904Sdim case UO_PreInc: return "++"; 1041212904Sdim case UO_PreDec: return "--"; 1042212904Sdim case UO_AddrOf: return "&"; 1043212904Sdim case UO_Deref: return "*"; 1044212904Sdim case UO_Plus: return "+"; 1045212904Sdim case UO_Minus: return "-"; 1046212904Sdim case UO_Not: return "~"; 1047212904Sdim case UO_LNot: return "!"; 1048212904Sdim case UO_Real: return "__real"; 1049212904Sdim case UO_Imag: return "__imag"; 1050212904Sdim case UO_Extension: return "__extension__"; 1051193326Sed } 1052234353Sdim llvm_unreachable("Unknown unary operator"); 1053193326Sed} 1054193326Sed 1055212904SdimUnaryOperatorKind 1056193326SedUnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) { 1057193326Sed switch (OO) { 1058226633Sdim default: llvm_unreachable("No unary operator for overloaded function"); 1059212904Sdim case OO_PlusPlus: return Postfix ? UO_PostInc : UO_PreInc; 1060212904Sdim case OO_MinusMinus: return Postfix ? UO_PostDec : UO_PreDec; 1061212904Sdim case OO_Amp: return UO_AddrOf; 1062212904Sdim case OO_Star: return UO_Deref; 1063212904Sdim case OO_Plus: return UO_Plus; 1064212904Sdim case OO_Minus: return UO_Minus; 1065212904Sdim case OO_Tilde: return UO_Not; 1066212904Sdim case OO_Exclaim: return UO_LNot; 1067193326Sed } 1068193326Sed} 1069193326Sed 1070193326SedOverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) { 1071193326Sed switch (Opc) { 1072212904Sdim case UO_PostInc: case UO_PreInc: return OO_PlusPlus; 1073212904Sdim case UO_PostDec: case UO_PreDec: return OO_MinusMinus; 1074212904Sdim case UO_AddrOf: return OO_Amp; 1075212904Sdim case UO_Deref: return OO_Star; 1076212904Sdim case UO_Plus: return OO_Plus; 1077212904Sdim case UO_Minus: return OO_Minus; 1078212904Sdim case UO_Not: return OO_Tilde; 1079212904Sdim case UO_LNot: return OO_Exclaim; 1080193326Sed default: return OO_None; 1081193326Sed } 1082193326Sed} 1083193326Sed 1084193326Sed 1085193326Sed//===----------------------------------------------------------------------===// 1086193326Sed// Postfix Operators. 1087193326Sed//===----------------------------------------------------------------------===// 1088193326Sed 1089263508SdimCallExpr::CallExpr(const ASTContext& C, StmtClass SC, Expr *fn, 1090263508Sdim unsigned NumPreArgs, ArrayRef<Expr*> args, QualType t, 1091263508Sdim ExprValueKind VK, SourceLocation rparenloc) 1092218893Sdim : Expr(SC, t, VK, OK_Ordinary, 1093218893Sdim fn->isTypeDependent(), 1094218893Sdim fn->isValueDependent(), 1095224145Sdim fn->isInstantiationDependent(), 1096218893Sdim fn->containsUnexpandedParameterPack()), 1097243830Sdim NumArgs(args.size()) { 1098198092Srdivacky 1099243830Sdim SubExprs = new (C) Stmt*[args.size()+PREARGS_START+NumPreArgs]; 1100193326Sed SubExprs[FN] = fn; 1101243830Sdim for (unsigned i = 0; i != args.size(); ++i) { 1102218893Sdim if (args[i]->isTypeDependent()) 1103218893Sdim ExprBits.TypeDependent = true; 1104218893Sdim if (args[i]->isValueDependent()) 1105218893Sdim ExprBits.ValueDependent = true; 1106224145Sdim if (args[i]->isInstantiationDependent()) 1107224145Sdim ExprBits.InstantiationDependent = true; 1108218893Sdim if (args[i]->containsUnexpandedParameterPack()) 1109218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 1110193326Sed 1111218893Sdim SubExprs[i+PREARGS_START+NumPreArgs] = args[i]; 1112218893Sdim } 1113218893Sdim 1114218893Sdim CallExprBits.NumPreArgs = NumPreArgs; 1115193326Sed RParenLoc = rparenloc; 1116193326Sed} 1117193326Sed 1118263508SdimCallExpr::CallExpr(const ASTContext& C, Expr *fn, ArrayRef<Expr*> args, 1119218893Sdim QualType t, ExprValueKind VK, SourceLocation rparenloc) 1120218893Sdim : Expr(CallExprClass, t, VK, OK_Ordinary, 1121218893Sdim fn->isTypeDependent(), 1122218893Sdim fn->isValueDependent(), 1123224145Sdim fn->isInstantiationDependent(), 1124218893Sdim fn->containsUnexpandedParameterPack()), 1125243830Sdim NumArgs(args.size()) { 1126193326Sed 1127243830Sdim SubExprs = new (C) Stmt*[args.size()+PREARGS_START]; 1128193326Sed SubExprs[FN] = fn; 1129243830Sdim for (unsigned i = 0; i != args.size(); ++i) { 1130218893Sdim if (args[i]->isTypeDependent()) 1131218893Sdim ExprBits.TypeDependent = true; 1132218893Sdim if (args[i]->isValueDependent()) 1133218893Sdim ExprBits.ValueDependent = true; 1134224145Sdim if (args[i]->isInstantiationDependent()) 1135224145Sdim ExprBits.InstantiationDependent = true; 1136218893Sdim if (args[i]->containsUnexpandedParameterPack()) 1137218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 1138193326Sed 1139218893Sdim SubExprs[i+PREARGS_START] = args[i]; 1140218893Sdim } 1141218893Sdim 1142218893Sdim CallExprBits.NumPreArgs = 0; 1143193326Sed RParenLoc = rparenloc; 1144193326Sed} 1145193326Sed 1146263508SdimCallExpr::CallExpr(const ASTContext &C, StmtClass SC, EmptyShell Empty) 1147198092Srdivacky : Expr(SC, Empty), SubExprs(0), NumArgs(0) { 1148218893Sdim // FIXME: Why do we allocate this? 1149218893Sdim SubExprs = new (C) Stmt*[PREARGS_START]; 1150218893Sdim CallExprBits.NumPreArgs = 0; 1151193326Sed} 1152193326Sed 1153263508SdimCallExpr::CallExpr(const ASTContext &C, StmtClass SC, unsigned NumPreArgs, 1154218893Sdim EmptyShell Empty) 1155218893Sdim : Expr(SC, Empty), SubExprs(0), NumArgs(0) { 1156218893Sdim // FIXME: Why do we allocate this? 1157218893Sdim SubExprs = new (C) Stmt*[PREARGS_START+NumPreArgs]; 1158218893Sdim CallExprBits.NumPreArgs = NumPreArgs; 1159218893Sdim} 1160218893Sdim 1161201361SrdivackyDecl *CallExpr::getCalleeDecl() { 1162226633Sdim Expr *CEE = getCallee()->IgnoreParenImpCasts(); 1163226633Sdim 1164226633Sdim while (SubstNonTypeTemplateParmExpr *NTTP 1165226633Sdim = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE)) { 1166226633Sdim CEE = NTTP->getReplacement()->IgnoreParenCasts(); 1167226633Sdim } 1168226633Sdim 1169218893Sdim // If we're calling a dereference, look at the pointer instead. 1170218893Sdim if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CEE)) { 1171218893Sdim if (BO->isPtrMemOp()) 1172218893Sdim CEE = BO->getRHS()->IgnoreParenCasts(); 1173218893Sdim } else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(CEE)) { 1174218893Sdim if (UO->getOpcode() == UO_Deref) 1175218893Sdim CEE = UO->getSubExpr()->IgnoreParenCasts(); 1176218893Sdim } 1177198092Srdivacky if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) 1178201361Srdivacky return DRE->getDecl(); 1179201361Srdivacky if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE)) 1180201361Srdivacky return ME->getMemberDecl(); 1181198092Srdivacky 1182198092Srdivacky return 0; 1183198092Srdivacky} 1184198092Srdivacky 1185201361SrdivackyFunctionDecl *CallExpr::getDirectCallee() { 1186201361Srdivacky return dyn_cast_or_null<FunctionDecl>(getCalleeDecl()); 1187201361Srdivacky} 1188201361Srdivacky 1189193326Sed/// setNumArgs - This changes the number of arguments present in this call. 1190193326Sed/// Any orphaned expressions are deleted by this, and any new operands are set 1191193326Sed/// to null. 1192263508Sdimvoid CallExpr::setNumArgs(const ASTContext& C, unsigned NumArgs) { 1193193326Sed // No change, just return. 1194193326Sed if (NumArgs == getNumArgs()) return; 1195198092Srdivacky 1196193326Sed // If shrinking # arguments, just delete the extras and forgot them. 1197193326Sed if (NumArgs < getNumArgs()) { 1198193326Sed this->NumArgs = NumArgs; 1199193326Sed return; 1200193326Sed } 1201193326Sed 1202193326Sed // Otherwise, we are growing the # arguments. New an bigger argument array. 1203218893Sdim unsigned NumPreArgs = getNumPreArgs(); 1204218893Sdim Stmt **NewSubExprs = new (C) Stmt*[NumArgs+PREARGS_START+NumPreArgs]; 1205193326Sed // Copy over args. 1206218893Sdim for (unsigned i = 0; i != getNumArgs()+PREARGS_START+NumPreArgs; ++i) 1207193326Sed NewSubExprs[i] = SubExprs[i]; 1208193326Sed // Null out new args. 1209218893Sdim for (unsigned i = getNumArgs()+PREARGS_START+NumPreArgs; 1210218893Sdim i != NumArgs+PREARGS_START+NumPreArgs; ++i) 1211193326Sed NewSubExprs[i] = 0; 1212198092Srdivacky 1213193326Sed if (SubExprs) C.Deallocate(SubExprs); 1214193326Sed SubExprs = NewSubExprs; 1215193326Sed this->NumArgs = NumArgs; 1216193326Sed} 1217193326Sed 1218193326Sed/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If 1219193326Sed/// not, return 0. 1220234353Sdimunsigned CallExpr::isBuiltinCall() const { 1221193326Sed // All simple function calls (e.g. func()) are implicitly cast to pointer to 1222198092Srdivacky // function. As a result, we try and obtain the DeclRefExpr from the 1223193326Sed // ImplicitCastExpr. 1224193326Sed const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 1225193326Sed if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 1226193326Sed return 0; 1227198092Srdivacky 1228193326Sed const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 1229193326Sed if (!DRE) 1230193326Sed return 0; 1231198092Srdivacky 1232193326Sed const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 1233193326Sed if (!FDecl) 1234193326Sed return 0; 1235198092Srdivacky 1236193326Sed if (!FDecl->getIdentifier()) 1237193326Sed return 0; 1238193326Sed 1239198092Srdivacky return FDecl->getBuiltinID(); 1240193326Sed} 1241193326Sed 1242249423Sdimbool CallExpr::isUnevaluatedBuiltinCall(ASTContext &Ctx) const { 1243249423Sdim if (unsigned BI = isBuiltinCall()) 1244249423Sdim return Ctx.BuiltinInfo.isUnevaluated(BI); 1245249423Sdim return false; 1246249423Sdim} 1247249423Sdim 1248193326SedQualType CallExpr::getCallReturnType() const { 1249193326Sed QualType CalleeType = getCallee()->getType(); 1250198092Srdivacky if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>()) 1251193326Sed CalleeType = FnTypePtr->getPointeeType(); 1252198092Srdivacky else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>()) 1253193326Sed CalleeType = BPT->getPointeeType(); 1254221345Sdim else if (CalleeType->isSpecificPlaceholderType(BuiltinType::BoundMember)) 1255221345Sdim // This should never be overloaded and so should never return null. 1256221345Sdim CalleeType = Expr::findBoundMemberType(getCallee()); 1257210299Sed 1258221345Sdim const FunctionType *FnType = CalleeType->castAs<FunctionType>(); 1259193326Sed return FnType->getResultType(); 1260193326Sed} 1261193326Sed 1262234353SdimSourceLocation CallExpr::getLocStart() const { 1263234353Sdim if (isa<CXXOperatorCallExpr>(this)) 1264249423Sdim return cast<CXXOperatorCallExpr>(this)->getLocStart(); 1265219077Sdim 1266234353Sdim SourceLocation begin = getCallee()->getLocStart(); 1267234353Sdim if (begin.isInvalid() && getNumArgs() > 0) 1268234353Sdim begin = getArg(0)->getLocStart(); 1269234353Sdim return begin; 1270234353Sdim} 1271234353SdimSourceLocation CallExpr::getLocEnd() const { 1272234353Sdim if (isa<CXXOperatorCallExpr>(this)) 1273249423Sdim return cast<CXXOperatorCallExpr>(this)->getLocEnd(); 1274234353Sdim 1275234353Sdim SourceLocation end = getRParenLoc(); 1276234353Sdim if (end.isInvalid() && getNumArgs() > 0) 1277234353Sdim end = getArg(getNumArgs() - 1)->getLocEnd(); 1278234353Sdim return end; 1279234353Sdim} 1280234353Sdim 1281263508SdimOffsetOfExpr *OffsetOfExpr::Create(const ASTContext &C, QualType type, 1282207619Srdivacky SourceLocation OperatorLoc, 1283207619Srdivacky TypeSourceInfo *tsi, 1284243830Sdim ArrayRef<OffsetOfNode> comps, 1285243830Sdim ArrayRef<Expr*> exprs, 1286207619Srdivacky SourceLocation RParenLoc) { 1287207619Srdivacky void *Mem = C.Allocate(sizeof(OffsetOfExpr) + 1288243830Sdim sizeof(OffsetOfNode) * comps.size() + 1289243830Sdim sizeof(Expr*) * exprs.size()); 1290207619Srdivacky 1291243830Sdim return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, comps, exprs, 1292243830Sdim RParenLoc); 1293207619Srdivacky} 1294207619Srdivacky 1295263508SdimOffsetOfExpr *OffsetOfExpr::CreateEmpty(const ASTContext &C, 1296207619Srdivacky unsigned numComps, unsigned numExprs) { 1297207619Srdivacky void *Mem = C.Allocate(sizeof(OffsetOfExpr) + 1298207619Srdivacky sizeof(OffsetOfNode) * numComps + 1299207619Srdivacky sizeof(Expr*) * numExprs); 1300207619Srdivacky return new (Mem) OffsetOfExpr(numComps, numExprs); 1301207619Srdivacky} 1302207619Srdivacky 1303263508SdimOffsetOfExpr::OffsetOfExpr(const ASTContext &C, QualType type, 1304207619Srdivacky SourceLocation OperatorLoc, TypeSourceInfo *tsi, 1305243830Sdim ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs, 1306207619Srdivacky SourceLocation RParenLoc) 1307218893Sdim : Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary, 1308218893Sdim /*TypeDependent=*/false, 1309218893Sdim /*ValueDependent=*/tsi->getType()->isDependentType(), 1310224145Sdim tsi->getType()->isInstantiationDependentType(), 1311218893Sdim tsi->getType()->containsUnexpandedParameterPack()), 1312207619Srdivacky OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi), 1313243830Sdim NumComps(comps.size()), NumExprs(exprs.size()) 1314207619Srdivacky{ 1315243830Sdim for (unsigned i = 0; i != comps.size(); ++i) { 1316243830Sdim setComponent(i, comps[i]); 1317207619Srdivacky } 1318207619Srdivacky 1319243830Sdim for (unsigned i = 0; i != exprs.size(); ++i) { 1320243830Sdim if (exprs[i]->isTypeDependent() || exprs[i]->isValueDependent()) 1321218893Sdim ExprBits.ValueDependent = true; 1322243830Sdim if (exprs[i]->containsUnexpandedParameterPack()) 1323218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 1324218893Sdim 1325243830Sdim setIndexExpr(i, exprs[i]); 1326207619Srdivacky } 1327207619Srdivacky} 1328207619Srdivacky 1329207619SrdivackyIdentifierInfo *OffsetOfExpr::OffsetOfNode::getFieldName() const { 1330207619Srdivacky assert(getKind() == Field || getKind() == Identifier); 1331207619Srdivacky if (getKind() == Field) 1332207619Srdivacky return getField()->getIdentifier(); 1333207619Srdivacky 1334207619Srdivacky return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask); 1335207619Srdivacky} 1336207619Srdivacky 1337263508SdimMemberExpr *MemberExpr::Create(const ASTContext &C, Expr *base, bool isarrow, 1338221345Sdim NestedNameSpecifierLoc QualifierLoc, 1339234353Sdim SourceLocation TemplateKWLoc, 1340200583Srdivacky ValueDecl *memberdecl, 1341207619Srdivacky DeclAccessPair founddecl, 1342212904Sdim DeclarationNameInfo nameinfo, 1343199990Srdivacky const TemplateArgumentListInfo *targs, 1344218893Sdim QualType ty, 1345218893Sdim ExprValueKind vk, 1346218893Sdim ExprObjectKind ok) { 1347198092Srdivacky std::size_t Size = sizeof(MemberExpr); 1348198092Srdivacky 1349221345Sdim bool hasQualOrFound = (QualifierLoc || 1350207619Srdivacky founddecl.getDecl() != memberdecl || 1351207619Srdivacky founddecl.getAccess() != memberdecl->getAccess()); 1352206084Srdivacky if (hasQualOrFound) 1353206084Srdivacky Size += sizeof(MemberNameQualifier); 1354206084Srdivacky 1355199990Srdivacky if (targs) 1356234353Sdim Size += ASTTemplateKWAndArgsInfo::sizeFor(targs->size()); 1357234353Sdim else if (TemplateKWLoc.isValid()) 1358234353Sdim Size += ASTTemplateKWAndArgsInfo::sizeFor(0); 1359198092Srdivacky 1360218893Sdim void *Mem = C.Allocate(Size, llvm::alignOf<MemberExpr>()); 1361218893Sdim MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, nameinfo, 1362218893Sdim ty, vk, ok); 1363206084Srdivacky 1364206084Srdivacky if (hasQualOrFound) { 1365221345Sdim // FIXME: Wrong. We should be looking at the member declaration we found. 1366221345Sdim if (QualifierLoc && QualifierLoc.getNestedNameSpecifier()->isDependent()) { 1367206084Srdivacky E->setValueDependent(true); 1368206084Srdivacky E->setTypeDependent(true); 1369224145Sdim E->setInstantiationDependent(true); 1370224145Sdim } 1371224145Sdim else if (QualifierLoc && 1372224145Sdim QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent()) 1373224145Sdim E->setInstantiationDependent(true); 1374224145Sdim 1375206084Srdivacky E->HasQualifierOrFoundDecl = true; 1376206084Srdivacky 1377206084Srdivacky MemberNameQualifier *NQ = E->getMemberQualifier(); 1378221345Sdim NQ->QualifierLoc = QualifierLoc; 1379206084Srdivacky NQ->FoundDecl = founddecl; 1380206084Srdivacky } 1381206084Srdivacky 1382234353Sdim E->HasTemplateKWAndArgsInfo = (targs || TemplateKWLoc.isValid()); 1383234353Sdim 1384206084Srdivacky if (targs) { 1385224145Sdim bool Dependent = false; 1386224145Sdim bool InstantiationDependent = false; 1387224145Sdim bool ContainsUnexpandedParameterPack = false; 1388234353Sdim E->getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *targs, 1389234353Sdim Dependent, 1390234353Sdim InstantiationDependent, 1391234353Sdim ContainsUnexpandedParameterPack); 1392224145Sdim if (InstantiationDependent) 1393224145Sdim E->setInstantiationDependent(true); 1394234353Sdim } else if (TemplateKWLoc.isValid()) { 1395234353Sdim E->getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc); 1396206084Srdivacky } 1397206084Srdivacky 1398206084Srdivacky return E; 1399198092Srdivacky} 1400198092Srdivacky 1401234353SdimSourceLocation MemberExpr::getLocStart() const { 1402221345Sdim if (isImplicitAccess()) { 1403221345Sdim if (hasQualifier()) 1404234353Sdim return getQualifierLoc().getBeginLoc(); 1405234353Sdim return MemberLoc; 1406221345Sdim } 1407234353Sdim 1408234353Sdim // FIXME: We don't want this to happen. Rather, we should be able to 1409234353Sdim // detect all kinds of implicit accesses more cleanly. 1410234353Sdim SourceLocation BaseStartLoc = getBase()->getLocStart(); 1411234353Sdim if (BaseStartLoc.isValid()) 1412234353Sdim return BaseStartLoc; 1413234353Sdim return MemberLoc; 1414221345Sdim} 1415234353SdimSourceLocation MemberExpr::getLocEnd() const { 1416243830Sdim SourceLocation EndLoc = getMemberNameInfo().getEndLoc(); 1417234353Sdim if (hasExplicitTemplateArgs()) 1418243830Sdim EndLoc = getRAngleLoc(); 1419243830Sdim else if (EndLoc.isInvalid()) 1420243830Sdim EndLoc = getBase()->getLocEnd(); 1421243830Sdim return EndLoc; 1422234353Sdim} 1423221345Sdim 1424226633Sdimvoid CastExpr::CheckCastConsistency() const { 1425226633Sdim switch (getCastKind()) { 1426226633Sdim case CK_DerivedToBase: 1427226633Sdim case CK_UncheckedDerivedToBase: 1428226633Sdim case CK_DerivedToBaseMemberPointer: 1429226633Sdim case CK_BaseToDerived: 1430226633Sdim case CK_BaseToDerivedMemberPointer: 1431226633Sdim assert(!path_empty() && "Cast kind should have a base path!"); 1432226633Sdim break; 1433226633Sdim 1434226633Sdim case CK_CPointerToObjCPointerCast: 1435226633Sdim assert(getType()->isObjCObjectPointerType()); 1436226633Sdim assert(getSubExpr()->getType()->isPointerType()); 1437226633Sdim goto CheckNoBasePath; 1438226633Sdim 1439226633Sdim case CK_BlockPointerToObjCPointerCast: 1440226633Sdim assert(getType()->isObjCObjectPointerType()); 1441226633Sdim assert(getSubExpr()->getType()->isBlockPointerType()); 1442226633Sdim goto CheckNoBasePath; 1443226633Sdim 1444234353Sdim case CK_ReinterpretMemberPointer: 1445234353Sdim assert(getType()->isMemberPointerType()); 1446234353Sdim assert(getSubExpr()->getType()->isMemberPointerType()); 1447234353Sdim goto CheckNoBasePath; 1448234353Sdim 1449226633Sdim case CK_BitCast: 1450226633Sdim // Arbitrary casts to C pointer types count as bitcasts. 1451226633Sdim // Otherwise, we should only have block and ObjC pointer casts 1452226633Sdim // here if they stay within the type kind. 1453226633Sdim if (!getType()->isPointerType()) { 1454226633Sdim assert(getType()->isObjCObjectPointerType() == 1455226633Sdim getSubExpr()->getType()->isObjCObjectPointerType()); 1456226633Sdim assert(getType()->isBlockPointerType() == 1457226633Sdim getSubExpr()->getType()->isBlockPointerType()); 1458226633Sdim } 1459226633Sdim goto CheckNoBasePath; 1460226633Sdim 1461226633Sdim case CK_AnyPointerToBlockPointerCast: 1462226633Sdim assert(getType()->isBlockPointerType()); 1463226633Sdim assert(getSubExpr()->getType()->isAnyPointerType() && 1464226633Sdim !getSubExpr()->getType()->isBlockPointerType()); 1465226633Sdim goto CheckNoBasePath; 1466226633Sdim 1467234353Sdim case CK_CopyAndAutoreleaseBlockObject: 1468234353Sdim assert(getType()->isBlockPointerType()); 1469234353Sdim assert(getSubExpr()->getType()->isBlockPointerType()); 1470234353Sdim goto CheckNoBasePath; 1471243830Sdim 1472243830Sdim case CK_FunctionToPointerDecay: 1473243830Sdim assert(getType()->isPointerType()); 1474243830Sdim assert(getSubExpr()->getType()->isFunctionType()); 1475243830Sdim goto CheckNoBasePath; 1476243830Sdim 1477226633Sdim // These should not have an inheritance path. 1478226633Sdim case CK_Dynamic: 1479226633Sdim case CK_ToUnion: 1480226633Sdim case CK_ArrayToPointerDecay: 1481226633Sdim case CK_NullToMemberPointer: 1482226633Sdim case CK_NullToPointer: 1483226633Sdim case CK_ConstructorConversion: 1484226633Sdim case CK_IntegralToPointer: 1485226633Sdim case CK_PointerToIntegral: 1486226633Sdim case CK_ToVoid: 1487226633Sdim case CK_VectorSplat: 1488226633Sdim case CK_IntegralCast: 1489226633Sdim case CK_IntegralToFloating: 1490226633Sdim case CK_FloatingToIntegral: 1491226633Sdim case CK_FloatingCast: 1492226633Sdim case CK_ObjCObjectLValueCast: 1493226633Sdim case CK_FloatingRealToComplex: 1494226633Sdim case CK_FloatingComplexToReal: 1495226633Sdim case CK_FloatingComplexCast: 1496226633Sdim case CK_FloatingComplexToIntegralComplex: 1497226633Sdim case CK_IntegralRealToComplex: 1498226633Sdim case CK_IntegralComplexToReal: 1499226633Sdim case CK_IntegralComplexCast: 1500226633Sdim case CK_IntegralComplexToFloatingComplex: 1501226633Sdim case CK_ARCProduceObject: 1502226633Sdim case CK_ARCConsumeObject: 1503226633Sdim case CK_ARCReclaimReturnedObject: 1504226633Sdim case CK_ARCExtendBlockObject: 1505249423Sdim case CK_ZeroToOCLEvent: 1506226633Sdim assert(!getType()->isBooleanType() && "unheralded conversion to bool"); 1507226633Sdim goto CheckNoBasePath; 1508226633Sdim 1509226633Sdim case CK_Dependent: 1510226633Sdim case CK_LValueToRValue: 1511226633Sdim case CK_NoOp: 1512234353Sdim case CK_AtomicToNonAtomic: 1513234353Sdim case CK_NonAtomicToAtomic: 1514226633Sdim case CK_PointerToBoolean: 1515226633Sdim case CK_IntegralToBoolean: 1516226633Sdim case CK_FloatingToBoolean: 1517226633Sdim case CK_MemberPointerToBoolean: 1518226633Sdim case CK_FloatingComplexToBoolean: 1519226633Sdim case CK_IntegralComplexToBoolean: 1520226633Sdim case CK_LValueBitCast: // -> bool& 1521226633Sdim case CK_UserDefinedConversion: // operator bool() 1522243830Sdim case CK_BuiltinFnToFnPtr: 1523226633Sdim CheckNoBasePath: 1524226633Sdim assert(path_empty() && "Cast kind should not have a base path!"); 1525226633Sdim break; 1526226633Sdim } 1527226633Sdim} 1528226633Sdim 1529198092Srdivackyconst char *CastExpr::getCastKindName() const { 1530198092Srdivacky switch (getCastKind()) { 1531218893Sdim case CK_Dependent: 1532218893Sdim return "Dependent"; 1533212904Sdim case CK_BitCast: 1534198092Srdivacky return "BitCast"; 1535212904Sdim case CK_LValueBitCast: 1536210299Sed return "LValueBitCast"; 1537218893Sdim case CK_LValueToRValue: 1538218893Sdim return "LValueToRValue"; 1539212904Sdim case CK_NoOp: 1540198092Srdivacky return "NoOp"; 1541212904Sdim case CK_BaseToDerived: 1542199482Srdivacky return "BaseToDerived"; 1543212904Sdim case CK_DerivedToBase: 1544198092Srdivacky return "DerivedToBase"; 1545212904Sdim case CK_UncheckedDerivedToBase: 1546206084Srdivacky return "UncheckedDerivedToBase"; 1547212904Sdim case CK_Dynamic: 1548198092Srdivacky return "Dynamic"; 1549212904Sdim case CK_ToUnion: 1550198092Srdivacky return "ToUnion"; 1551212904Sdim case CK_ArrayToPointerDecay: 1552198092Srdivacky return "ArrayToPointerDecay"; 1553212904Sdim case CK_FunctionToPointerDecay: 1554198092Srdivacky return "FunctionToPointerDecay"; 1555212904Sdim case CK_NullToMemberPointer: 1556198092Srdivacky return "NullToMemberPointer"; 1557218893Sdim case CK_NullToPointer: 1558218893Sdim return "NullToPointer"; 1559212904Sdim case CK_BaseToDerivedMemberPointer: 1560198092Srdivacky return "BaseToDerivedMemberPointer"; 1561212904Sdim case CK_DerivedToBaseMemberPointer: 1562198893Srdivacky return "DerivedToBaseMemberPointer"; 1563234353Sdim case CK_ReinterpretMemberPointer: 1564234353Sdim return "ReinterpretMemberPointer"; 1565212904Sdim case CK_UserDefinedConversion: 1566198092Srdivacky return "UserDefinedConversion"; 1567212904Sdim case CK_ConstructorConversion: 1568198092Srdivacky return "ConstructorConversion"; 1569212904Sdim case CK_IntegralToPointer: 1570198092Srdivacky return "IntegralToPointer"; 1571212904Sdim case CK_PointerToIntegral: 1572198092Srdivacky return "PointerToIntegral"; 1573218893Sdim case CK_PointerToBoolean: 1574218893Sdim return "PointerToBoolean"; 1575212904Sdim case CK_ToVoid: 1576198398Srdivacky return "ToVoid"; 1577212904Sdim case CK_VectorSplat: 1578198398Srdivacky return "VectorSplat"; 1579212904Sdim case CK_IntegralCast: 1580198398Srdivacky return "IntegralCast"; 1581218893Sdim case CK_IntegralToBoolean: 1582218893Sdim return "IntegralToBoolean"; 1583212904Sdim case CK_IntegralToFloating: 1584198398Srdivacky return "IntegralToFloating"; 1585212904Sdim case CK_FloatingToIntegral: 1586198398Srdivacky return "FloatingToIntegral"; 1587212904Sdim case CK_FloatingCast: 1588198398Srdivacky return "FloatingCast"; 1589218893Sdim case CK_FloatingToBoolean: 1590218893Sdim return "FloatingToBoolean"; 1591212904Sdim case CK_MemberPointerToBoolean: 1592199990Srdivacky return "MemberPointerToBoolean"; 1593226633Sdim case CK_CPointerToObjCPointerCast: 1594226633Sdim return "CPointerToObjCPointerCast"; 1595226633Sdim case CK_BlockPointerToObjCPointerCast: 1596226633Sdim return "BlockPointerToObjCPointerCast"; 1597212904Sdim case CK_AnyPointerToBlockPointerCast: 1598200583Srdivacky return "AnyPointerToBlockPointerCast"; 1599212904Sdim case CK_ObjCObjectLValueCast: 1600212904Sdim return "ObjCObjectLValueCast"; 1601218893Sdim case CK_FloatingRealToComplex: 1602218893Sdim return "FloatingRealToComplex"; 1603218893Sdim case CK_FloatingComplexToReal: 1604218893Sdim return "FloatingComplexToReal"; 1605218893Sdim case CK_FloatingComplexToBoolean: 1606218893Sdim return "FloatingComplexToBoolean"; 1607218893Sdim case CK_FloatingComplexCast: 1608218893Sdim return "FloatingComplexCast"; 1609218893Sdim case CK_FloatingComplexToIntegralComplex: 1610218893Sdim return "FloatingComplexToIntegralComplex"; 1611218893Sdim case CK_IntegralRealToComplex: 1612218893Sdim return "IntegralRealToComplex"; 1613218893Sdim case CK_IntegralComplexToReal: 1614218893Sdim return "IntegralComplexToReal"; 1615218893Sdim case CK_IntegralComplexToBoolean: 1616218893Sdim return "IntegralComplexToBoolean"; 1617218893Sdim case CK_IntegralComplexCast: 1618218893Sdim return "IntegralComplexCast"; 1619218893Sdim case CK_IntegralComplexToFloatingComplex: 1620218893Sdim return "IntegralComplexToFloatingComplex"; 1621226633Sdim case CK_ARCConsumeObject: 1622226633Sdim return "ARCConsumeObject"; 1623226633Sdim case CK_ARCProduceObject: 1624226633Sdim return "ARCProduceObject"; 1625226633Sdim case CK_ARCReclaimReturnedObject: 1626226633Sdim return "ARCReclaimReturnedObject"; 1627226633Sdim case CK_ARCExtendBlockObject: 1628226633Sdim return "ARCCExtendBlockObject"; 1629234353Sdim case CK_AtomicToNonAtomic: 1630234353Sdim return "AtomicToNonAtomic"; 1631234353Sdim case CK_NonAtomicToAtomic: 1632234353Sdim return "NonAtomicToAtomic"; 1633234353Sdim case CK_CopyAndAutoreleaseBlockObject: 1634234353Sdim return "CopyAndAutoreleaseBlockObject"; 1635243830Sdim case CK_BuiltinFnToFnPtr: 1636243830Sdim return "BuiltinFnToFnPtr"; 1637249423Sdim case CK_ZeroToOCLEvent: 1638249423Sdim return "ZeroToOCLEvent"; 1639198092Srdivacky } 1640198092Srdivacky 1641218893Sdim llvm_unreachable("Unhandled cast kind!"); 1642198092Srdivacky} 1643198092Srdivacky 1644200583SrdivackyExpr *CastExpr::getSubExprAsWritten() { 1645200583Srdivacky Expr *SubExpr = 0; 1646200583Srdivacky CastExpr *E = this; 1647200583Srdivacky do { 1648200583Srdivacky SubExpr = E->getSubExpr(); 1649224145Sdim 1650224145Sdim // Skip through reference binding to temporary. 1651224145Sdim if (MaterializeTemporaryExpr *Materialize 1652224145Sdim = dyn_cast<MaterializeTemporaryExpr>(SubExpr)) 1653224145Sdim SubExpr = Materialize->GetTemporaryExpr(); 1654224145Sdim 1655200583Srdivacky // Skip any temporary bindings; they're implicit. 1656200583Srdivacky if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr)) 1657200583Srdivacky SubExpr = Binder->getSubExpr(); 1658200583Srdivacky 1659200583Srdivacky // Conversions by constructor and conversion functions have a 1660200583Srdivacky // subexpression describing the call; strip it off. 1661212904Sdim if (E->getCastKind() == CK_ConstructorConversion) 1662200583Srdivacky SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0); 1663212904Sdim else if (E->getCastKind() == CK_UserDefinedConversion) 1664200583Srdivacky SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument(); 1665200583Srdivacky 1666200583Srdivacky // If the subexpression we're left with is an implicit cast, look 1667200583Srdivacky // through that, too. 1668200583Srdivacky } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr))); 1669200583Srdivacky 1670200583Srdivacky return SubExpr; 1671200583Srdivacky} 1672200583Srdivacky 1673212904SdimCXXBaseSpecifier **CastExpr::path_buffer() { 1674212904Sdim switch (getStmtClass()) { 1675212904Sdim#define ABSTRACT_STMT(x) 1676212904Sdim#define CASTEXPR(Type, Base) \ 1677212904Sdim case Stmt::Type##Class: \ 1678212904Sdim return reinterpret_cast<CXXBaseSpecifier**>(static_cast<Type*>(this)+1); 1679212904Sdim#define STMT(Type, Base) 1680212904Sdim#include "clang/AST/StmtNodes.inc" 1681212904Sdim default: 1682212904Sdim llvm_unreachable("non-cast expressions not possible here"); 1683212904Sdim } 1684212904Sdim} 1685212904Sdim 1686212904Sdimvoid CastExpr::setCastPath(const CXXCastPath &Path) { 1687212904Sdim assert(Path.size() == path_size()); 1688212904Sdim memcpy(path_buffer(), Path.data(), Path.size() * sizeof(CXXBaseSpecifier*)); 1689212904Sdim} 1690212904Sdim 1691263508SdimImplicitCastExpr *ImplicitCastExpr::Create(const ASTContext &C, QualType T, 1692212904Sdim CastKind Kind, Expr *Operand, 1693212904Sdim const CXXCastPath *BasePath, 1694212904Sdim ExprValueKind VK) { 1695212904Sdim unsigned PathSize = (BasePath ? BasePath->size() : 0); 1696212904Sdim void *Buffer = 1697212904Sdim C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 1698212904Sdim ImplicitCastExpr *E = 1699212904Sdim new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK); 1700212904Sdim if (PathSize) E->setCastPath(*BasePath); 1701212904Sdim return E; 1702212904Sdim} 1703212904Sdim 1704263508SdimImplicitCastExpr *ImplicitCastExpr::CreateEmpty(const ASTContext &C, 1705212904Sdim unsigned PathSize) { 1706212904Sdim void *Buffer = 1707212904Sdim C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 1708212904Sdim return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize); 1709212904Sdim} 1710212904Sdim 1711212904Sdim 1712263508SdimCStyleCastExpr *CStyleCastExpr::Create(const ASTContext &C, QualType T, 1713218893Sdim ExprValueKind VK, CastKind K, Expr *Op, 1714212904Sdim const CXXCastPath *BasePath, 1715212904Sdim TypeSourceInfo *WrittenTy, 1716212904Sdim SourceLocation L, SourceLocation R) { 1717212904Sdim unsigned PathSize = (BasePath ? BasePath->size() : 0); 1718212904Sdim void *Buffer = 1719212904Sdim C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 1720212904Sdim CStyleCastExpr *E = 1721218893Sdim new (Buffer) CStyleCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, R); 1722212904Sdim if (PathSize) E->setCastPath(*BasePath); 1723212904Sdim return E; 1724212904Sdim} 1725212904Sdim 1726263508SdimCStyleCastExpr *CStyleCastExpr::CreateEmpty(const ASTContext &C, 1727263508Sdim unsigned PathSize) { 1728212904Sdim void *Buffer = 1729212904Sdim C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*)); 1730212904Sdim return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize); 1731212904Sdim} 1732212904Sdim 1733193326Sed/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 1734193326Sed/// corresponds to, e.g. "<<=". 1735243830SdimStringRef BinaryOperator::getOpcodeStr(Opcode Op) { 1736193326Sed switch (Op) { 1737212904Sdim case BO_PtrMemD: return ".*"; 1738212904Sdim case BO_PtrMemI: return "->*"; 1739212904Sdim case BO_Mul: return "*"; 1740212904Sdim case BO_Div: return "/"; 1741212904Sdim case BO_Rem: return "%"; 1742212904Sdim case BO_Add: return "+"; 1743212904Sdim case BO_Sub: return "-"; 1744212904Sdim case BO_Shl: return "<<"; 1745212904Sdim case BO_Shr: return ">>"; 1746212904Sdim case BO_LT: return "<"; 1747212904Sdim case BO_GT: return ">"; 1748212904Sdim case BO_LE: return "<="; 1749212904Sdim case BO_GE: return ">="; 1750212904Sdim case BO_EQ: return "=="; 1751212904Sdim case BO_NE: return "!="; 1752212904Sdim case BO_And: return "&"; 1753212904Sdim case BO_Xor: return "^"; 1754212904Sdim case BO_Or: return "|"; 1755212904Sdim case BO_LAnd: return "&&"; 1756212904Sdim case BO_LOr: return "||"; 1757212904Sdim case BO_Assign: return "="; 1758212904Sdim case BO_MulAssign: return "*="; 1759212904Sdim case BO_DivAssign: return "/="; 1760212904Sdim case BO_RemAssign: return "%="; 1761212904Sdim case BO_AddAssign: return "+="; 1762212904Sdim case BO_SubAssign: return "-="; 1763212904Sdim case BO_ShlAssign: return "<<="; 1764212904Sdim case BO_ShrAssign: return ">>="; 1765212904Sdim case BO_AndAssign: return "&="; 1766212904Sdim case BO_XorAssign: return "^="; 1767212904Sdim case BO_OrAssign: return "|="; 1768212904Sdim case BO_Comma: return ","; 1769193326Sed } 1770193326Sed 1771234353Sdim llvm_unreachable("Invalid OpCode!"); 1772193326Sed} 1773193326Sed 1774212904SdimBinaryOperatorKind 1775193326SedBinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) { 1776193326Sed switch (OO) { 1777226633Sdim default: llvm_unreachable("Not an overloadable binary operator"); 1778212904Sdim case OO_Plus: return BO_Add; 1779212904Sdim case OO_Minus: return BO_Sub; 1780212904Sdim case OO_Star: return BO_Mul; 1781212904Sdim case OO_Slash: return BO_Div; 1782212904Sdim case OO_Percent: return BO_Rem; 1783212904Sdim case OO_Caret: return BO_Xor; 1784212904Sdim case OO_Amp: return BO_And; 1785212904Sdim case OO_Pipe: return BO_Or; 1786212904Sdim case OO_Equal: return BO_Assign; 1787212904Sdim case OO_Less: return BO_LT; 1788212904Sdim case OO_Greater: return BO_GT; 1789212904Sdim case OO_PlusEqual: return BO_AddAssign; 1790212904Sdim case OO_MinusEqual: return BO_SubAssign; 1791212904Sdim case OO_StarEqual: return BO_MulAssign; 1792212904Sdim case OO_SlashEqual: return BO_DivAssign; 1793212904Sdim case OO_PercentEqual: return BO_RemAssign; 1794212904Sdim case OO_CaretEqual: return BO_XorAssign; 1795212904Sdim case OO_AmpEqual: return BO_AndAssign; 1796212904Sdim case OO_PipeEqual: return BO_OrAssign; 1797212904Sdim case OO_LessLess: return BO_Shl; 1798212904Sdim case OO_GreaterGreater: return BO_Shr; 1799212904Sdim case OO_LessLessEqual: return BO_ShlAssign; 1800212904Sdim case OO_GreaterGreaterEqual: return BO_ShrAssign; 1801212904Sdim case OO_EqualEqual: return BO_EQ; 1802212904Sdim case OO_ExclaimEqual: return BO_NE; 1803212904Sdim case OO_LessEqual: return BO_LE; 1804212904Sdim case OO_GreaterEqual: return BO_GE; 1805212904Sdim case OO_AmpAmp: return BO_LAnd; 1806212904Sdim case OO_PipePipe: return BO_LOr; 1807212904Sdim case OO_Comma: return BO_Comma; 1808212904Sdim case OO_ArrowStar: return BO_PtrMemI; 1809193326Sed } 1810193326Sed} 1811193326Sed 1812193326SedOverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) { 1813193326Sed static const OverloadedOperatorKind OverOps[] = { 1814193326Sed /* .* Cannot be overloaded */OO_None, OO_ArrowStar, 1815193326Sed OO_Star, OO_Slash, OO_Percent, 1816193326Sed OO_Plus, OO_Minus, 1817193326Sed OO_LessLess, OO_GreaterGreater, 1818193326Sed OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual, 1819193326Sed OO_EqualEqual, OO_ExclaimEqual, 1820193326Sed OO_Amp, 1821193326Sed OO_Caret, 1822193326Sed OO_Pipe, 1823193326Sed OO_AmpAmp, 1824193326Sed OO_PipePipe, 1825193326Sed OO_Equal, OO_StarEqual, 1826193326Sed OO_SlashEqual, OO_PercentEqual, 1827193326Sed OO_PlusEqual, OO_MinusEqual, 1828193326Sed OO_LessLessEqual, OO_GreaterGreaterEqual, 1829193326Sed OO_AmpEqual, OO_CaretEqual, 1830193326Sed OO_PipeEqual, 1831193326Sed OO_Comma 1832193326Sed }; 1833193326Sed return OverOps[Opc]; 1834193326Sed} 1835193326Sed 1836263508SdimInitListExpr::InitListExpr(const ASTContext &C, SourceLocation lbraceloc, 1837243830Sdim ArrayRef<Expr*> initExprs, SourceLocation rbraceloc) 1838218893Sdim : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false, 1839224145Sdim false, false), 1840243830Sdim InitExprs(C, initExprs.size()), 1841243830Sdim LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), AltForm(0, true) 1842234353Sdim{ 1843234353Sdim sawArrayRangeDesignator(false); 1844243830Sdim for (unsigned I = 0; I != initExprs.size(); ++I) { 1845199990Srdivacky if (initExprs[I]->isTypeDependent()) 1846218893Sdim ExprBits.TypeDependent = true; 1847199990Srdivacky if (initExprs[I]->isValueDependent()) 1848218893Sdim ExprBits.ValueDependent = true; 1849224145Sdim if (initExprs[I]->isInstantiationDependent()) 1850224145Sdim ExprBits.InstantiationDependent = true; 1851218893Sdim if (initExprs[I]->containsUnexpandedParameterPack()) 1852218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 1853199990Srdivacky } 1854199990Srdivacky 1855243830Sdim InitExprs.insert(C, InitExprs.end(), initExprs.begin(), initExprs.end()); 1856193326Sed} 1857193326Sed 1858263508Sdimvoid InitListExpr::reserveInits(const ASTContext &C, unsigned NumInits) { 1859193326Sed if (NumInits > InitExprs.size()) 1860207619Srdivacky InitExprs.reserve(C, NumInits); 1861193326Sed} 1862193326Sed 1863263508Sdimvoid InitListExpr::resizeInits(const ASTContext &C, unsigned NumInits) { 1864207619Srdivacky InitExprs.resize(C, NumInits, 0); 1865193326Sed} 1866193326Sed 1867263508SdimExpr *InitListExpr::updateInit(const ASTContext &C, unsigned Init, Expr *expr) { 1868193326Sed if (Init >= InitExprs.size()) { 1869207619Srdivacky InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, 0); 1870193326Sed InitExprs.back() = expr; 1871193326Sed return 0; 1872193326Sed } 1873198092Srdivacky 1874193326Sed Expr *Result = cast_or_null<Expr>(InitExprs[Init]); 1875193326Sed InitExprs[Init] = expr; 1876193326Sed return Result; 1877193326Sed} 1878193326Sed 1879221345Sdimvoid InitListExpr::setArrayFiller(Expr *filler) { 1880234353Sdim assert(!hasArrayFiller() && "Filler already set!"); 1881221345Sdim ArrayFillerOrUnionFieldInit = filler; 1882221345Sdim // Fill out any "holes" in the array due to designated initializers. 1883221345Sdim Expr **inits = getInits(); 1884221345Sdim for (unsigned i = 0, e = getNumInits(); i != e; ++i) 1885221345Sdim if (inits[i] == 0) 1886221345Sdim inits[i] = filler; 1887221345Sdim} 1888221345Sdim 1889234982Sdimbool InitListExpr::isStringLiteralInit() const { 1890234982Sdim if (getNumInits() != 1) 1891234982Sdim return false; 1892243830Sdim const ArrayType *AT = getType()->getAsArrayTypeUnsafe(); 1893243830Sdim if (!AT || !AT->getElementType()->isIntegerType()) 1894234982Sdim return false; 1895243830Sdim const Expr *Init = getInit(0)->IgnoreParens(); 1896234982Sdim return isa<StringLiteral>(Init) || isa<ObjCEncodeExpr>(Init); 1897234982Sdim} 1898234982Sdim 1899249423SdimSourceLocation InitListExpr::getLocStart() const { 1900243830Sdim if (InitListExpr *SyntacticForm = getSyntacticForm()) 1901249423Sdim return SyntacticForm->getLocStart(); 1902249423Sdim SourceLocation Beg = LBraceLoc; 1903218893Sdim if (Beg.isInvalid()) { 1904218893Sdim // Find the first non-null initializer. 1905218893Sdim for (InitExprsTy::const_iterator I = InitExprs.begin(), 1906218893Sdim E = InitExprs.end(); 1907218893Sdim I != E; ++I) { 1908218893Sdim if (Stmt *S = *I) { 1909218893Sdim Beg = S->getLocStart(); 1910218893Sdim break; 1911218893Sdim } 1912218893Sdim } 1913218893Sdim } 1914249423Sdim return Beg; 1915249423Sdim} 1916249423Sdim 1917249423SdimSourceLocation InitListExpr::getLocEnd() const { 1918249423Sdim if (InitListExpr *SyntacticForm = getSyntacticForm()) 1919249423Sdim return SyntacticForm->getLocEnd(); 1920249423Sdim SourceLocation End = RBraceLoc; 1921218893Sdim if (End.isInvalid()) { 1922218893Sdim // Find the first non-null initializer from the end. 1923218893Sdim for (InitExprsTy::const_reverse_iterator I = InitExprs.rbegin(), 1924249423Sdim E = InitExprs.rend(); 1925249423Sdim I != E; ++I) { 1926218893Sdim if (Stmt *S = *I) { 1927249423Sdim End = S->getLocEnd(); 1928218893Sdim break; 1929249423Sdim } 1930218893Sdim } 1931218893Sdim } 1932249423Sdim return End; 1933218893Sdim} 1934218893Sdim 1935193326Sed/// getFunctionType - Return the underlying function type for this block. 1936193326Sed/// 1937234353Sdimconst FunctionProtoType *BlockExpr::getFunctionType() const { 1938234353Sdim // The block pointer is never sugared, but the function type might be. 1939234353Sdim return cast<BlockPointerType>(getType()) 1940234353Sdim ->getPointeeType()->castAs<FunctionProtoType>(); 1941193326Sed} 1942193326Sed 1943198092SrdivackySourceLocation BlockExpr::getCaretLocation() const { 1944198092Srdivacky return TheBlock->getCaretLocation(); 1945193326Sed} 1946198092Srdivackyconst Stmt *BlockExpr::getBody() const { 1947193326Sed return TheBlock->getBody(); 1948193326Sed} 1949198092SrdivackyStmt *BlockExpr::getBody() { 1950198092Srdivacky return TheBlock->getBody(); 1951193326Sed} 1952193326Sed 1953193326Sed 1954193326Sed//===----------------------------------------------------------------------===// 1955193326Sed// Generic Expression Routines 1956193326Sed//===----------------------------------------------------------------------===// 1957193326Sed 1958193326Sed/// isUnusedResultAWarning - Return true if this immediate expression should 1959193326Sed/// be warned about if the result is unused. If so, fill in Loc and Ranges 1960193326Sed/// with location to warn on and the source range[s] to report with the 1961193326Sed/// warning. 1962239462Sdimbool Expr::isUnusedResultAWarning(const Expr *&WarnE, SourceLocation &Loc, 1963239462Sdim SourceRange &R1, SourceRange &R2, 1964239462Sdim ASTContext &Ctx) const { 1965193326Sed // Don't warn if the expr is type dependent. The type could end up 1966193326Sed // instantiating to void. 1967193326Sed if (isTypeDependent()) 1968193326Sed return false; 1969198092Srdivacky 1970193326Sed switch (getStmtClass()) { 1971193326Sed default: 1972205219Srdivacky if (getType()->isVoidType()) 1973205219Srdivacky return false; 1974239462Sdim WarnE = this; 1975193326Sed Loc = getExprLoc(); 1976193326Sed R1 = getSourceRange(); 1977193326Sed return true; 1978193326Sed case ParenExprClass: 1979193326Sed return cast<ParenExpr>(this)->getSubExpr()-> 1980239462Sdim isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 1981221345Sdim case GenericSelectionExprClass: 1982221345Sdim return cast<GenericSelectionExpr>(this)->getResultExpr()-> 1983239462Sdim isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 1984263508Sdim case ChooseExprClass: 1985263508Sdim return cast<ChooseExpr>(this)->getChosenSubExpr()-> 1986263508Sdim isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 1987193326Sed case UnaryOperatorClass: { 1988193326Sed const UnaryOperator *UO = cast<UnaryOperator>(this); 1989198092Srdivacky 1990193326Sed switch (UO->getOpcode()) { 1991239462Sdim case UO_Plus: 1992239462Sdim case UO_Minus: 1993239462Sdim case UO_AddrOf: 1994239462Sdim case UO_Not: 1995239462Sdim case UO_LNot: 1996239462Sdim case UO_Deref: 1997239462Sdim break; 1998212904Sdim case UO_PostInc: 1999212904Sdim case UO_PostDec: 2000212904Sdim case UO_PreInc: 2001212904Sdim case UO_PreDec: // ++/-- 2002193326Sed return false; // Not a warning. 2003212904Sdim case UO_Real: 2004212904Sdim case UO_Imag: 2005193326Sed // accessing a piece of a volatile complex is a side-effect. 2006198893Srdivacky if (Ctx.getCanonicalType(UO->getSubExpr()->getType()) 2007198893Srdivacky .isVolatileQualified()) 2008193326Sed return false; 2009193326Sed break; 2010212904Sdim case UO_Extension: 2011239462Sdim return UO->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2012193326Sed } 2013239462Sdim WarnE = this; 2014193326Sed Loc = UO->getOperatorLoc(); 2015193326Sed R1 = UO->getSubExpr()->getSourceRange(); 2016193326Sed return true; 2017193326Sed } 2018193326Sed case BinaryOperatorClass: { 2019193326Sed const BinaryOperator *BO = cast<BinaryOperator>(this); 2020207619Srdivacky switch (BO->getOpcode()) { 2021207619Srdivacky default: 2022207619Srdivacky break; 2023210299Sed // Consider the RHS of comma for side effects. LHS was checked by 2024210299Sed // Sema::CheckCommaOperands. 2025212904Sdim case BO_Comma: 2026207619Srdivacky // ((foo = <blah>), 0) is an idiom for hiding the result (and 2027207619Srdivacky // lvalue-ness) of an assignment written in a macro. 2028207619Srdivacky if (IntegerLiteral *IE = 2029207619Srdivacky dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens())) 2030207619Srdivacky if (IE->getValue() == 0) 2031207619Srdivacky return false; 2032239462Sdim return BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2033210299Sed // Consider '||', '&&' to have side effects if the LHS or RHS does. 2034212904Sdim case BO_LAnd: 2035212904Sdim case BO_LOr: 2036239462Sdim if (!BO->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) || 2037239462Sdim !BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)) 2038210299Sed return false; 2039210299Sed break; 2040203955Srdivacky } 2041193326Sed if (BO->isAssignmentOp()) 2042193326Sed return false; 2043239462Sdim WarnE = this; 2044193326Sed Loc = BO->getOperatorLoc(); 2045193326Sed R1 = BO->getLHS()->getSourceRange(); 2046193326Sed R2 = BO->getRHS()->getSourceRange(); 2047193326Sed return true; 2048193326Sed } 2049193326Sed case CompoundAssignOperatorClass: 2050208600Srdivacky case VAArgExprClass: 2051226633Sdim case AtomicExprClass: 2052193326Sed return false; 2053193326Sed 2054193326Sed case ConditionalOperatorClass: { 2055221345Sdim // If only one of the LHS or RHS is a warning, the operator might 2056221345Sdim // be being used for control flow. Only warn if both the LHS and 2057221345Sdim // RHS are warnings. 2058193326Sed const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 2059239462Sdim if (!Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)) 2060221345Sdim return false; 2061221345Sdim if (!Exp->getLHS()) 2062193326Sed return true; 2063239462Sdim return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2064193326Sed } 2065193326Sed 2066193326Sed case MemberExprClass: 2067239462Sdim WarnE = this; 2068193326Sed Loc = cast<MemberExpr>(this)->getMemberLoc(); 2069193326Sed R1 = SourceRange(Loc, Loc); 2070193326Sed R2 = cast<MemberExpr>(this)->getBase()->getSourceRange(); 2071193326Sed return true; 2072198092Srdivacky 2073193326Sed case ArraySubscriptExprClass: 2074239462Sdim WarnE = this; 2075193326Sed Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc(); 2076193326Sed R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange(); 2077193326Sed R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange(); 2078193326Sed return true; 2079193326Sed 2080226633Sdim case CXXOperatorCallExprClass: { 2081226633Sdim // We warn about operator== and operator!= even when user-defined operator 2082226633Sdim // overloads as there is no reasonable way to define these such that they 2083226633Sdim // have non-trivial, desirable side-effects. See the -Wunused-comparison 2084226633Sdim // warning: these operators are commonly typo'ed, and so warning on them 2085226633Sdim // provides additional value as well. If this list is updated, 2086226633Sdim // DiagnoseUnusedComparison should be as well. 2087226633Sdim const CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(this); 2088226633Sdim if (Op->getOperator() == OO_EqualEqual || 2089226633Sdim Op->getOperator() == OO_ExclaimEqual) { 2090239462Sdim WarnE = this; 2091226633Sdim Loc = Op->getOperatorLoc(); 2092226633Sdim R1 = Op->getSourceRange(); 2093226633Sdim return true; 2094226633Sdim } 2095226633Sdim 2096226633Sdim // Fallthrough for generic call handling. 2097226633Sdim } 2098193326Sed case CallExprClass: 2099234353Sdim case CXXMemberCallExprClass: 2100234353Sdim case UserDefinedLiteralClass: { 2101193326Sed // If this is a direct call, get the callee. 2102193326Sed const CallExpr *CE = cast<CallExpr>(this); 2103201361Srdivacky if (const Decl *FD = CE->getCalleeDecl()) { 2104193326Sed // If the callee has attribute pure, const, or warn_unused_result, warn 2105193326Sed // about it. void foo() { strlen("bar"); } should warn. 2106198092Srdivacky // 2107198092Srdivacky // Note: If new cases are added here, DiagnoseUnusedExprResult should be 2108198092Srdivacky // updated to match for QoI. 2109198092Srdivacky if (FD->getAttr<WarnUnusedResultAttr>() || 2110198092Srdivacky FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) { 2111239462Sdim WarnE = this; 2112198092Srdivacky Loc = CE->getCallee()->getLocStart(); 2113198092Srdivacky R1 = CE->getCallee()->getSourceRange(); 2114198092Srdivacky 2115198092Srdivacky if (unsigned NumArgs = CE->getNumArgs()) 2116198092Srdivacky R2 = SourceRange(CE->getArg(0)->getLocStart(), 2117198092Srdivacky CE->getArg(NumArgs-1)->getLocEnd()); 2118198092Srdivacky return true; 2119198092Srdivacky } 2120193326Sed } 2121193326Sed return false; 2122193326Sed } 2123199482Srdivacky 2124243830Sdim // If we don't know precisely what we're looking at, let's not warn. 2125243830Sdim case UnresolvedLookupExprClass: 2126243830Sdim case CXXUnresolvedConstructExprClass: 2127243830Sdim return false; 2128243830Sdim 2129199482Srdivacky case CXXTemporaryObjectExprClass: 2130263508Sdim case CXXConstructExprClass: { 2131263508Sdim if (const CXXRecordDecl *Type = getType()->getAsCXXRecordDecl()) { 2132263508Sdim if (Type->hasAttr<WarnUnusedAttr>()) { 2133263508Sdim WarnE = this; 2134263508Sdim Loc = getLocStart(); 2135263508Sdim R1 = getSourceRange(); 2136263508Sdim return true; 2137263508Sdim } 2138263508Sdim } 2139199482Srdivacky return false; 2140263508Sdim } 2141199482Srdivacky 2142206084Srdivacky case ObjCMessageExprClass: { 2143206084Srdivacky const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this); 2144234353Sdim if (Ctx.getLangOpts().ObjCAutoRefCount && 2145224145Sdim ME->isInstanceMessage() && 2146224145Sdim !ME->getType()->isVoidType() && 2147263508Sdim ME->getMethodFamily() == OMF_init) { 2148239462Sdim WarnE = this; 2149224145Sdim Loc = getExprLoc(); 2150224145Sdim R1 = ME->getSourceRange(); 2151224145Sdim return true; 2152224145Sdim } 2153224145Sdim 2154206084Srdivacky const ObjCMethodDecl *MD = ME->getMethodDecl(); 2155206084Srdivacky if (MD && MD->getAttr<WarnUnusedResultAttr>()) { 2156239462Sdim WarnE = this; 2157206084Srdivacky Loc = getExprLoc(); 2158206084Srdivacky return true; 2159206084Srdivacky } 2160193326Sed return false; 2161206084Srdivacky } 2162198092Srdivacky 2163218893Sdim case ObjCPropertyRefExprClass: 2164239462Sdim WarnE = this; 2165198092Srdivacky Loc = getExprLoc(); 2166198092Srdivacky R1 = getSourceRange(); 2167198092Srdivacky return true; 2168218893Sdim 2169234353Sdim case PseudoObjectExprClass: { 2170234353Sdim const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this); 2171234353Sdim 2172234353Sdim // Only complain about things that have the form of a getter. 2173234353Sdim if (isa<UnaryOperator>(PO->getSyntacticForm()) || 2174234353Sdim isa<BinaryOperator>(PO->getSyntacticForm())) 2175234353Sdim return false; 2176234353Sdim 2177239462Sdim WarnE = this; 2178234353Sdim Loc = getExprLoc(); 2179234353Sdim R1 = getSourceRange(); 2180234353Sdim return true; 2181234353Sdim } 2182234353Sdim 2183193326Sed case StmtExprClass: { 2184193326Sed // Statement exprs don't logically have side effects themselves, but are 2185193326Sed // sometimes used in macros in ways that give them a type that is unused. 2186193326Sed // For example ({ blah; foo(); }) will end up with a type if foo has a type. 2187193326Sed // however, if the result of the stmt expr is dead, we don't want to emit a 2188193326Sed // warning. 2189193326Sed const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 2190218893Sdim if (!CS->body_empty()) { 2191193326Sed if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 2192239462Sdim return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2193218893Sdim if (const LabelStmt *Label = dyn_cast<LabelStmt>(CS->body_back())) 2194218893Sdim if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt())) 2195239462Sdim return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2196218893Sdim } 2197198092Srdivacky 2198205219Srdivacky if (getType()->isVoidType()) 2199205219Srdivacky return false; 2200239462Sdim WarnE = this; 2201193326Sed Loc = cast<StmtExpr>(this)->getLParenLoc(); 2202193326Sed R1 = getSourceRange(); 2203193326Sed return true; 2204193326Sed } 2205243830Sdim case CXXFunctionalCastExprClass: 2206239462Sdim case CStyleCastExprClass: { 2207239462Sdim // Ignore an explicit cast to void unless the operand is a non-trivial 2208239462Sdim // volatile lvalue. 2209239462Sdim const CastExpr *CE = cast<CastExpr>(this); 2210239462Sdim if (CE->getCastKind() == CK_ToVoid) { 2211239462Sdim if (CE->getSubExpr()->isGLValue() && 2212239462Sdim CE->getSubExpr()->getType().isVolatileQualified()) { 2213239462Sdim const DeclRefExpr *DRE = 2214239462Sdim dyn_cast<DeclRefExpr>(CE->getSubExpr()->IgnoreParens()); 2215239462Sdim if (!(DRE && isa<VarDecl>(DRE->getDecl()) && 2216239462Sdim cast<VarDecl>(DRE->getDecl())->hasLocalStorage())) { 2217239462Sdim return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, 2218239462Sdim R1, R2, Ctx); 2219239462Sdim } 2220239462Sdim } 2221198092Srdivacky return false; 2222239462Sdim } 2223239462Sdim 2224239462Sdim // If this is a cast to a constructor conversion, check the operand. 2225199482Srdivacky // Otherwise, the result of the cast is unused. 2226239462Sdim if (CE->getCastKind() == CK_ConstructorConversion) 2227239462Sdim return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2228239462Sdim 2229239462Sdim WarnE = this; 2230239462Sdim if (const CXXFunctionalCastExpr *CXXCE = 2231239462Sdim dyn_cast<CXXFunctionalCastExpr>(this)) { 2232263508Sdim Loc = CXXCE->getLocStart(); 2233239462Sdim R1 = CXXCE->getSubExpr()->getSourceRange(); 2234239462Sdim } else { 2235239462Sdim const CStyleCastExpr *CStyleCE = cast<CStyleCastExpr>(this); 2236239462Sdim Loc = CStyleCE->getLParenLoc(); 2237239462Sdim R1 = CStyleCE->getSubExpr()->getSourceRange(); 2238239462Sdim } 2239193326Sed return true; 2240199482Srdivacky } 2241239462Sdim case ImplicitCastExprClass: { 2242239462Sdim const CastExpr *ICE = cast<ImplicitCastExpr>(this); 2243198092Srdivacky 2244239462Sdim // lvalue-to-rvalue conversion on a volatile lvalue is a side-effect. 2245239462Sdim if (ICE->getCastKind() == CK_LValueToRValue && 2246239462Sdim ICE->getSubExpr()->getType().isVolatileQualified()) 2247239462Sdim return false; 2248193326Sed 2249239462Sdim return ICE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx); 2250239462Sdim } 2251193326Sed case CXXDefaultArgExprClass: 2252198893Srdivacky return (cast<CXXDefaultArgExpr>(this) 2253239462Sdim ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2254251662Sdim case CXXDefaultInitExprClass: 2255251662Sdim return (cast<CXXDefaultInitExpr>(this) 2256251662Sdim ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2257193326Sed 2258193326Sed case CXXNewExprClass: 2259193326Sed // FIXME: In theory, there might be new expressions that don't have side 2260193326Sed // effects (e.g. a placement new with an uninitialized POD). 2261193326Sed case CXXDeleteExprClass: 2262193326Sed return false; 2263198092Srdivacky case CXXBindTemporaryExprClass: 2264198893Srdivacky return (cast<CXXBindTemporaryExpr>(this) 2265239462Sdim ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2266218893Sdim case ExprWithCleanupsClass: 2267218893Sdim return (cast<ExprWithCleanups>(this) 2268239462Sdim ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx)); 2269193326Sed } 2270193326Sed} 2271193326Sed 2272193326Sed/// isOBJCGCCandidate - Check if an expression is objc gc'able. 2273198092Srdivacky/// returns true, if it is; false otherwise. 2274193326Sedbool Expr::isOBJCGCCandidate(ASTContext &Ctx) const { 2275221345Sdim const Expr *E = IgnoreParens(); 2276221345Sdim switch (E->getStmtClass()) { 2277193326Sed default: 2278193326Sed return false; 2279193326Sed case ObjCIvarRefExprClass: 2280193326Sed return true; 2281193326Sed case Expr::UnaryOperatorClass: 2282221345Sdim return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx); 2283193326Sed case ImplicitCastExprClass: 2284221345Sdim return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx); 2285224145Sdim case MaterializeTemporaryExprClass: 2286224145Sdim return cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr() 2287224145Sdim ->isOBJCGCCandidate(Ctx); 2288193326Sed case CStyleCastExprClass: 2289221345Sdim return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx); 2290198893Srdivacky case DeclRefExprClass: { 2291234353Sdim const Decl *D = cast<DeclRefExpr>(E)->getDecl(); 2292226633Sdim 2293193326Sed if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 2294193326Sed if (VD->hasGlobalStorage()) 2295193326Sed return true; 2296193326Sed QualType T = VD->getType(); 2297198092Srdivacky // dereferencing to a pointer is always a gc'able candidate, 2298198092Srdivacky // unless it is __weak. 2299198092Srdivacky return T->isPointerType() && 2300198092Srdivacky (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak); 2301193326Sed } 2302193326Sed return false; 2303193326Sed } 2304193326Sed case MemberExprClass: { 2305221345Sdim const MemberExpr *M = cast<MemberExpr>(E); 2306193326Sed return M->getBase()->isOBJCGCCandidate(Ctx); 2307193326Sed } 2308193326Sed case ArraySubscriptExprClass: 2309221345Sdim return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx); 2310193326Sed } 2311193326Sed} 2312218893Sdim 2313218893Sdimbool Expr::isBoundMemberFunction(ASTContext &Ctx) const { 2314218893Sdim if (isTypeDependent()) 2315218893Sdim return false; 2316218893Sdim return ClassifyLValue(Ctx) == Expr::LV_MemberFunction; 2317218893Sdim} 2318218893Sdim 2319221345SdimQualType Expr::findBoundMemberType(const Expr *expr) { 2320234353Sdim assert(expr->hasPlaceholderType(BuiltinType::BoundMember)); 2321221345Sdim 2322221345Sdim // Bound member expressions are always one of these possibilities: 2323221345Sdim // x->m x.m x->*y x.*y 2324221345Sdim // (possibly parenthesized) 2325221345Sdim 2326221345Sdim expr = expr->IgnoreParens(); 2327221345Sdim if (const MemberExpr *mem = dyn_cast<MemberExpr>(expr)) { 2328221345Sdim assert(isa<CXXMethodDecl>(mem->getMemberDecl())); 2329221345Sdim return mem->getMemberDecl()->getType(); 2330221345Sdim } 2331221345Sdim 2332221345Sdim if (const BinaryOperator *op = dyn_cast<BinaryOperator>(expr)) { 2333221345Sdim QualType type = op->getRHS()->getType()->castAs<MemberPointerType>() 2334221345Sdim ->getPointeeType(); 2335221345Sdim assert(type->isFunctionType()); 2336221345Sdim return type; 2337221345Sdim } 2338221345Sdim 2339221345Sdim assert(isa<UnresolvedMemberExpr>(expr)); 2340221345Sdim return QualType(); 2341221345Sdim} 2342221345Sdim 2343193326SedExpr* Expr::IgnoreParens() { 2344193326Sed Expr* E = this; 2345218893Sdim while (true) { 2346218893Sdim if (ParenExpr* P = dyn_cast<ParenExpr>(E)) { 2347218893Sdim E = P->getSubExpr(); 2348218893Sdim continue; 2349218893Sdim } 2350218893Sdim if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) { 2351218893Sdim if (P->getOpcode() == UO_Extension) { 2352218893Sdim E = P->getSubExpr(); 2353218893Sdim continue; 2354218893Sdim } 2355218893Sdim } 2356221345Sdim if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) { 2357221345Sdim if (!P->isResultDependent()) { 2358221345Sdim E = P->getResultExpr(); 2359221345Sdim continue; 2360221345Sdim } 2361221345Sdim } 2362263508Sdim if (ChooseExpr* P = dyn_cast<ChooseExpr>(E)) { 2363263508Sdim if (!P->isConditionDependent()) { 2364263508Sdim E = P->getChosenSubExpr(); 2365263508Sdim continue; 2366263508Sdim } 2367263508Sdim } 2368218893Sdim return E; 2369218893Sdim } 2370193326Sed} 2371193326Sed 2372193326Sed/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 2373193326Sed/// or CastExprs or ImplicitCastExprs, returning their operand. 2374193326SedExpr *Expr::IgnoreParenCasts() { 2375193326Sed Expr *E = this; 2376193326Sed while (true) { 2377263508Sdim E = E->IgnoreParens(); 2378218893Sdim if (CastExpr *P = dyn_cast<CastExpr>(E)) { 2379193326Sed E = P->getSubExpr(); 2380218893Sdim continue; 2381218893Sdim } 2382224145Sdim if (MaterializeTemporaryExpr *Materialize 2383224145Sdim = dyn_cast<MaterializeTemporaryExpr>(E)) { 2384224145Sdim E = Materialize->GetTemporaryExpr(); 2385224145Sdim continue; 2386224145Sdim } 2387226633Sdim if (SubstNonTypeTemplateParmExpr *NTTP 2388226633Sdim = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2389226633Sdim E = NTTP->getReplacement(); 2390226633Sdim continue; 2391226633Sdim } 2392218893Sdim return E; 2393193326Sed } 2394193326Sed} 2395193326Sed 2396218893Sdim/// IgnoreParenLValueCasts - Ignore parentheses and lvalue-to-rvalue 2397218893Sdim/// casts. This is intended purely as a temporary workaround for code 2398218893Sdim/// that hasn't yet been rewritten to do the right thing about those 2399218893Sdim/// casts, and may disappear along with the last internal use. 2400218893SdimExpr *Expr::IgnoreParenLValueCasts() { 2401218893Sdim Expr *E = this; 2402218893Sdim while (true) { 2403263508Sdim E = E->IgnoreParens(); 2404263508Sdim if (CastExpr *P = dyn_cast<CastExpr>(E)) { 2405218893Sdim if (P->getCastKind() == CK_LValueToRValue) { 2406218893Sdim E = P->getSubExpr(); 2407218893Sdim continue; 2408218893Sdim } 2409224145Sdim } else if (MaterializeTemporaryExpr *Materialize 2410224145Sdim = dyn_cast<MaterializeTemporaryExpr>(E)) { 2411224145Sdim E = Materialize->GetTemporaryExpr(); 2412224145Sdim continue; 2413226633Sdim } else if (SubstNonTypeTemplateParmExpr *NTTP 2414226633Sdim = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2415226633Sdim E = NTTP->getReplacement(); 2416226633Sdim continue; 2417218893Sdim } 2418218893Sdim break; 2419218893Sdim } 2420218893Sdim return E; 2421218893Sdim} 2422239462Sdim 2423239462SdimExpr *Expr::ignoreParenBaseCasts() { 2424239462Sdim Expr *E = this; 2425239462Sdim while (true) { 2426263508Sdim E = E->IgnoreParens(); 2427239462Sdim if (CastExpr *CE = dyn_cast<CastExpr>(E)) { 2428239462Sdim if (CE->getCastKind() == CK_DerivedToBase || 2429239462Sdim CE->getCastKind() == CK_UncheckedDerivedToBase || 2430239462Sdim CE->getCastKind() == CK_NoOp) { 2431239462Sdim E = CE->getSubExpr(); 2432239462Sdim continue; 2433239462Sdim } 2434239462Sdim } 2435239462Sdim 2436239462Sdim return E; 2437239462Sdim } 2438239462Sdim} 2439239462Sdim 2440208600SrdivackyExpr *Expr::IgnoreParenImpCasts() { 2441208600Srdivacky Expr *E = this; 2442208600Srdivacky while (true) { 2443263508Sdim E = E->IgnoreParens(); 2444218893Sdim if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) { 2445208600Srdivacky E = P->getSubExpr(); 2446218893Sdim continue; 2447218893Sdim } 2448224145Sdim if (MaterializeTemporaryExpr *Materialize 2449224145Sdim = dyn_cast<MaterializeTemporaryExpr>(E)) { 2450224145Sdim E = Materialize->GetTemporaryExpr(); 2451224145Sdim continue; 2452224145Sdim } 2453226633Sdim if (SubstNonTypeTemplateParmExpr *NTTP 2454226633Sdim = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2455226633Sdim E = NTTP->getReplacement(); 2456226633Sdim continue; 2457226633Sdim } 2458218893Sdim return E; 2459208600Srdivacky } 2460208600Srdivacky} 2461208600Srdivacky 2462223017SdimExpr *Expr::IgnoreConversionOperator() { 2463223017Sdim if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(this)) { 2464224145Sdim if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl())) 2465223017Sdim return MCE->getImplicitObjectArgument(); 2466223017Sdim } 2467223017Sdim return this; 2468223017Sdim} 2469223017Sdim 2470193326Sed/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the 2471193326Sed/// value (including ptr->int casts of the same size). Strip off any 2472193326Sed/// ParenExpr or CastExprs, returning their operand. 2473193326SedExpr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) { 2474193326Sed Expr *E = this; 2475193326Sed while (true) { 2476263508Sdim E = E->IgnoreParens(); 2477198092Srdivacky 2478193326Sed if (CastExpr *P = dyn_cast<CastExpr>(E)) { 2479193326Sed // We ignore integer <-> casts that are of the same width, ptr<->ptr and 2480210299Sed // ptr<->int casts of the same width. We also ignore all identity casts. 2481193326Sed Expr *SE = P->getSubExpr(); 2482198092Srdivacky 2483193326Sed if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) { 2484193326Sed E = SE; 2485193326Sed continue; 2486193326Sed } 2487198092Srdivacky 2488218893Sdim if ((E->getType()->isPointerType() || 2489210299Sed E->getType()->isIntegralType(Ctx)) && 2490218893Sdim (SE->getType()->isPointerType() || 2491210299Sed SE->getType()->isIntegralType(Ctx)) && 2492193326Sed Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) { 2493193326Sed E = SE; 2494193326Sed continue; 2495193326Sed } 2496193326Sed } 2497198092Srdivacky 2498226633Sdim if (SubstNonTypeTemplateParmExpr *NTTP 2499226633Sdim = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) { 2500226633Sdim E = NTTP->getReplacement(); 2501226633Sdim continue; 2502226633Sdim } 2503226633Sdim 2504193326Sed return E; 2505193326Sed } 2506193326Sed} 2507193326Sed 2508200583Srdivackybool Expr::isDefaultArgument() const { 2509200583Srdivacky const Expr *E = this; 2510224145Sdim if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E)) 2511224145Sdim E = M->GetTemporaryExpr(); 2512224145Sdim 2513200583Srdivacky while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 2514200583Srdivacky E = ICE->getSubExprAsWritten(); 2515200583Srdivacky 2516200583Srdivacky return isa<CXXDefaultArgExpr>(E); 2517200583Srdivacky} 2518193326Sed 2519206125Srdivacky/// \brief Skip over any no-op casts and any temporary-binding 2520206125Srdivacky/// expressions. 2521218893Sdimstatic const Expr *skipTemporaryBindingsNoOpCastsAndParens(const Expr *E) { 2522224145Sdim if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E)) 2523224145Sdim E = M->GetTemporaryExpr(); 2524224145Sdim 2525206125Srdivacky while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 2526212904Sdim if (ICE->getCastKind() == CK_NoOp) 2527206125Srdivacky E = ICE->getSubExpr(); 2528206125Srdivacky else 2529206125Srdivacky break; 2530206125Srdivacky } 2531206125Srdivacky 2532206125Srdivacky while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E)) 2533206125Srdivacky E = BE->getSubExpr(); 2534206125Srdivacky 2535206125Srdivacky while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 2536212904Sdim if (ICE->getCastKind() == CK_NoOp) 2537206125Srdivacky E = ICE->getSubExpr(); 2538206125Srdivacky else 2539206125Srdivacky break; 2540206125Srdivacky } 2541218893Sdim 2542218893Sdim return E->IgnoreParens(); 2543206125Srdivacky} 2544206125Srdivacky 2545218893Sdim/// isTemporaryObject - Determines if this expression produces a 2546218893Sdim/// temporary of the given class type. 2547218893Sdimbool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const { 2548218893Sdim if (!C.hasSameUnqualifiedType(getType(), C.getTypeDeclType(TempTy))) 2549218893Sdim return false; 2550206125Srdivacky 2551218893Sdim const Expr *E = skipTemporaryBindingsNoOpCastsAndParens(this); 2552206125Srdivacky 2553218893Sdim // Temporaries are by definition pr-values of class type. 2554218893Sdim if (!E->Classify(C).isPRValue()) { 2555218893Sdim // In this context, property reference is a message call and is pr-value. 2556218893Sdim if (!isa<ObjCPropertyRefExpr>(E)) 2557218893Sdim return false; 2558218893Sdim } 2559206125Srdivacky 2560218893Sdim // Black-list a few cases which yield pr-values of class type that don't 2561218893Sdim // refer to temporaries of that type: 2562206125Srdivacky 2563218893Sdim // - implicit derived-to-base conversions 2564218893Sdim if (isa<ImplicitCastExpr>(E)) { 2565218893Sdim switch (cast<ImplicitCastExpr>(E)->getCastKind()) { 2566218893Sdim case CK_DerivedToBase: 2567218893Sdim case CK_UncheckedDerivedToBase: 2568218893Sdim return false; 2569218893Sdim default: 2570218893Sdim break; 2571218893Sdim } 2572206125Srdivacky } 2573206125Srdivacky 2574218893Sdim // - member expressions (all) 2575218893Sdim if (isa<MemberExpr>(E)) 2576218893Sdim return false; 2577206125Srdivacky 2578239462Sdim if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) 2579239462Sdim if (BO->isPtrMemOp()) 2580239462Sdim return false; 2581239462Sdim 2582218893Sdim // - opaque values (all) 2583218893Sdim if (isa<OpaqueValueExpr>(E)) 2584218893Sdim return false; 2585206125Srdivacky 2586218893Sdim return true; 2587206125Srdivacky} 2588206125Srdivacky 2589221345Sdimbool Expr::isImplicitCXXThis() const { 2590221345Sdim const Expr *E = this; 2591221345Sdim 2592221345Sdim // Strip away parentheses and casts we don't care about. 2593221345Sdim while (true) { 2594221345Sdim if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) { 2595221345Sdim E = Paren->getSubExpr(); 2596221345Sdim continue; 2597221345Sdim } 2598221345Sdim 2599221345Sdim if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 2600221345Sdim if (ICE->getCastKind() == CK_NoOp || 2601221345Sdim ICE->getCastKind() == CK_LValueToRValue || 2602221345Sdim ICE->getCastKind() == CK_DerivedToBase || 2603221345Sdim ICE->getCastKind() == CK_UncheckedDerivedToBase) { 2604221345Sdim E = ICE->getSubExpr(); 2605221345Sdim continue; 2606221345Sdim } 2607221345Sdim } 2608221345Sdim 2609221345Sdim if (const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) { 2610221345Sdim if (UnOp->getOpcode() == UO_Extension) { 2611221345Sdim E = UnOp->getSubExpr(); 2612221345Sdim continue; 2613221345Sdim } 2614221345Sdim } 2615221345Sdim 2616224145Sdim if (const MaterializeTemporaryExpr *M 2617224145Sdim = dyn_cast<MaterializeTemporaryExpr>(E)) { 2618224145Sdim E = M->GetTemporaryExpr(); 2619224145Sdim continue; 2620224145Sdim } 2621224145Sdim 2622221345Sdim break; 2623221345Sdim } 2624221345Sdim 2625221345Sdim if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E)) 2626221345Sdim return This->isImplicit(); 2627221345Sdim 2628221345Sdim return false; 2629221345Sdim} 2630221345Sdim 2631193326Sed/// hasAnyTypeDependentArguments - Determines if any of the expressions 2632193326Sed/// in Exprs is type-dependent. 2633249423Sdimbool Expr::hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs) { 2634234353Sdim for (unsigned I = 0; I < Exprs.size(); ++I) 2635193326Sed if (Exprs[I]->isTypeDependent()) 2636193326Sed return true; 2637193326Sed 2638193326Sed return false; 2639193326Sed} 2640193326Sed 2641212904Sdimbool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef) const { 2642193326Sed // This function is attempting whether an expression is an initializer 2643263508Sdim // which can be evaluated at compile-time. It very closely parallels 2644263508Sdim // ConstExprEmitter in CGExprConstant.cpp; if they don't match, it 2645263508Sdim // will lead to unexpected results. Like ConstExprEmitter, it falls back 2646263508Sdim // to isEvaluatable most of the time. 2647263508Sdim // 2648212904Sdim // If we ever capture reference-binding directly in the AST, we can 2649212904Sdim // kill the second parameter. 2650193326Sed 2651212904Sdim if (IsForRef) { 2652212904Sdim EvalResult Result; 2653212904Sdim return EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects; 2654212904Sdim } 2655212904Sdim 2656193326Sed switch (getStmtClass()) { 2657193326Sed default: break; 2658193326Sed case StringLiteralClass: 2659193326Sed case ObjCEncodeExprClass: 2660193326Sed return true; 2661212904Sdim case CXXTemporaryObjectExprClass: 2662212904Sdim case CXXConstructExprClass: { 2663212904Sdim const CXXConstructExpr *CE = cast<CXXConstructExpr>(this); 2664212904Sdim 2665263508Sdim if (CE->getConstructor()->isTrivial() && 2666263508Sdim CE->getConstructor()->getParent()->hasTrivialDestructor()) { 2667263508Sdim // Trivial default constructor 2668234353Sdim if (!CE->getNumArgs()) return true; 2669212904Sdim 2670263508Sdim // Trivial copy constructor 2671263508Sdim assert(CE->getNumArgs() == 1 && "trivial ctor with > 1 argument"); 2672263508Sdim return CE->getArg(0)->isConstantInitializer(Ctx, false); 2673234353Sdim } 2674234353Sdim 2675234353Sdim break; 2676212904Sdim } 2677193326Sed case CompoundLiteralExprClass: { 2678193326Sed // This handles gcc's extension that allows global initializers like 2679193326Sed // "struct x {int x;} x = (struct x) {};". 2680193326Sed // FIXME: This accepts other cases it shouldn't! 2681193326Sed const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer(); 2682212904Sdim return Exp->isConstantInitializer(Ctx, false); 2683193326Sed } 2684193326Sed case InitListExprClass: { 2685263508Sdim const InitListExpr *ILE = cast<InitListExpr>(this); 2686263508Sdim if (ILE->getType()->isArrayType()) { 2687263508Sdim unsigned numInits = ILE->getNumInits(); 2688263508Sdim for (unsigned i = 0; i < numInits; i++) { 2689263508Sdim if (!ILE->getInit(i)->isConstantInitializer(Ctx, false)) 2690263508Sdim return false; 2691263508Sdim } 2692263508Sdim return true; 2693193326Sed } 2694263508Sdim 2695263508Sdim if (ILE->getType()->isRecordType()) { 2696263508Sdim unsigned ElementNo = 0; 2697263508Sdim RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl(); 2698263508Sdim for (RecordDecl::field_iterator Field = RD->field_begin(), 2699263508Sdim FieldEnd = RD->field_end(); Field != FieldEnd; ++Field) { 2700263508Sdim // If this is a union, skip all the fields that aren't being initialized. 2701263508Sdim if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field) 2702263508Sdim continue; 2703263508Sdim 2704263508Sdim // Don't emit anonymous bitfields, they just affect layout. 2705263508Sdim if (Field->isUnnamedBitfield()) 2706263508Sdim continue; 2707263508Sdim 2708263508Sdim if (ElementNo < ILE->getNumInits()) { 2709263508Sdim const Expr *Elt = ILE->getInit(ElementNo++); 2710263508Sdim if (Field->isBitField()) { 2711263508Sdim // Bitfields have to evaluate to an integer. 2712263508Sdim llvm::APSInt ResultTmp; 2713263508Sdim if (!Elt->EvaluateAsInt(ResultTmp, Ctx)) 2714263508Sdim return false; 2715263508Sdim } else { 2716263508Sdim bool RefType = Field->getType()->isReferenceType(); 2717263508Sdim if (!Elt->isConstantInitializer(Ctx, RefType)) 2718263508Sdim return false; 2719263508Sdim } 2720263508Sdim } 2721263508Sdim } 2722263508Sdim return true; 2723263508Sdim } 2724263508Sdim 2725263508Sdim break; 2726193326Sed } 2727193326Sed case ImplicitValueInitExprClass: 2728193326Sed return true; 2729198092Srdivacky case ParenExprClass: 2730212904Sdim return cast<ParenExpr>(this)->getSubExpr() 2731212904Sdim ->isConstantInitializer(Ctx, IsForRef); 2732221345Sdim case GenericSelectionExprClass: 2733221345Sdim return cast<GenericSelectionExpr>(this)->getResultExpr() 2734221345Sdim ->isConstantInitializer(Ctx, IsForRef); 2735218893Sdim case ChooseExprClass: 2736263508Sdim if (cast<ChooseExpr>(this)->isConditionDependent()) 2737263508Sdim return false; 2738263508Sdim return cast<ChooseExpr>(this)->getChosenSubExpr() 2739218893Sdim ->isConstantInitializer(Ctx, IsForRef); 2740193326Sed case UnaryOperatorClass: { 2741193326Sed const UnaryOperator* Exp = cast<UnaryOperator>(this); 2742212904Sdim if (Exp->getOpcode() == UO_Extension) 2743212904Sdim return Exp->getSubExpr()->isConstantInitializer(Ctx, false); 2744193326Sed break; 2745193326Sed } 2746212904Sdim case CXXFunctionalCastExprClass: 2747212904Sdim case CXXStaticCastExprClass: 2748193326Sed case ImplicitCastExprClass: 2749263508Sdim case CStyleCastExprClass: 2750263508Sdim case ObjCBridgedCastExprClass: 2751263508Sdim case CXXDynamicCastExprClass: 2752263508Sdim case CXXReinterpretCastExprClass: 2753263508Sdim case CXXConstCastExprClass: { 2754234353Sdim const CastExpr *CE = cast<CastExpr>(this); 2755234353Sdim 2756234353Sdim // Handle misc casts we want to ignore. 2757234353Sdim if (CE->getCastKind() == CK_NoOp || 2758234353Sdim CE->getCastKind() == CK_LValueToRValue || 2759234353Sdim CE->getCastKind() == CK_ToUnion || 2760263508Sdim CE->getCastKind() == CK_ConstructorConversion || 2761263508Sdim CE->getCastKind() == CK_NonAtomicToAtomic || 2762263508Sdim CE->getCastKind() == CK_AtomicToNonAtomic) 2763234353Sdim return CE->getSubExpr()->isConstantInitializer(Ctx, false); 2764234353Sdim 2765193326Sed break; 2766234353Sdim } 2767224145Sdim case MaterializeTemporaryExprClass: 2768226633Sdim return cast<MaterializeTemporaryExpr>(this)->GetTemporaryExpr() 2769224145Sdim ->isConstantInitializer(Ctx, false); 2770263508Sdim 2771263508Sdim case SubstNonTypeTemplateParmExprClass: 2772263508Sdim return cast<SubstNonTypeTemplateParmExpr>(this)->getReplacement() 2773263508Sdim ->isConstantInitializer(Ctx, false); 2774263508Sdim case CXXDefaultArgExprClass: 2775263508Sdim return cast<CXXDefaultArgExpr>(this)->getExpr() 2776263508Sdim ->isConstantInitializer(Ctx, false); 2777263508Sdim case CXXDefaultInitExprClass: 2778263508Sdim return cast<CXXDefaultInitExpr>(this)->getExpr() 2779263508Sdim ->isConstantInitializer(Ctx, false); 2780193326Sed } 2781193326Sed return isEvaluatable(Ctx); 2782193326Sed} 2783193326Sed 2784239462Sdimbool Expr::HasSideEffects(const ASTContext &Ctx) const { 2785239462Sdim if (isInstantiationDependent()) 2786239462Sdim return true; 2787239462Sdim 2788239462Sdim switch (getStmtClass()) { 2789239462Sdim case NoStmtClass: 2790239462Sdim #define ABSTRACT_STMT(Type) 2791239462Sdim #define STMT(Type, Base) case Type##Class: 2792239462Sdim #define EXPR(Type, Base) 2793239462Sdim #include "clang/AST/StmtNodes.inc" 2794239462Sdim llvm_unreachable("unexpected Expr kind"); 2795239462Sdim 2796239462Sdim case DependentScopeDeclRefExprClass: 2797239462Sdim case CXXUnresolvedConstructExprClass: 2798239462Sdim case CXXDependentScopeMemberExprClass: 2799239462Sdim case UnresolvedLookupExprClass: 2800239462Sdim case UnresolvedMemberExprClass: 2801239462Sdim case PackExpansionExprClass: 2802239462Sdim case SubstNonTypeTemplateParmPackExprClass: 2803243830Sdim case FunctionParmPackExprClass: 2804239462Sdim llvm_unreachable("shouldn't see dependent / unresolved nodes here"); 2805239462Sdim 2806239462Sdim case DeclRefExprClass: 2807239462Sdim case ObjCIvarRefExprClass: 2808239462Sdim case PredefinedExprClass: 2809239462Sdim case IntegerLiteralClass: 2810239462Sdim case FloatingLiteralClass: 2811239462Sdim case ImaginaryLiteralClass: 2812239462Sdim case StringLiteralClass: 2813239462Sdim case CharacterLiteralClass: 2814239462Sdim case OffsetOfExprClass: 2815239462Sdim case ImplicitValueInitExprClass: 2816239462Sdim case UnaryExprOrTypeTraitExprClass: 2817239462Sdim case AddrLabelExprClass: 2818239462Sdim case GNUNullExprClass: 2819239462Sdim case CXXBoolLiteralExprClass: 2820239462Sdim case CXXNullPtrLiteralExprClass: 2821239462Sdim case CXXThisExprClass: 2822239462Sdim case CXXScalarValueInitExprClass: 2823239462Sdim case TypeTraitExprClass: 2824239462Sdim case UnaryTypeTraitExprClass: 2825239462Sdim case BinaryTypeTraitExprClass: 2826239462Sdim case ArrayTypeTraitExprClass: 2827239462Sdim case ExpressionTraitExprClass: 2828239462Sdim case CXXNoexceptExprClass: 2829239462Sdim case SizeOfPackExprClass: 2830239462Sdim case ObjCStringLiteralClass: 2831239462Sdim case ObjCEncodeExprClass: 2832239462Sdim case ObjCBoolLiteralExprClass: 2833239462Sdim case CXXUuidofExprClass: 2834239462Sdim case OpaqueValueExprClass: 2835239462Sdim // These never have a side-effect. 2836239462Sdim return false; 2837239462Sdim 2838239462Sdim case CallExprClass: 2839251662Sdim case MSPropertyRefExprClass: 2840239462Sdim case CompoundAssignOperatorClass: 2841239462Sdim case VAArgExprClass: 2842239462Sdim case AtomicExprClass: 2843239462Sdim case StmtExprClass: 2844239462Sdim case CXXOperatorCallExprClass: 2845239462Sdim case CXXMemberCallExprClass: 2846239462Sdim case UserDefinedLiteralClass: 2847239462Sdim case CXXThrowExprClass: 2848239462Sdim case CXXNewExprClass: 2849239462Sdim case CXXDeleteExprClass: 2850239462Sdim case ExprWithCleanupsClass: 2851239462Sdim case CXXBindTemporaryExprClass: 2852239462Sdim case BlockExprClass: 2853239462Sdim case CUDAKernelCallExprClass: 2854239462Sdim // These always have a side-effect. 2855239462Sdim return true; 2856239462Sdim 2857239462Sdim case ParenExprClass: 2858239462Sdim case ArraySubscriptExprClass: 2859239462Sdim case MemberExprClass: 2860239462Sdim case ConditionalOperatorClass: 2861239462Sdim case BinaryConditionalOperatorClass: 2862239462Sdim case CompoundLiteralExprClass: 2863239462Sdim case ExtVectorElementExprClass: 2864239462Sdim case DesignatedInitExprClass: 2865239462Sdim case ParenListExprClass: 2866239462Sdim case CXXPseudoDestructorExprClass: 2867263508Sdim case CXXStdInitializerListExprClass: 2868239462Sdim case SubstNonTypeTemplateParmExprClass: 2869239462Sdim case MaterializeTemporaryExprClass: 2870239462Sdim case ShuffleVectorExprClass: 2871263508Sdim case ConvertVectorExprClass: 2872239462Sdim case AsTypeExprClass: 2873239462Sdim // These have a side-effect if any subexpression does. 2874239462Sdim break; 2875239462Sdim 2876239462Sdim case UnaryOperatorClass: 2877239462Sdim if (cast<UnaryOperator>(this)->isIncrementDecrementOp()) 2878239462Sdim return true; 2879239462Sdim break; 2880239462Sdim 2881239462Sdim case BinaryOperatorClass: 2882239462Sdim if (cast<BinaryOperator>(this)->isAssignmentOp()) 2883239462Sdim return true; 2884239462Sdim break; 2885239462Sdim 2886239462Sdim case InitListExprClass: 2887239462Sdim // FIXME: The children for an InitListExpr doesn't include the array filler. 2888239462Sdim if (const Expr *E = cast<InitListExpr>(this)->getArrayFiller()) 2889239462Sdim if (E->HasSideEffects(Ctx)) 2890239462Sdim return true; 2891239462Sdim break; 2892239462Sdim 2893239462Sdim case GenericSelectionExprClass: 2894239462Sdim return cast<GenericSelectionExpr>(this)->getResultExpr()-> 2895239462Sdim HasSideEffects(Ctx); 2896239462Sdim 2897239462Sdim case ChooseExprClass: 2898263508Sdim return cast<ChooseExpr>(this)->getChosenSubExpr()->HasSideEffects(Ctx); 2899239462Sdim 2900239462Sdim case CXXDefaultArgExprClass: 2901239462Sdim return cast<CXXDefaultArgExpr>(this)->getExpr()->HasSideEffects(Ctx); 2902239462Sdim 2903251662Sdim case CXXDefaultInitExprClass: 2904251662Sdim if (const Expr *E = cast<CXXDefaultInitExpr>(this)->getExpr()) 2905251662Sdim return E->HasSideEffects(Ctx); 2906251662Sdim // If we've not yet parsed the initializer, assume it has side-effects. 2907251662Sdim return true; 2908251662Sdim 2909239462Sdim case CXXDynamicCastExprClass: { 2910239462Sdim // A dynamic_cast expression has side-effects if it can throw. 2911239462Sdim const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(this); 2912239462Sdim if (DCE->getTypeAsWritten()->isReferenceType() && 2913239462Sdim DCE->getCastKind() == CK_Dynamic) 2914239462Sdim return true; 2915239462Sdim } // Fall through. 2916239462Sdim case ImplicitCastExprClass: 2917239462Sdim case CStyleCastExprClass: 2918239462Sdim case CXXStaticCastExprClass: 2919239462Sdim case CXXReinterpretCastExprClass: 2920239462Sdim case CXXConstCastExprClass: 2921239462Sdim case CXXFunctionalCastExprClass: { 2922239462Sdim const CastExpr *CE = cast<CastExpr>(this); 2923239462Sdim if (CE->getCastKind() == CK_LValueToRValue && 2924239462Sdim CE->getSubExpr()->getType().isVolatileQualified()) 2925239462Sdim return true; 2926239462Sdim break; 2927239462Sdim } 2928239462Sdim 2929239462Sdim case CXXTypeidExprClass: 2930239462Sdim // typeid might throw if its subexpression is potentially-evaluated, so has 2931239462Sdim // side-effects in that case whether or not its subexpression does. 2932239462Sdim return cast<CXXTypeidExpr>(this)->isPotentiallyEvaluated(); 2933239462Sdim 2934239462Sdim case CXXConstructExprClass: 2935239462Sdim case CXXTemporaryObjectExprClass: { 2936239462Sdim const CXXConstructExpr *CE = cast<CXXConstructExpr>(this); 2937239462Sdim if (!CE->getConstructor()->isTrivial()) 2938239462Sdim return true; 2939239462Sdim // A trivial constructor does not add any side-effects of its own. Just look 2940239462Sdim // at its arguments. 2941239462Sdim break; 2942239462Sdim } 2943239462Sdim 2944239462Sdim case LambdaExprClass: { 2945239462Sdim const LambdaExpr *LE = cast<LambdaExpr>(this); 2946239462Sdim for (LambdaExpr::capture_iterator I = LE->capture_begin(), 2947239462Sdim E = LE->capture_end(); I != E; ++I) 2948239462Sdim if (I->getCaptureKind() == LCK_ByCopy) 2949239462Sdim // FIXME: Only has a side-effect if the variable is volatile or if 2950239462Sdim // the copy would invoke a non-trivial copy constructor. 2951239462Sdim return true; 2952239462Sdim return false; 2953239462Sdim } 2954239462Sdim 2955239462Sdim case PseudoObjectExprClass: { 2956239462Sdim // Only look for side-effects in the semantic form, and look past 2957239462Sdim // OpaqueValueExpr bindings in that form. 2958239462Sdim const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this); 2959239462Sdim for (PseudoObjectExpr::const_semantics_iterator I = PO->semantics_begin(), 2960239462Sdim E = PO->semantics_end(); 2961239462Sdim I != E; ++I) { 2962239462Sdim const Expr *Subexpr = *I; 2963239462Sdim if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Subexpr)) 2964239462Sdim Subexpr = OVE->getSourceExpr(); 2965239462Sdim if (Subexpr->HasSideEffects(Ctx)) 2966239462Sdim return true; 2967239462Sdim } 2968239462Sdim return false; 2969239462Sdim } 2970239462Sdim 2971239462Sdim case ObjCBoxedExprClass: 2972239462Sdim case ObjCArrayLiteralClass: 2973239462Sdim case ObjCDictionaryLiteralClass: 2974239462Sdim case ObjCMessageExprClass: 2975239462Sdim case ObjCSelectorExprClass: 2976239462Sdim case ObjCProtocolExprClass: 2977239462Sdim case ObjCPropertyRefExprClass: 2978239462Sdim case ObjCIsaExprClass: 2979239462Sdim case ObjCIndirectCopyRestoreExprClass: 2980239462Sdim case ObjCSubscriptRefExprClass: 2981239462Sdim case ObjCBridgedCastExprClass: 2982239462Sdim // FIXME: Classify these cases better. 2983239462Sdim return true; 2984239462Sdim } 2985239462Sdim 2986239462Sdim // Recurse to children. 2987239462Sdim for (const_child_range SubStmts = children(); SubStmts; ++SubStmts) 2988239462Sdim if (const Stmt *S = *SubStmts) 2989239462Sdim if (cast<Expr>(S)->HasSideEffects(Ctx)) 2990239462Sdim return true; 2991239462Sdim 2992239462Sdim return false; 2993239462Sdim} 2994239462Sdim 2995234353Sdimnamespace { 2996234353Sdim /// \brief Look for a call to a non-trivial function within an expression. 2997234353Sdim class NonTrivialCallFinder : public EvaluatedExprVisitor<NonTrivialCallFinder> 2998234353Sdim { 2999234353Sdim typedef EvaluatedExprVisitor<NonTrivialCallFinder> Inherited; 3000234353Sdim 3001234353Sdim bool NonTrivial; 3002234353Sdim 3003234353Sdim public: 3004234353Sdim explicit NonTrivialCallFinder(ASTContext &Context) 3005234353Sdim : Inherited(Context), NonTrivial(false) { } 3006234353Sdim 3007234353Sdim bool hasNonTrivialCall() const { return NonTrivial; } 3008234353Sdim 3009234353Sdim void VisitCallExpr(CallExpr *E) { 3010234353Sdim if (CXXMethodDecl *Method 3011234353Sdim = dyn_cast_or_null<CXXMethodDecl>(E->getCalleeDecl())) { 3012234353Sdim if (Method->isTrivial()) { 3013234353Sdim // Recurse to children of the call. 3014234353Sdim Inherited::VisitStmt(E); 3015234353Sdim return; 3016234353Sdim } 3017234353Sdim } 3018234353Sdim 3019234353Sdim NonTrivial = true; 3020234353Sdim } 3021234353Sdim 3022234353Sdim void VisitCXXConstructExpr(CXXConstructExpr *E) { 3023234353Sdim if (E->getConstructor()->isTrivial()) { 3024234353Sdim // Recurse to children of the call. 3025234353Sdim Inherited::VisitStmt(E); 3026234353Sdim return; 3027234353Sdim } 3028234353Sdim 3029234353Sdim NonTrivial = true; 3030234353Sdim } 3031234353Sdim 3032234353Sdim void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) { 3033234353Sdim if (E->getTemporary()->getDestructor()->isTrivial()) { 3034234353Sdim Inherited::VisitStmt(E); 3035234353Sdim return; 3036234353Sdim } 3037234353Sdim 3038234353Sdim NonTrivial = true; 3039234353Sdim } 3040234353Sdim }; 3041234353Sdim} 3042234353Sdim 3043234353Sdimbool Expr::hasNonTrivialCall(ASTContext &Ctx) { 3044234353Sdim NonTrivialCallFinder Finder(Ctx); 3045234353Sdim Finder.Visit(this); 3046234353Sdim return Finder.hasNonTrivialCall(); 3047234353Sdim} 3048234353Sdim 3049218893Sdim/// isNullPointerConstant - C99 6.3.2.3p3 - Return whether this is a null 3050218893Sdim/// pointer constant or not, as well as the specific kind of constant detected. 3051218893Sdim/// Null pointer constants can be integer constant expressions with the 3052218893Sdim/// value zero, casts of zero to void*, nullptr (C++0X), or __null 3053218893Sdim/// (a GNU extension). 3054218893SdimExpr::NullPointerConstantKind 3055218893SdimExpr::isNullPointerConstant(ASTContext &Ctx, 3056218893Sdim NullPointerConstantValueDependence NPC) const { 3057263508Sdim if (isValueDependent() && 3058263508Sdim (!Ctx.getLangOpts().CPlusPlus11 || Ctx.getLangOpts().MicrosoftMode)) { 3059198092Srdivacky switch (NPC) { 3060198092Srdivacky case NPC_NeverValueDependent: 3061226633Sdim llvm_unreachable("Unexpected value dependent expression!"); 3062198092Srdivacky case NPC_ValueDependentIsNull: 3063218893Sdim if (isTypeDependent() || getType()->isIntegralType(Ctx)) 3064239462Sdim return NPCK_ZeroExpression; 3065218893Sdim else 3066218893Sdim return NPCK_NotNull; 3067198092Srdivacky 3068198092Srdivacky case NPC_ValueDependentIsNotNull: 3069218893Sdim return NPCK_NotNull; 3070198092Srdivacky } 3071198092Srdivacky } 3072198092Srdivacky 3073193326Sed // Strip off a cast to void*, if it exists. Except in C++. 3074193326Sed if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 3075234353Sdim if (!Ctx.getLangOpts().CPlusPlus) { 3076193326Sed // Check that it is a cast to void*. 3077198092Srdivacky if (const PointerType *PT = CE->getType()->getAs<PointerType>()) { 3078193326Sed QualType Pointee = PT->getPointeeType(); 3079198092Srdivacky if (!Pointee.hasQualifiers() && 3080193326Sed Pointee->isVoidType() && // to void* 3081193326Sed CE->getSubExpr()->getType()->isIntegerType()) // from int. 3082198092Srdivacky return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 3083193326Sed } 3084193326Sed } 3085193326Sed } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 3086193326Sed // Ignore the ImplicitCastExpr type entirely. 3087198092Srdivacky return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 3088193326Sed } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 3089193326Sed // Accept ((void*)0) as a null pointer constant, as many other 3090193326Sed // implementations do. 3091198092Srdivacky return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC); 3092221345Sdim } else if (const GenericSelectionExpr *GE = 3093221345Sdim dyn_cast<GenericSelectionExpr>(this)) { 3094263508Sdim if (GE->isResultDependent()) 3095263508Sdim return NPCK_NotNull; 3096221345Sdim return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC); 3097263508Sdim } else if (const ChooseExpr *CE = dyn_cast<ChooseExpr>(this)) { 3098263508Sdim if (CE->isConditionDependent()) 3099263508Sdim return NPCK_NotNull; 3100263508Sdim return CE->getChosenSubExpr()->isNullPointerConstant(Ctx, NPC); 3101198092Srdivacky } else if (const CXXDefaultArgExpr *DefaultArg 3102193326Sed = dyn_cast<CXXDefaultArgExpr>(this)) { 3103251662Sdim // See through default argument expressions. 3104198092Srdivacky return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC); 3105251662Sdim } else if (const CXXDefaultInitExpr *DefaultInit 3106251662Sdim = dyn_cast<CXXDefaultInitExpr>(this)) { 3107251662Sdim // See through default initializer expressions. 3108251662Sdim return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC); 3109193326Sed } else if (isa<GNUNullExpr>(this)) { 3110193326Sed // The GNU __null extension is always a null pointer constant. 3111218893Sdim return NPCK_GNUNull; 3112224145Sdim } else if (const MaterializeTemporaryExpr *M 3113224145Sdim = dyn_cast<MaterializeTemporaryExpr>(this)) { 3114224145Sdim return M->GetTemporaryExpr()->isNullPointerConstant(Ctx, NPC); 3115234353Sdim } else if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(this)) { 3116234353Sdim if (const Expr *Source = OVE->getSourceExpr()) 3117234353Sdim return Source->isNullPointerConstant(Ctx, NPC); 3118193326Sed } 3119193326Sed 3120249423Sdim // C++11 nullptr_t is always a null pointer constant. 3121193326Sed if (getType()->isNullPtrType()) 3122249423Sdim return NPCK_CXX11_nullptr; 3123193326Sed 3124218893Sdim if (const RecordType *UT = getType()->getAsUnionType()) 3125263508Sdim if (!Ctx.getLangOpts().CPlusPlus11 && 3126263508Sdim UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) 3127218893Sdim if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){ 3128218893Sdim const Expr *InitExpr = CLE->getInitializer(); 3129218893Sdim if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr)) 3130218893Sdim return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC); 3131218893Sdim } 3132193326Sed // This expression must be an integer type. 3133198092Srdivacky if (!getType()->isIntegerType() || 3134234353Sdim (Ctx.getLangOpts().CPlusPlus && getType()->isEnumeralType())) 3135218893Sdim return NPCK_NotNull; 3136198092Srdivacky 3137249423Sdim if (Ctx.getLangOpts().CPlusPlus11) { 3138263508Sdim // C++11 [conv.ptr]p1: A null pointer constant is an integer literal with 3139263508Sdim // value zero or a prvalue of type std::nullptr_t. 3140263508Sdim // Microsoft mode permits C++98 rules reflecting MSVC behavior. 3141263508Sdim const IntegerLiteral *Lit = dyn_cast<IntegerLiteral>(this); 3142263508Sdim if (Lit && !Lit->getValue()) 3143263508Sdim return NPCK_ZeroLiteral; 3144263508Sdim else if (!Ctx.getLangOpts().MicrosoftMode || 3145263508Sdim !isCXX98IntegralConstantExpr(Ctx)) 3146234353Sdim return NPCK_NotNull; 3147234353Sdim } else { 3148263508Sdim // If we have an integer constant expression, we need to *evaluate* it and 3149263508Sdim // test for the value 0. 3150234353Sdim if (!isIntegerConstantExpr(Ctx)) 3151234353Sdim return NPCK_NotNull; 3152234353Sdim } 3153218893Sdim 3154239462Sdim if (EvaluateKnownConstInt(Ctx) != 0) 3155239462Sdim return NPCK_NotNull; 3156239462Sdim 3157239462Sdim if (isa<IntegerLiteral>(this)) 3158239462Sdim return NPCK_ZeroLiteral; 3159239462Sdim return NPCK_ZeroExpression; 3160193326Sed} 3161193326Sed 3162218893Sdim/// \brief If this expression is an l-value for an Objective C 3163218893Sdim/// property, find the underlying property reference expression. 3164218893Sdimconst ObjCPropertyRefExpr *Expr::getObjCProperty() const { 3165218893Sdim const Expr *E = this; 3166218893Sdim while (true) { 3167218893Sdim assert((E->getValueKind() == VK_LValue && 3168218893Sdim E->getObjectKind() == OK_ObjCProperty) && 3169218893Sdim "expression is not a property reference"); 3170218893Sdim E = E->IgnoreParenCasts(); 3171218893Sdim if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 3172218893Sdim if (BO->getOpcode() == BO_Comma) { 3173218893Sdim E = BO->getRHS(); 3174218893Sdim continue; 3175218893Sdim } 3176218893Sdim } 3177218893Sdim 3178218893Sdim break; 3179218893Sdim } 3180218893Sdim 3181218893Sdim return cast<ObjCPropertyRefExpr>(E); 3182218893Sdim} 3183218893Sdim 3184243830Sdimbool Expr::isObjCSelfExpr() const { 3185243830Sdim const Expr *E = IgnoreParenImpCasts(); 3186243830Sdim 3187243830Sdim const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E); 3188243830Sdim if (!DRE) 3189243830Sdim return false; 3190243830Sdim 3191243830Sdim const ImplicitParamDecl *Param = dyn_cast<ImplicitParamDecl>(DRE->getDecl()); 3192243830Sdim if (!Param) 3193243830Sdim return false; 3194243830Sdim 3195243830Sdim const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(Param->getDeclContext()); 3196243830Sdim if (!M) 3197243830Sdim return false; 3198243830Sdim 3199243830Sdim return M->getSelfDecl() == Param; 3200243830Sdim} 3201243830Sdim 3202251662SdimFieldDecl *Expr::getSourceBitField() { 3203198092Srdivacky Expr *E = this->IgnoreParens(); 3204193326Sed 3205203955Srdivacky while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 3206218893Sdim if (ICE->getCastKind() == CK_LValueToRValue || 3207218893Sdim (ICE->getValueKind() != VK_RValue && ICE->getCastKind() == CK_NoOp)) 3208203955Srdivacky E = ICE->getSubExpr()->IgnoreParens(); 3209203955Srdivacky else 3210203955Srdivacky break; 3211203955Srdivacky } 3212203955Srdivacky 3213193326Sed if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 3214193326Sed if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl())) 3215193326Sed if (Field->isBitField()) 3216193326Sed return Field; 3217193326Sed 3218251662Sdim if (ObjCIvarRefExpr *IvarRef = dyn_cast<ObjCIvarRefExpr>(E)) 3219251662Sdim if (FieldDecl *Ivar = dyn_cast<FieldDecl>(IvarRef->getDecl())) 3220251662Sdim if (Ivar->isBitField()) 3221251662Sdim return Ivar; 3222251662Sdim 3223218893Sdim if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E)) 3224218893Sdim if (FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl())) 3225218893Sdim if (Field->isBitField()) 3226218893Sdim return Field; 3227218893Sdim 3228224145Sdim if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) { 3229193326Sed if (BinOp->isAssignmentOp() && BinOp->getLHS()) 3230251662Sdim return BinOp->getLHS()->getSourceBitField(); 3231193326Sed 3232224145Sdim if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS()) 3233251662Sdim return BinOp->getRHS()->getSourceBitField(); 3234224145Sdim } 3235224145Sdim 3236193326Sed return 0; 3237193326Sed} 3238193326Sed 3239203955Srdivackybool Expr::refersToVectorElement() const { 3240203955Srdivacky const Expr *E = this->IgnoreParens(); 3241203955Srdivacky 3242203955Srdivacky while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 3243212904Sdim if (ICE->getValueKind() != VK_RValue && 3244212904Sdim ICE->getCastKind() == CK_NoOp) 3245203955Srdivacky E = ICE->getSubExpr()->IgnoreParens(); 3246203955Srdivacky else 3247203955Srdivacky break; 3248203955Srdivacky } 3249203955Srdivacky 3250203955Srdivacky if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) 3251203955Srdivacky return ASE->getBase()->getType()->isVectorType(); 3252203955Srdivacky 3253203955Srdivacky if (isa<ExtVectorElementExpr>(E)) 3254203955Srdivacky return true; 3255203955Srdivacky 3256203955Srdivacky return false; 3257203955Srdivacky} 3258203955Srdivacky 3259193326Sed/// isArrow - Return true if the base expression is a pointer to vector, 3260193326Sed/// return false if the base expression is a vector. 3261193326Sedbool ExtVectorElementExpr::isArrow() const { 3262193326Sed return getBase()->getType()->isPointerType(); 3263193326Sed} 3264193326Sed 3265193326Sedunsigned ExtVectorElementExpr::getNumElements() const { 3266198092Srdivacky if (const VectorType *VT = getType()->getAs<VectorType>()) 3267193326Sed return VT->getNumElements(); 3268193326Sed return 1; 3269193326Sed} 3270193326Sed 3271193326Sed/// containsDuplicateElements - Return true if any element access is repeated. 3272193326Sedbool ExtVectorElementExpr::containsDuplicateElements() const { 3273198398Srdivacky // FIXME: Refactor this code to an accessor on the AST node which returns the 3274198398Srdivacky // "type" of component access, and share with code below and in Sema. 3275226633Sdim StringRef Comp = Accessor->getName(); 3276193326Sed 3277193326Sed // Halving swizzles do not contain duplicate elements. 3278198398Srdivacky if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd") 3279193326Sed return false; 3280198092Srdivacky 3281193326Sed // Advance past s-char prefix on hex swizzles. 3282198398Srdivacky if (Comp[0] == 's' || Comp[0] == 'S') 3283198398Srdivacky Comp = Comp.substr(1); 3284198092Srdivacky 3285198398Srdivacky for (unsigned i = 0, e = Comp.size(); i != e; ++i) 3286226633Sdim if (Comp.substr(i + 1).find(Comp[i]) != StringRef::npos) 3287193326Sed return true; 3288198398Srdivacky 3289193326Sed return false; 3290193326Sed} 3291193326Sed 3292193326Sed/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 3293193326Sedvoid ExtVectorElementExpr::getEncodedElementAccess( 3294226633Sdim SmallVectorImpl<unsigned> &Elts) const { 3295226633Sdim StringRef Comp = Accessor->getName(); 3296198398Srdivacky if (Comp[0] == 's' || Comp[0] == 'S') 3297198398Srdivacky Comp = Comp.substr(1); 3298198092Srdivacky 3299198398Srdivacky bool isHi = Comp == "hi"; 3300198398Srdivacky bool isLo = Comp == "lo"; 3301198398Srdivacky bool isEven = Comp == "even"; 3302198398Srdivacky bool isOdd = Comp == "odd"; 3303198092Srdivacky 3304193326Sed for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 3305193326Sed uint64_t Index; 3306198092Srdivacky 3307193326Sed if (isHi) 3308193326Sed Index = e + i; 3309193326Sed else if (isLo) 3310193326Sed Index = i; 3311193326Sed else if (isEven) 3312193326Sed Index = 2 * i; 3313193326Sed else if (isOdd) 3314193326Sed Index = 2 * i + 1; 3315193326Sed else 3316198398Srdivacky Index = ExtVectorType::getAccessorIdx(Comp[i]); 3317193326Sed 3318193326Sed Elts.push_back(Index); 3319193326Sed } 3320193326Sed} 3321193326Sed 3322207619SrdivackyObjCMessageExpr::ObjCMessageExpr(QualType T, 3323218893Sdim ExprValueKind VK, 3324207619Srdivacky SourceLocation LBracLoc, 3325207619Srdivacky SourceLocation SuperLoc, 3326207619Srdivacky bool IsInstanceSuper, 3327207619Srdivacky QualType SuperType, 3328207619Srdivacky Selector Sel, 3329226633Sdim ArrayRef<SourceLocation> SelLocs, 3330226633Sdim SelectorLocationsKind SelLocsK, 3331207619Srdivacky ObjCMethodDecl *Method, 3332226633Sdim ArrayRef<Expr *> Args, 3333234353Sdim SourceLocation RBracLoc, 3334234353Sdim bool isImplicit) 3335218893Sdim : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, 3336218893Sdim /*TypeDependent=*/false, /*ValueDependent=*/false, 3337224145Sdim /*InstantiationDependent=*/false, 3338218893Sdim /*ContainsUnexpandedParameterPack=*/false), 3339207619Srdivacky SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 3340207619Srdivacky : Sel.getAsOpaquePtr())), 3341226633Sdim Kind(IsInstanceSuper? SuperInstance : SuperClass), 3342234353Sdim HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit), 3343234353Sdim SuperLoc(SuperLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc) 3344207619Srdivacky{ 3345226633Sdim initArgsAndSelLocs(Args, SelLocs, SelLocsK); 3346207619Srdivacky setReceiverPointer(SuperType.getAsOpaquePtr()); 3347193326Sed} 3348193326Sed 3349207619SrdivackyObjCMessageExpr::ObjCMessageExpr(QualType T, 3350218893Sdim ExprValueKind VK, 3351207619Srdivacky SourceLocation LBracLoc, 3352207619Srdivacky TypeSourceInfo *Receiver, 3353218893Sdim Selector Sel, 3354226633Sdim ArrayRef<SourceLocation> SelLocs, 3355226633Sdim SelectorLocationsKind SelLocsK, 3356207619Srdivacky ObjCMethodDecl *Method, 3357226633Sdim ArrayRef<Expr *> Args, 3358234353Sdim SourceLocation RBracLoc, 3359234353Sdim bool isImplicit) 3360218893Sdim : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(), 3361224145Sdim T->isDependentType(), T->isInstantiationDependentType(), 3362224145Sdim T->containsUnexpandedParameterPack()), 3363207619Srdivacky SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 3364207619Srdivacky : Sel.getAsOpaquePtr())), 3365226633Sdim Kind(Class), 3366234353Sdim HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit), 3367226633Sdim LBracLoc(LBracLoc), RBracLoc(RBracLoc) 3368207619Srdivacky{ 3369226633Sdim initArgsAndSelLocs(Args, SelLocs, SelLocsK); 3370207619Srdivacky setReceiverPointer(Receiver); 3371193326Sed} 3372193326Sed 3373207619SrdivackyObjCMessageExpr::ObjCMessageExpr(QualType T, 3374218893Sdim ExprValueKind VK, 3375207619Srdivacky SourceLocation LBracLoc, 3376207619Srdivacky Expr *Receiver, 3377207619Srdivacky Selector Sel, 3378226633Sdim ArrayRef<SourceLocation> SelLocs, 3379226633Sdim SelectorLocationsKind SelLocsK, 3380207619Srdivacky ObjCMethodDecl *Method, 3381226633Sdim ArrayRef<Expr *> Args, 3382234353Sdim SourceLocation RBracLoc, 3383234353Sdim bool isImplicit) 3384218893Sdim : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, Receiver->isTypeDependent(), 3385218893Sdim Receiver->isTypeDependent(), 3386224145Sdim Receiver->isInstantiationDependent(), 3387218893Sdim Receiver->containsUnexpandedParameterPack()), 3388207619Srdivacky SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method 3389207619Srdivacky : Sel.getAsOpaquePtr())), 3390226633Sdim Kind(Instance), 3391234353Sdim HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit), 3392226633Sdim LBracLoc(LBracLoc), RBracLoc(RBracLoc) 3393204962Srdivacky{ 3394226633Sdim initArgsAndSelLocs(Args, SelLocs, SelLocsK); 3395207619Srdivacky setReceiverPointer(Receiver); 3396226633Sdim} 3397226633Sdim 3398226633Sdimvoid ObjCMessageExpr::initArgsAndSelLocs(ArrayRef<Expr *> Args, 3399226633Sdim ArrayRef<SourceLocation> SelLocs, 3400226633Sdim SelectorLocationsKind SelLocsK) { 3401226633Sdim setNumArgs(Args.size()); 3402218893Sdim Expr **MyArgs = getArgs(); 3403226633Sdim for (unsigned I = 0; I != Args.size(); ++I) { 3404218893Sdim if (Args[I]->isTypeDependent()) 3405218893Sdim ExprBits.TypeDependent = true; 3406218893Sdim if (Args[I]->isValueDependent()) 3407218893Sdim ExprBits.ValueDependent = true; 3408224145Sdim if (Args[I]->isInstantiationDependent()) 3409224145Sdim ExprBits.InstantiationDependent = true; 3410218893Sdim if (Args[I]->containsUnexpandedParameterPack()) 3411218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 3412218893Sdim 3413218893Sdim MyArgs[I] = Args[I]; 3414218893Sdim } 3415226633Sdim 3416226633Sdim SelLocsKind = SelLocsK; 3417234353Sdim if (!isImplicit()) { 3418234353Sdim if (SelLocsK == SelLoc_NonStandard) 3419234353Sdim std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs()); 3420234353Sdim } 3421193326Sed} 3422193326Sed 3423263508SdimObjCMessageExpr *ObjCMessageExpr::Create(const ASTContext &Context, QualType T, 3424218893Sdim ExprValueKind VK, 3425207619Srdivacky SourceLocation LBracLoc, 3426207619Srdivacky SourceLocation SuperLoc, 3427207619Srdivacky bool IsInstanceSuper, 3428207619Srdivacky QualType SuperType, 3429207619Srdivacky Selector Sel, 3430226633Sdim ArrayRef<SourceLocation> SelLocs, 3431207619Srdivacky ObjCMethodDecl *Method, 3432226633Sdim ArrayRef<Expr *> Args, 3433234353Sdim SourceLocation RBracLoc, 3434234353Sdim bool isImplicit) { 3435234353Sdim assert((!SelLocs.empty() || isImplicit) && 3436234353Sdim "No selector locs for non-implicit message"); 3437234353Sdim ObjCMessageExpr *Mem; 3438234353Sdim SelectorLocationsKind SelLocsK = SelectorLocationsKind(); 3439234353Sdim if (isImplicit) 3440234353Sdim Mem = alloc(Context, Args.size(), 0); 3441234353Sdim else 3442234353Sdim Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); 3443218893Sdim return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, SuperLoc, IsInstanceSuper, 3444226633Sdim SuperType, Sel, SelLocs, SelLocsK, 3445234353Sdim Method, Args, RBracLoc, isImplicit); 3446193326Sed} 3447193326Sed 3448263508SdimObjCMessageExpr *ObjCMessageExpr::Create(const ASTContext &Context, QualType T, 3449218893Sdim ExprValueKind VK, 3450207619Srdivacky SourceLocation LBracLoc, 3451207619Srdivacky TypeSourceInfo *Receiver, 3452207619Srdivacky Selector Sel, 3453226633Sdim ArrayRef<SourceLocation> SelLocs, 3454207619Srdivacky ObjCMethodDecl *Method, 3455226633Sdim ArrayRef<Expr *> Args, 3456234353Sdim SourceLocation RBracLoc, 3457234353Sdim bool isImplicit) { 3458234353Sdim assert((!SelLocs.empty() || isImplicit) && 3459234353Sdim "No selector locs for non-implicit message"); 3460234353Sdim ObjCMessageExpr *Mem; 3461234353Sdim SelectorLocationsKind SelLocsK = SelectorLocationsKind(); 3462234353Sdim if (isImplicit) 3463234353Sdim Mem = alloc(Context, Args.size(), 0); 3464234353Sdim else 3465234353Sdim Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); 3466226633Sdim return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, 3467234353Sdim SelLocs, SelLocsK, Method, Args, RBracLoc, 3468234353Sdim isImplicit); 3469207619Srdivacky} 3470204962Srdivacky 3471263508SdimObjCMessageExpr *ObjCMessageExpr::Create(const ASTContext &Context, QualType T, 3472218893Sdim ExprValueKind VK, 3473207619Srdivacky SourceLocation LBracLoc, 3474207619Srdivacky Expr *Receiver, 3475218893Sdim Selector Sel, 3476226633Sdim ArrayRef<SourceLocation> SelLocs, 3477207619Srdivacky ObjCMethodDecl *Method, 3478226633Sdim ArrayRef<Expr *> Args, 3479234353Sdim SourceLocation RBracLoc, 3480234353Sdim bool isImplicit) { 3481234353Sdim assert((!SelLocs.empty() || isImplicit) && 3482234353Sdim "No selector locs for non-implicit message"); 3483234353Sdim ObjCMessageExpr *Mem; 3484234353Sdim SelectorLocationsKind SelLocsK = SelectorLocationsKind(); 3485234353Sdim if (isImplicit) 3486234353Sdim Mem = alloc(Context, Args.size(), 0); 3487234353Sdim else 3488234353Sdim Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK); 3489226633Sdim return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel, 3490234353Sdim SelLocs, SelLocsK, Method, Args, RBracLoc, 3491234353Sdim isImplicit); 3492193326Sed} 3493193326Sed 3494263508SdimObjCMessageExpr *ObjCMessageExpr::CreateEmpty(const ASTContext &Context, 3495226633Sdim unsigned NumArgs, 3496226633Sdim unsigned NumStoredSelLocs) { 3497226633Sdim ObjCMessageExpr *Mem = alloc(Context, NumArgs, NumStoredSelLocs); 3498207619Srdivacky return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs); 3499203955Srdivacky} 3500218893Sdim 3501263508SdimObjCMessageExpr *ObjCMessageExpr::alloc(const ASTContext &C, 3502226633Sdim ArrayRef<Expr *> Args, 3503226633Sdim SourceLocation RBraceLoc, 3504226633Sdim ArrayRef<SourceLocation> SelLocs, 3505226633Sdim Selector Sel, 3506226633Sdim SelectorLocationsKind &SelLocsK) { 3507226633Sdim SelLocsK = hasStandardSelectorLocs(Sel, SelLocs, Args, RBraceLoc); 3508226633Sdim unsigned NumStoredSelLocs = (SelLocsK == SelLoc_NonStandard) ? SelLocs.size() 3509226633Sdim : 0; 3510226633Sdim return alloc(C, Args.size(), NumStoredSelLocs); 3511226633Sdim} 3512226633Sdim 3513263508SdimObjCMessageExpr *ObjCMessageExpr::alloc(const ASTContext &C, 3514226633Sdim unsigned NumArgs, 3515226633Sdim unsigned NumStoredSelLocs) { 3516226633Sdim unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) + 3517226633Sdim NumArgs * sizeof(Expr *) + NumStoredSelLocs * sizeof(SourceLocation); 3518226633Sdim return (ObjCMessageExpr *)C.Allocate(Size, 3519226633Sdim llvm::AlignOf<ObjCMessageExpr>::Alignment); 3520226633Sdim} 3521226633Sdim 3522226633Sdimvoid ObjCMessageExpr::getSelectorLocs( 3523226633Sdim SmallVectorImpl<SourceLocation> &SelLocs) const { 3524226633Sdim for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i) 3525226633Sdim SelLocs.push_back(getSelectorLoc(i)); 3526226633Sdim} 3527226633Sdim 3528218893SdimSourceRange ObjCMessageExpr::getReceiverRange() const { 3529218893Sdim switch (getReceiverKind()) { 3530218893Sdim case Instance: 3531218893Sdim return getInstanceReceiver()->getSourceRange(); 3532218893Sdim 3533218893Sdim case Class: 3534218893Sdim return getClassReceiverTypeInfo()->getTypeLoc().getSourceRange(); 3535218893Sdim 3536218893Sdim case SuperInstance: 3537218893Sdim case SuperClass: 3538218893Sdim return getSuperLoc(); 3539218893Sdim } 3540218893Sdim 3541234353Sdim llvm_unreachable("Invalid ReceiverKind!"); 3542218893Sdim} 3543218893Sdim 3544207619SrdivackySelector ObjCMessageExpr::getSelector() const { 3545207619Srdivacky if (HasMethod) 3546207619Srdivacky return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod) 3547207619Srdivacky ->getSelector(); 3548207619Srdivacky return Selector(SelectorOrMethod); 3549207619Srdivacky} 3550193326Sed 3551243830SdimQualType ObjCMessageExpr::getReceiverType() const { 3552207619Srdivacky switch (getReceiverKind()) { 3553207619Srdivacky case Instance: 3554243830Sdim return getInstanceReceiver()->getType(); 3555207619Srdivacky case Class: 3556243830Sdim return getClassReceiver(); 3557207619Srdivacky case SuperInstance: 3558207619Srdivacky case SuperClass: 3559243830Sdim return getSuperType(); 3560207619Srdivacky } 3561207619Srdivacky 3562243830Sdim llvm_unreachable("unexpected receiver kind"); 3563243830Sdim} 3564243830Sdim 3565243830SdimObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const { 3566243830Sdim QualType T = getReceiverType(); 3567243830Sdim 3568243830Sdim if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>()) 3569243830Sdim return Ptr->getInterfaceDecl(); 3570243830Sdim 3571243830Sdim if (const ObjCObjectType *Ty = T->getAs<ObjCObjectType>()) 3572243830Sdim return Ty->getInterface(); 3573243830Sdim 3574207619Srdivacky return 0; 3575207619Srdivacky} 3576207619Srdivacky 3577226633SdimStringRef ObjCBridgedCastExpr::getBridgeKindName() const { 3578224145Sdim switch (getBridgeKind()) { 3579224145Sdim case OBC_Bridge: 3580224145Sdim return "__bridge"; 3581224145Sdim case OBC_BridgeTransfer: 3582224145Sdim return "__bridge_transfer"; 3583224145Sdim case OBC_BridgeRetained: 3584224145Sdim return "__bridge_retained"; 3585224145Sdim } 3586234353Sdim 3587234353Sdim llvm_unreachable("Invalid BridgeKind!"); 3588224145Sdim} 3589224145Sdim 3590263508SdimShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args, 3591218893Sdim QualType Type, SourceLocation BLoc, 3592218893Sdim SourceLocation RP) 3593218893Sdim : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary, 3594218893Sdim Type->isDependentType(), Type->isDependentType(), 3595224145Sdim Type->isInstantiationDependentType(), 3596218893Sdim Type->containsUnexpandedParameterPack()), 3597243830Sdim BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) 3598218893Sdim{ 3599243830Sdim SubExprs = new (C) Stmt*[args.size()]; 3600243830Sdim for (unsigned i = 0; i != args.size(); i++) { 3601218893Sdim if (args[i]->isTypeDependent()) 3602218893Sdim ExprBits.TypeDependent = true; 3603218893Sdim if (args[i]->isValueDependent()) 3604218893Sdim ExprBits.ValueDependent = true; 3605224145Sdim if (args[i]->isInstantiationDependent()) 3606224145Sdim ExprBits.InstantiationDependent = true; 3607218893Sdim if (args[i]->containsUnexpandedParameterPack()) 3608218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 3609218893Sdim 3610218893Sdim SubExprs[i] = args[i]; 3611218893Sdim } 3612218893Sdim} 3613218893Sdim 3614263508Sdimvoid ShuffleVectorExpr::setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs) { 3615198092Srdivacky if (SubExprs) C.Deallocate(SubExprs); 3616198092Srdivacky 3617263508Sdim this->NumExprs = Exprs.size(); 3618263508Sdim SubExprs = new (C) Stmt*[NumExprs]; 3619263508Sdim memcpy(SubExprs, Exprs.data(), sizeof(Expr *) * Exprs.size()); 3620193326Sed} 3621193326Sed 3622263508SdimGenericSelectionExpr::GenericSelectionExpr(const ASTContext &Context, 3623221345Sdim SourceLocation GenericLoc, Expr *ControllingExpr, 3624243830Sdim ArrayRef<TypeSourceInfo*> AssocTypes, 3625243830Sdim ArrayRef<Expr*> AssocExprs, 3626243830Sdim SourceLocation DefaultLoc, 3627221345Sdim SourceLocation RParenLoc, 3628221345Sdim bool ContainsUnexpandedParameterPack, 3629221345Sdim unsigned ResultIndex) 3630221345Sdim : Expr(GenericSelectionExprClass, 3631221345Sdim AssocExprs[ResultIndex]->getType(), 3632221345Sdim AssocExprs[ResultIndex]->getValueKind(), 3633221345Sdim AssocExprs[ResultIndex]->getObjectKind(), 3634221345Sdim AssocExprs[ResultIndex]->isTypeDependent(), 3635221345Sdim AssocExprs[ResultIndex]->isValueDependent(), 3636224145Sdim AssocExprs[ResultIndex]->isInstantiationDependent(), 3637221345Sdim ContainsUnexpandedParameterPack), 3638243830Sdim AssocTypes(new (Context) TypeSourceInfo*[AssocTypes.size()]), 3639243830Sdim SubExprs(new (Context) Stmt*[END_EXPR+AssocExprs.size()]), 3640243830Sdim NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex), 3641243830Sdim GenericLoc(GenericLoc), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) { 3642221345Sdim SubExprs[CONTROLLING] = ControllingExpr; 3643243830Sdim assert(AssocTypes.size() == AssocExprs.size()); 3644243830Sdim std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes); 3645243830Sdim std::copy(AssocExprs.begin(), AssocExprs.end(), SubExprs+END_EXPR); 3646221345Sdim} 3647221345Sdim 3648263508SdimGenericSelectionExpr::GenericSelectionExpr(const ASTContext &Context, 3649221345Sdim SourceLocation GenericLoc, Expr *ControllingExpr, 3650243830Sdim ArrayRef<TypeSourceInfo*> AssocTypes, 3651243830Sdim ArrayRef<Expr*> AssocExprs, 3652243830Sdim SourceLocation DefaultLoc, 3653221345Sdim SourceLocation RParenLoc, 3654221345Sdim bool ContainsUnexpandedParameterPack) 3655221345Sdim : Expr(GenericSelectionExprClass, 3656221345Sdim Context.DependentTy, 3657221345Sdim VK_RValue, 3658221345Sdim OK_Ordinary, 3659224145Sdim /*isTypeDependent=*/true, 3660224145Sdim /*isValueDependent=*/true, 3661224145Sdim /*isInstantiationDependent=*/true, 3662221345Sdim ContainsUnexpandedParameterPack), 3663243830Sdim AssocTypes(new (Context) TypeSourceInfo*[AssocTypes.size()]), 3664243830Sdim SubExprs(new (Context) Stmt*[END_EXPR+AssocExprs.size()]), 3665243830Sdim NumAssocs(AssocExprs.size()), ResultIndex(-1U), GenericLoc(GenericLoc), 3666243830Sdim DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) { 3667221345Sdim SubExprs[CONTROLLING] = ControllingExpr; 3668243830Sdim assert(AssocTypes.size() == AssocExprs.size()); 3669243830Sdim std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes); 3670243830Sdim std::copy(AssocExprs.begin(), AssocExprs.end(), SubExprs+END_EXPR); 3671221345Sdim} 3672221345Sdim 3673193326Sed//===----------------------------------------------------------------------===// 3674193326Sed// DesignatedInitExpr 3675193326Sed//===----------------------------------------------------------------------===// 3676193326Sed 3677224145SdimIdentifierInfo *DesignatedInitExpr::Designator::getFieldName() const { 3678193326Sed assert(Kind == FieldDesignator && "Only valid on a field designator"); 3679193326Sed if (Field.NameOrField & 0x01) 3680193326Sed return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01); 3681193326Sed else 3682193326Sed return getField()->getIdentifier(); 3683193326Sed} 3684193326Sed 3685263508SdimDesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty, 3686202379Srdivacky unsigned NumDesignators, 3687193326Sed const Designator *Designators, 3688198092Srdivacky SourceLocation EqualOrColonLoc, 3689193326Sed bool GNUSyntax, 3690243830Sdim ArrayRef<Expr*> IndexExprs, 3691193326Sed Expr *Init) 3692198092Srdivacky : Expr(DesignatedInitExprClass, Ty, 3693218893Sdim Init->getValueKind(), Init->getObjectKind(), 3694218893Sdim Init->isTypeDependent(), Init->isValueDependent(), 3695224145Sdim Init->isInstantiationDependent(), 3696218893Sdim Init->containsUnexpandedParameterPack()), 3697198092Srdivacky EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax), 3698243830Sdim NumDesignators(NumDesignators), NumSubExprs(IndexExprs.size() + 1) { 3699202379Srdivacky this->Designators = new (C) Designator[NumDesignators]; 3700193326Sed 3701193326Sed // Record the initializer itself. 3702218893Sdim child_range Child = children(); 3703193326Sed *Child++ = Init; 3704193326Sed 3705193326Sed // Copy the designators and their subexpressions, computing 3706193326Sed // value-dependence along the way. 3707193326Sed unsigned IndexIdx = 0; 3708193326Sed for (unsigned I = 0; I != NumDesignators; ++I) { 3709193326Sed this->Designators[I] = Designators[I]; 3710193326Sed 3711193326Sed if (this->Designators[I].isArrayDesignator()) { 3712193326Sed // Compute type- and value-dependence. 3713193326Sed Expr *Index = IndexExprs[IndexIdx]; 3714218893Sdim if (Index->isTypeDependent() || Index->isValueDependent()) 3715218893Sdim ExprBits.ValueDependent = true; 3716224145Sdim if (Index->isInstantiationDependent()) 3717224145Sdim ExprBits.InstantiationDependent = true; 3718218893Sdim // Propagate unexpanded parameter packs. 3719218893Sdim if (Index->containsUnexpandedParameterPack()) 3720218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 3721218893Sdim 3722193326Sed // Copy the index expressions into permanent storage. 3723193326Sed *Child++ = IndexExprs[IndexIdx++]; 3724193326Sed } else if (this->Designators[I].isArrayRangeDesignator()) { 3725193326Sed // Compute type- and value-dependence. 3726193326Sed Expr *Start = IndexExprs[IndexIdx]; 3727193326Sed Expr *End = IndexExprs[IndexIdx + 1]; 3728218893Sdim if (Start->isTypeDependent() || Start->isValueDependent() || 3729224145Sdim End->isTypeDependent() || End->isValueDependent()) { 3730218893Sdim ExprBits.ValueDependent = true; 3731224145Sdim ExprBits.InstantiationDependent = true; 3732224145Sdim } else if (Start->isInstantiationDependent() || 3733224145Sdim End->isInstantiationDependent()) { 3734224145Sdim ExprBits.InstantiationDependent = true; 3735224145Sdim } 3736224145Sdim 3737218893Sdim // Propagate unexpanded parameter packs. 3738218893Sdim if (Start->containsUnexpandedParameterPack() || 3739218893Sdim End->containsUnexpandedParameterPack()) 3740218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 3741218893Sdim 3742193326Sed // Copy the start/end expressions into permanent storage. 3743193326Sed *Child++ = IndexExprs[IndexIdx++]; 3744193326Sed *Child++ = IndexExprs[IndexIdx++]; 3745193326Sed } 3746193326Sed } 3747193326Sed 3748243830Sdim assert(IndexIdx == IndexExprs.size() && "Wrong number of index expressions"); 3749193326Sed} 3750193326Sed 3751193326SedDesignatedInitExpr * 3752263508SdimDesignatedInitExpr::Create(const ASTContext &C, Designator *Designators, 3753193326Sed unsigned NumDesignators, 3754243830Sdim ArrayRef<Expr*> IndexExprs, 3755193326Sed SourceLocation ColonOrEqualLoc, 3756193326Sed bool UsesColonSyntax, Expr *Init) { 3757193326Sed void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 3758243830Sdim sizeof(Stmt *) * (IndexExprs.size() + 1), 8); 3759202379Srdivacky return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators, 3760193326Sed ColonOrEqualLoc, UsesColonSyntax, 3761243830Sdim IndexExprs, Init); 3762193326Sed} 3763193326Sed 3764263508SdimDesignatedInitExpr *DesignatedInitExpr::CreateEmpty(const ASTContext &C, 3765193326Sed unsigned NumIndexExprs) { 3766193326Sed void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 3767193326Sed sizeof(Stmt *) * (NumIndexExprs + 1), 8); 3768193326Sed return new (Mem) DesignatedInitExpr(NumIndexExprs + 1); 3769193326Sed} 3770193326Sed 3771263508Sdimvoid DesignatedInitExpr::setDesignators(const ASTContext &C, 3772202379Srdivacky const Designator *Desigs, 3773193326Sed unsigned NumDesigs) { 3774202379Srdivacky Designators = new (C) Designator[NumDesigs]; 3775193326Sed NumDesignators = NumDesigs; 3776193326Sed for (unsigned I = 0; I != NumDesigs; ++I) 3777193326Sed Designators[I] = Desigs[I]; 3778193326Sed} 3779193326Sed 3780221345SdimSourceRange DesignatedInitExpr::getDesignatorsSourceRange() const { 3781221345Sdim DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this); 3782221345Sdim if (size() == 1) 3783221345Sdim return DIE->getDesignator(0)->getSourceRange(); 3784249423Sdim return SourceRange(DIE->getDesignator(0)->getLocStart(), 3785249423Sdim DIE->getDesignator(size()-1)->getLocEnd()); 3786221345Sdim} 3787221345Sdim 3788249423SdimSourceLocation DesignatedInitExpr::getLocStart() const { 3789193326Sed SourceLocation StartLoc; 3790193326Sed Designator &First = 3791193326Sed *const_cast<DesignatedInitExpr*>(this)->designators_begin(); 3792193326Sed if (First.isFieldDesignator()) { 3793193326Sed if (GNUSyntax) 3794193326Sed StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc); 3795193326Sed else 3796193326Sed StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc); 3797193326Sed } else 3798193326Sed StartLoc = 3799193326Sed SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc); 3800249423Sdim return StartLoc; 3801193326Sed} 3802193326Sed 3803249423SdimSourceLocation DesignatedInitExpr::getLocEnd() const { 3804249423Sdim return getInit()->getLocEnd(); 3805249423Sdim} 3806249423Sdim 3807249423SdimExpr *DesignatedInitExpr::getArrayIndex(const Designator& D) const { 3808193326Sed assert(D.Kind == Designator::ArrayDesignator && "Requires array designator"); 3809249423Sdim char *Ptr = static_cast<char *>( 3810249423Sdim const_cast<void *>(static_cast<const void *>(this))); 3811193326Sed Ptr += sizeof(DesignatedInitExpr); 3812193326Sed Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 3813193326Sed return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 3814193326Sed} 3815193326Sed 3816249423SdimExpr *DesignatedInitExpr::getArrayRangeStart(const Designator &D) const { 3817198092Srdivacky assert(D.Kind == Designator::ArrayRangeDesignator && 3818193326Sed "Requires array range designator"); 3819249423Sdim char *Ptr = static_cast<char *>( 3820249423Sdim const_cast<void *>(static_cast<const void *>(this))); 3821193326Sed Ptr += sizeof(DesignatedInitExpr); 3822193326Sed Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 3823193326Sed return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 3824193326Sed} 3825193326Sed 3826249423SdimExpr *DesignatedInitExpr::getArrayRangeEnd(const Designator &D) const { 3827198092Srdivacky assert(D.Kind == Designator::ArrayRangeDesignator && 3828193326Sed "Requires array range designator"); 3829249423Sdim char *Ptr = static_cast<char *>( 3830249423Sdim const_cast<void *>(static_cast<const void *>(this))); 3831193326Sed Ptr += sizeof(DesignatedInitExpr); 3832193326Sed Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 3833193326Sed return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2)); 3834193326Sed} 3835193326Sed 3836193326Sed/// \brief Replaces the designator at index @p Idx with the series 3837193326Sed/// of designators in [First, Last). 3838263508Sdimvoid DesignatedInitExpr::ExpandDesignator(const ASTContext &C, unsigned Idx, 3839198092Srdivacky const Designator *First, 3840193326Sed const Designator *Last) { 3841193326Sed unsigned NumNewDesignators = Last - First; 3842193326Sed if (NumNewDesignators == 0) { 3843193326Sed std::copy_backward(Designators + Idx + 1, 3844193326Sed Designators + NumDesignators, 3845193326Sed Designators + Idx); 3846193326Sed --NumNewDesignators; 3847193326Sed return; 3848193326Sed } else if (NumNewDesignators == 1) { 3849193326Sed Designators[Idx] = *First; 3850193326Sed return; 3851193326Sed } 3852193326Sed 3853198092Srdivacky Designator *NewDesignators 3854202379Srdivacky = new (C) Designator[NumDesignators - 1 + NumNewDesignators]; 3855193326Sed std::copy(Designators, Designators + Idx, NewDesignators); 3856193326Sed std::copy(First, Last, NewDesignators + Idx); 3857193326Sed std::copy(Designators + Idx + 1, Designators + NumDesignators, 3858193326Sed NewDesignators + Idx + NumNewDesignators); 3859193326Sed Designators = NewDesignators; 3860193326Sed NumDesignators = NumDesignators - 1 + NumNewDesignators; 3861193326Sed} 3862193326Sed 3863263508SdimParenListExpr::ParenListExpr(const ASTContext& C, SourceLocation lparenloc, 3864243830Sdim ArrayRef<Expr*> exprs, 3865234353Sdim SourceLocation rparenloc) 3866234353Sdim : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary, 3867224145Sdim false, false, false, false), 3868243830Sdim NumExprs(exprs.size()), LParenLoc(lparenloc), RParenLoc(rparenloc) { 3869243830Sdim Exprs = new (C) Stmt*[exprs.size()]; 3870243830Sdim for (unsigned i = 0; i != exprs.size(); ++i) { 3871218893Sdim if (exprs[i]->isTypeDependent()) 3872218893Sdim ExprBits.TypeDependent = true; 3873218893Sdim if (exprs[i]->isValueDependent()) 3874218893Sdim ExprBits.ValueDependent = true; 3875224145Sdim if (exprs[i]->isInstantiationDependent()) 3876224145Sdim ExprBits.InstantiationDependent = true; 3877218893Sdim if (exprs[i]->containsUnexpandedParameterPack()) 3878218893Sdim ExprBits.ContainsUnexpandedParameterPack = true; 3879218893Sdim 3880198092Srdivacky Exprs[i] = exprs[i]; 3881218893Sdim } 3882193326Sed} 3883193326Sed 3884218893Sdimconst OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) { 3885218893Sdim if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e)) 3886218893Sdim e = ewc->getSubExpr(); 3887224145Sdim if (const MaterializeTemporaryExpr *m = dyn_cast<MaterializeTemporaryExpr>(e)) 3888224145Sdim e = m->GetTemporaryExpr(); 3889218893Sdim e = cast<CXXConstructExpr>(e)->getArg(0); 3890218893Sdim while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e)) 3891218893Sdim e = ice->getSubExpr(); 3892218893Sdim return cast<OpaqueValueExpr>(e); 3893218893Sdim} 3894218893Sdim 3895263508SdimPseudoObjectExpr *PseudoObjectExpr::Create(const ASTContext &Context, 3896263508Sdim EmptyShell sh, 3897234353Sdim unsigned numSemanticExprs) { 3898234353Sdim void *buffer = Context.Allocate(sizeof(PseudoObjectExpr) + 3899234353Sdim (1 + numSemanticExprs) * sizeof(Expr*), 3900234353Sdim llvm::alignOf<PseudoObjectExpr>()); 3901234353Sdim return new(buffer) PseudoObjectExpr(sh, numSemanticExprs); 3902234353Sdim} 3903234353Sdim 3904234353SdimPseudoObjectExpr::PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs) 3905234353Sdim : Expr(PseudoObjectExprClass, shell) { 3906234353Sdim PseudoObjectExprBits.NumSubExprs = numSemanticExprs + 1; 3907234353Sdim} 3908234353Sdim 3909263508SdimPseudoObjectExpr *PseudoObjectExpr::Create(const ASTContext &C, Expr *syntax, 3910234353Sdim ArrayRef<Expr*> semantics, 3911234353Sdim unsigned resultIndex) { 3912234353Sdim assert(syntax && "no syntactic expression!"); 3913234353Sdim assert(semantics.size() && "no semantic expressions!"); 3914234353Sdim 3915234353Sdim QualType type; 3916234353Sdim ExprValueKind VK; 3917234353Sdim if (resultIndex == NoResult) { 3918234353Sdim type = C.VoidTy; 3919234353Sdim VK = VK_RValue; 3920234353Sdim } else { 3921234353Sdim assert(resultIndex < semantics.size()); 3922234353Sdim type = semantics[resultIndex]->getType(); 3923234353Sdim VK = semantics[resultIndex]->getValueKind(); 3924234353Sdim assert(semantics[resultIndex]->getObjectKind() == OK_Ordinary); 3925234353Sdim } 3926234353Sdim 3927234353Sdim void *buffer = C.Allocate(sizeof(PseudoObjectExpr) + 3928234353Sdim (1 + semantics.size()) * sizeof(Expr*), 3929234353Sdim llvm::alignOf<PseudoObjectExpr>()); 3930234353Sdim return new(buffer) PseudoObjectExpr(type, VK, syntax, semantics, 3931234353Sdim resultIndex); 3932234353Sdim} 3933234353Sdim 3934234353SdimPseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK, 3935234353Sdim Expr *syntax, ArrayRef<Expr*> semantics, 3936234353Sdim unsigned resultIndex) 3937234353Sdim : Expr(PseudoObjectExprClass, type, VK, OK_Ordinary, 3938234353Sdim /*filled in at end of ctor*/ false, false, false, false) { 3939234353Sdim PseudoObjectExprBits.NumSubExprs = semantics.size() + 1; 3940234353Sdim PseudoObjectExprBits.ResultIndex = resultIndex + 1; 3941234353Sdim 3942234353Sdim for (unsigned i = 0, e = semantics.size() + 1; i != e; ++i) { 3943234353Sdim Expr *E = (i == 0 ? syntax : semantics[i-1]); 3944234353Sdim getSubExprsBuffer()[i] = E; 3945234353Sdim 3946234353Sdim if (E->isTypeDependent()) 3947234353Sdim ExprBits.TypeDependent = true; 3948234353Sdim if (E->isValueDependent()) 3949234353Sdim ExprBits.ValueDependent = true; 3950234353Sdim if (E->isInstantiationDependent()) 3951234353Sdim ExprBits.InstantiationDependent = true; 3952234353Sdim if (E->containsUnexpandedParameterPack()) 3953234353Sdim ExprBits.ContainsUnexpandedParameterPack = true; 3954234353Sdim 3955234353Sdim if (isa<OpaqueValueExpr>(E)) 3956234353Sdim assert(cast<OpaqueValueExpr>(E)->getSourceExpr() != 0 && 3957234353Sdim "opaque-value semantic expressions for pseudo-object " 3958234353Sdim "operations must have sources"); 3959234353Sdim } 3960234353Sdim} 3961234353Sdim 3962193326Sed//===----------------------------------------------------------------------===// 3963193326Sed// ExprIterator. 3964193326Sed//===----------------------------------------------------------------------===// 3965193326Sed 3966193326SedExpr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 3967193326SedExpr* ExprIterator::operator*() const { return cast<Expr>(*I); } 3968193326SedExpr* ExprIterator::operator->() const { return cast<Expr>(*I); } 3969193326Sedconst Expr* ConstExprIterator::operator[](size_t idx) const { 3970193326Sed return cast<Expr>(I[idx]); 3971193326Sed} 3972193326Sedconst Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 3973193326Sedconst Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 3974193326Sed 3975193326Sed//===----------------------------------------------------------------------===// 3976193326Sed// Child Iterators for iterating over subexpressions/substatements 3977193326Sed//===----------------------------------------------------------------------===// 3978193326Sed 3979221345Sdim// UnaryExprOrTypeTraitExpr 3980221345SdimStmt::child_range UnaryExprOrTypeTraitExpr::children() { 3981193326Sed // If this is of a type and the type is a VLA type (and not a typedef), the 3982193326Sed // size expression of the VLA needs to be treated as an executable expression. 3983193326Sed // Why isn't this weirdness documented better in StmtIterator? 3984193326Sed if (isArgumentType()) { 3985218893Sdim if (const VariableArrayType* T = dyn_cast<VariableArrayType>( 3986193326Sed getArgumentType().getTypePtr())) 3987218893Sdim return child_range(child_iterator(T), child_iterator()); 3988218893Sdim return child_range(); 3989193326Sed } 3990218893Sdim return child_range(&Argument.Ex, &Argument.Ex + 1); 3991193326Sed} 3992193326Sed 3993193326Sed// ObjCMessageExpr 3994218893SdimStmt::child_range ObjCMessageExpr::children() { 3995218893Sdim Stmt **begin; 3996207619Srdivacky if (getReceiverKind() == Instance) 3997218893Sdim begin = reinterpret_cast<Stmt **>(this + 1); 3998218893Sdim else 3999218893Sdim begin = reinterpret_cast<Stmt **>(getArgs()); 4000218893Sdim return child_range(begin, 4001218893Sdim reinterpret_cast<Stmt **>(getArgs() + getNumArgs())); 4002193326Sed} 4003193326Sed 4004249423SdimObjCArrayLiteral::ObjCArrayLiteral(ArrayRef<Expr *> Elements, 4005234353Sdim QualType T, ObjCMethodDecl *Method, 4006234353Sdim SourceRange SR) 4007234353Sdim : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary, 4008234353Sdim false, false, false, false), 4009234353Sdim NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method) 4010218893Sdim{ 4011234353Sdim Expr **SaveElements = getElements(); 4012234353Sdim for (unsigned I = 0, N = Elements.size(); I != N; ++I) { 4013234353Sdim if (Elements[I]->isTypeDependent() || Elements[I]->isValueDependent()) 4014234353Sdim ExprBits.ValueDependent = true; 4015234353Sdim if (Elements[I]->isInstantiationDependent()) 4016234353Sdim ExprBits.InstantiationDependent = true; 4017234353Sdim if (Elements[I]->containsUnexpandedParameterPack()) 4018234353Sdim ExprBits.ContainsUnexpandedParameterPack = true; 4019234353Sdim 4020234353Sdim SaveElements[I] = Elements[I]; 4021234353Sdim } 4022218893Sdim} 4023226633Sdim 4024263508SdimObjCArrayLiteral *ObjCArrayLiteral::Create(const ASTContext &C, 4025249423Sdim ArrayRef<Expr *> Elements, 4026234353Sdim QualType T, ObjCMethodDecl * Method, 4027234353Sdim SourceRange SR) { 4028234353Sdim void *Mem = C.Allocate(sizeof(ObjCArrayLiteral) 4029234353Sdim + Elements.size() * sizeof(Expr *)); 4030234353Sdim return new (Mem) ObjCArrayLiteral(Elements, T, Method, SR); 4031234353Sdim} 4032226633Sdim 4033263508SdimObjCArrayLiteral *ObjCArrayLiteral::CreateEmpty(const ASTContext &C, 4034234353Sdim unsigned NumElements) { 4035234353Sdim 4036234353Sdim void *Mem = C.Allocate(sizeof(ObjCArrayLiteral) 4037234353Sdim + NumElements * sizeof(Expr *)); 4038234353Sdim return new (Mem) ObjCArrayLiteral(EmptyShell(), NumElements); 4039234353Sdim} 4040234353Sdim 4041234353SdimObjCDictionaryLiteral::ObjCDictionaryLiteral( 4042234353Sdim ArrayRef<ObjCDictionaryElement> VK, 4043234353Sdim bool HasPackExpansions, 4044234353Sdim QualType T, ObjCMethodDecl *method, 4045234353Sdim SourceRange SR) 4046234353Sdim : Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary, false, false, 4047234353Sdim false, false), 4048234353Sdim NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR), 4049234353Sdim DictWithObjectsMethod(method) 4050234353Sdim{ 4051234353Sdim KeyValuePair *KeyValues = getKeyValues(); 4052234353Sdim ExpansionData *Expansions = getExpansionData(); 4053234353Sdim for (unsigned I = 0; I < NumElements; I++) { 4054234353Sdim if (VK[I].Key->isTypeDependent() || VK[I].Key->isValueDependent() || 4055234353Sdim VK[I].Value->isTypeDependent() || VK[I].Value->isValueDependent()) 4056234353Sdim ExprBits.ValueDependent = true; 4057234353Sdim if (VK[I].Key->isInstantiationDependent() || 4058234353Sdim VK[I].Value->isInstantiationDependent()) 4059234353Sdim ExprBits.InstantiationDependent = true; 4060234353Sdim if (VK[I].EllipsisLoc.isInvalid() && 4061234353Sdim (VK[I].Key->containsUnexpandedParameterPack() || 4062234353Sdim VK[I].Value->containsUnexpandedParameterPack())) 4063234353Sdim ExprBits.ContainsUnexpandedParameterPack = true; 4064234353Sdim 4065234353Sdim KeyValues[I].Key = VK[I].Key; 4066234353Sdim KeyValues[I].Value = VK[I].Value; 4067234353Sdim if (Expansions) { 4068234353Sdim Expansions[I].EllipsisLoc = VK[I].EllipsisLoc; 4069234353Sdim if (VK[I].NumExpansions) 4070234353Sdim Expansions[I].NumExpansionsPlusOne = *VK[I].NumExpansions + 1; 4071234353Sdim else 4072234353Sdim Expansions[I].NumExpansionsPlusOne = 0; 4073234353Sdim } 4074234353Sdim } 4075234353Sdim} 4076234353Sdim 4077234353SdimObjCDictionaryLiteral * 4078263508SdimObjCDictionaryLiteral::Create(const ASTContext &C, 4079234353Sdim ArrayRef<ObjCDictionaryElement> VK, 4080234353Sdim bool HasPackExpansions, 4081234353Sdim QualType T, ObjCMethodDecl *method, 4082234353Sdim SourceRange SR) { 4083234353Sdim unsigned ExpansionsSize = 0; 4084234353Sdim if (HasPackExpansions) 4085234353Sdim ExpansionsSize = sizeof(ExpansionData) * VK.size(); 4086234353Sdim 4087234353Sdim void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) + 4088234353Sdim sizeof(KeyValuePair) * VK.size() + ExpansionsSize); 4089234353Sdim return new (Mem) ObjCDictionaryLiteral(VK, HasPackExpansions, T, method, SR); 4090234353Sdim} 4091234353Sdim 4092234353SdimObjCDictionaryLiteral * 4093263508SdimObjCDictionaryLiteral::CreateEmpty(const ASTContext &C, unsigned NumElements, 4094234353Sdim bool HasPackExpansions) { 4095234353Sdim unsigned ExpansionsSize = 0; 4096234353Sdim if (HasPackExpansions) 4097234353Sdim ExpansionsSize = sizeof(ExpansionData) * NumElements; 4098234353Sdim void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) + 4099234353Sdim sizeof(KeyValuePair) * NumElements + ExpansionsSize); 4100234353Sdim return new (Mem) ObjCDictionaryLiteral(EmptyShell(), NumElements, 4101234353Sdim HasPackExpansions); 4102234353Sdim} 4103234353Sdim 4104263508SdimObjCSubscriptRefExpr *ObjCSubscriptRefExpr::Create(const ASTContext &C, 4105234353Sdim Expr *base, 4106234353Sdim Expr *key, QualType T, 4107234353Sdim ObjCMethodDecl *getMethod, 4108234353Sdim ObjCMethodDecl *setMethod, 4109234353Sdim SourceLocation RB) { 4110234353Sdim void *Mem = C.Allocate(sizeof(ObjCSubscriptRefExpr)); 4111234353Sdim return new (Mem) ObjCSubscriptRefExpr(base, key, T, VK_LValue, 4112234353Sdim OK_ObjCSubscript, 4113234353Sdim getMethod, setMethod, RB); 4114234353Sdim} 4115234353Sdim 4116243830SdimAtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args, 4117226633Sdim QualType t, AtomicOp op, SourceLocation RP) 4118226633Sdim : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary, 4119226633Sdim false, false, false, false), 4120243830Sdim NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) 4121226633Sdim{ 4122243830Sdim assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions"); 4123243830Sdim for (unsigned i = 0; i != args.size(); i++) { 4124226633Sdim if (args[i]->isTypeDependent()) 4125226633Sdim ExprBits.TypeDependent = true; 4126226633Sdim if (args[i]->isValueDependent()) 4127226633Sdim ExprBits.ValueDependent = true; 4128226633Sdim if (args[i]->isInstantiationDependent()) 4129226633Sdim ExprBits.InstantiationDependent = true; 4130226633Sdim if (args[i]->containsUnexpandedParameterPack()) 4131226633Sdim ExprBits.ContainsUnexpandedParameterPack = true; 4132226633Sdim 4133226633Sdim SubExprs[i] = args[i]; 4134226633Sdim } 4135226633Sdim} 4136234353Sdim 4137234353Sdimunsigned AtomicExpr::getNumSubExprs(AtomicOp Op) { 4138234353Sdim switch (Op) { 4139234353Sdim case AO__c11_atomic_init: 4140234353Sdim case AO__c11_atomic_load: 4141234353Sdim case AO__atomic_load_n: 4142234353Sdim return 2; 4143234353Sdim 4144234353Sdim case AO__c11_atomic_store: 4145234353Sdim case AO__c11_atomic_exchange: 4146234353Sdim case AO__atomic_load: 4147234353Sdim case AO__atomic_store: 4148234353Sdim case AO__atomic_store_n: 4149234353Sdim case AO__atomic_exchange_n: 4150234353Sdim case AO__c11_atomic_fetch_add: 4151234353Sdim case AO__c11_atomic_fetch_sub: 4152234353Sdim case AO__c11_atomic_fetch_and: 4153234353Sdim case AO__c11_atomic_fetch_or: 4154234353Sdim case AO__c11_atomic_fetch_xor: 4155234353Sdim case AO__atomic_fetch_add: 4156234353Sdim case AO__atomic_fetch_sub: 4157234353Sdim case AO__atomic_fetch_and: 4158234353Sdim case AO__atomic_fetch_or: 4159234353Sdim case AO__atomic_fetch_xor: 4160234353Sdim case AO__atomic_fetch_nand: 4161234353Sdim case AO__atomic_add_fetch: 4162234353Sdim case AO__atomic_sub_fetch: 4163234353Sdim case AO__atomic_and_fetch: 4164234353Sdim case AO__atomic_or_fetch: 4165234353Sdim case AO__atomic_xor_fetch: 4166234353Sdim case AO__atomic_nand_fetch: 4167234353Sdim return 3; 4168234353Sdim 4169234353Sdim case AO__atomic_exchange: 4170234353Sdim return 4; 4171234353Sdim 4172234353Sdim case AO__c11_atomic_compare_exchange_strong: 4173234353Sdim case AO__c11_atomic_compare_exchange_weak: 4174234353Sdim return 5; 4175234353Sdim 4176234353Sdim case AO__atomic_compare_exchange: 4177234353Sdim case AO__atomic_compare_exchange_n: 4178234353Sdim return 6; 4179234353Sdim } 4180234353Sdim llvm_unreachable("unknown atomic op"); 4181234353Sdim} 4182