Expr.cpp revision 7f4f86a2167abc116275e49c81350fc3225485e5
1//===--- Expr.cpp - Expression AST Node Implementation --------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Expr class and subclasses. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/Expr.h" 15#include "clang/AST/ExprCXX.h" 16#include "clang/AST/APValue.h" 17#include "clang/AST/ASTContext.h" 18#include "clang/AST/DeclObjC.h" 19#include "clang/AST/DeclCXX.h" 20#include "clang/AST/DeclTemplate.h" 21#include "clang/AST/RecordLayout.h" 22#include "clang/AST/StmtVisitor.h" 23#include "clang/Basic/Builtins.h" 24#include "clang/Basic/TargetInfo.h" 25#include "llvm/Support/raw_ostream.h" 26#include <algorithm> 27using namespace clang; 28 29//===----------------------------------------------------------------------===// 30// Primary Expressions. 31//===----------------------------------------------------------------------===// 32 33// FIXME: Maybe this should use DeclPrinter with a special "print predefined 34// expr" policy instead. 35std::string PredefinedExpr::ComputeName(ASTContext &Context, IdentType IT, 36 const Decl *CurrentDecl) { 37 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) { 38 if (IT != PrettyFunction) 39 return FD->getNameAsString(); 40 41 llvm::SmallString<256> Name; 42 llvm::raw_svector_ostream Out(Name); 43 44 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 45 if (MD->isVirtual()) 46 Out << "virtual "; 47 } 48 49 PrintingPolicy Policy(Context.getLangOptions()); 50 Policy.SuppressTagKind = true; 51 52 std::string Proto = FD->getQualifiedNameAsString(Policy); 53 54 const FunctionType *AFT = FD->getType()->getAsFunctionType(); 55 const FunctionProtoType *FT = 0; 56 if (FD->hasWrittenPrototype()) 57 FT = dyn_cast<FunctionProtoType>(AFT); 58 59 Proto += "("; 60 if (FT) { 61 llvm::raw_string_ostream POut(Proto); 62 for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) { 63 if (i) POut << ", "; 64 std::string Param; 65 FD->getParamDecl(i)->getType().getAsStringInternal(Param, Policy); 66 POut << Param; 67 } 68 69 if (FT->isVariadic()) { 70 if (FD->getNumParams()) POut << ", "; 71 POut << "..."; 72 } 73 } 74 Proto += ")"; 75 76 AFT->getResultType().getAsStringInternal(Proto, Policy); 77 78 Out << Proto; 79 80 Out.flush(); 81 return Name.str().str(); 82 } 83 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) { 84 llvm::SmallString<256> Name; 85 llvm::raw_svector_ostream Out(Name); 86 Out << (MD->isInstanceMethod() ? '-' : '+'); 87 Out << '['; 88 Out << MD->getClassInterface()->getNameAsString(); 89 if (const ObjCCategoryImplDecl *CID = 90 dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext())) { 91 Out << '('; 92 Out << CID->getNameAsString(); 93 Out << ')'; 94 } 95 Out << ' '; 96 Out << MD->getSelector().getAsString(); 97 Out << ']'; 98 99 Out.flush(); 100 return Name.str().str(); 101 } 102 if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) { 103 // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string. 104 return "top level"; 105 } 106 return ""; 107} 108 109/// getValueAsApproximateDouble - This returns the value as an inaccurate 110/// double. Note that this may cause loss of precision, but is useful for 111/// debugging dumps, etc. 112double FloatingLiteral::getValueAsApproximateDouble() const { 113 llvm::APFloat V = getValue(); 114 bool ignored; 115 V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 116 &ignored); 117 return V.convertToDouble(); 118} 119 120StringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData, 121 unsigned ByteLength, bool Wide, 122 QualType Ty, 123 const SourceLocation *Loc, 124 unsigned NumStrs) { 125 // Allocate enough space for the StringLiteral plus an array of locations for 126 // any concatenated string tokens. 127 void *Mem = C.Allocate(sizeof(StringLiteral)+ 128 sizeof(SourceLocation)*(NumStrs-1), 129 llvm::alignof<StringLiteral>()); 130 StringLiteral *SL = new (Mem) StringLiteral(Ty); 131 132 // OPTIMIZE: could allocate this appended to the StringLiteral. 133 char *AStrData = new (C, 1) char[ByteLength]; 134 memcpy(AStrData, StrData, ByteLength); 135 SL->StrData = AStrData; 136 SL->ByteLength = ByteLength; 137 SL->IsWide = Wide; 138 SL->TokLocs[0] = Loc[0]; 139 SL->NumConcatenated = NumStrs; 140 141 if (NumStrs != 1) 142 memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1)); 143 return SL; 144} 145 146StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) { 147 void *Mem = C.Allocate(sizeof(StringLiteral)+ 148 sizeof(SourceLocation)*(NumStrs-1), 149 llvm::alignof<StringLiteral>()); 150 StringLiteral *SL = new (Mem) StringLiteral(QualType()); 151 SL->StrData = 0; 152 SL->ByteLength = 0; 153 SL->NumConcatenated = NumStrs; 154 return SL; 155} 156 157void StringLiteral::DoDestroy(ASTContext &C) { 158 C.Deallocate(const_cast<char*>(StrData)); 159 Expr::DoDestroy(C); 160} 161 162void StringLiteral::setStrData(ASTContext &C, const char *Str, unsigned Len) { 163 if (StrData) 164 C.Deallocate(const_cast<char*>(StrData)); 165 166 char *AStrData = new (C, 1) char[Len]; 167 memcpy(AStrData, Str, Len); 168 StrData = AStrData; 169 ByteLength = Len; 170} 171 172/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 173/// corresponds to, e.g. "sizeof" or "[pre]++". 174const char *UnaryOperator::getOpcodeStr(Opcode Op) { 175 switch (Op) { 176 default: assert(0 && "Unknown unary operator"); 177 case PostInc: return "++"; 178 case PostDec: return "--"; 179 case PreInc: return "++"; 180 case PreDec: return "--"; 181 case AddrOf: return "&"; 182 case Deref: return "*"; 183 case Plus: return "+"; 184 case Minus: return "-"; 185 case Not: return "~"; 186 case LNot: return "!"; 187 case Real: return "__real"; 188 case Imag: return "__imag"; 189 case Extension: return "__extension__"; 190 case OffsetOf: return "__builtin_offsetof"; 191 } 192} 193 194UnaryOperator::Opcode 195UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) { 196 switch (OO) { 197 default: assert(false && "No unary operator for overloaded function"); 198 case OO_PlusPlus: return Postfix ? PostInc : PreInc; 199 case OO_MinusMinus: return Postfix ? PostDec : PreDec; 200 case OO_Amp: return AddrOf; 201 case OO_Star: return Deref; 202 case OO_Plus: return Plus; 203 case OO_Minus: return Minus; 204 case OO_Tilde: return Not; 205 case OO_Exclaim: return LNot; 206 } 207} 208 209OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) { 210 switch (Opc) { 211 case PostInc: case PreInc: return OO_PlusPlus; 212 case PostDec: case PreDec: return OO_MinusMinus; 213 case AddrOf: return OO_Amp; 214 case Deref: return OO_Star; 215 case Plus: return OO_Plus; 216 case Minus: return OO_Minus; 217 case Not: return OO_Tilde; 218 case LNot: return OO_Exclaim; 219 default: return OO_None; 220 } 221} 222 223 224//===----------------------------------------------------------------------===// 225// Postfix Operators. 226//===----------------------------------------------------------------------===// 227 228CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args, 229 unsigned numargs, QualType t, SourceLocation rparenloc) 230 : Expr(SC, t, 231 fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 232 fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 233 NumArgs(numargs) { 234 235 SubExprs = new (C) Stmt*[numargs+1]; 236 SubExprs[FN] = fn; 237 for (unsigned i = 0; i != numargs; ++i) 238 SubExprs[i+ARGS_START] = args[i]; 239 240 RParenLoc = rparenloc; 241} 242 243CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs, 244 QualType t, SourceLocation rparenloc) 245 : Expr(CallExprClass, t, 246 fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 247 fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 248 NumArgs(numargs) { 249 250 SubExprs = new (C) Stmt*[numargs+1]; 251 SubExprs[FN] = fn; 252 for (unsigned i = 0; i != numargs; ++i) 253 SubExprs[i+ARGS_START] = args[i]; 254 255 RParenLoc = rparenloc; 256} 257 258CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty) 259 : Expr(SC, Empty), SubExprs(0), NumArgs(0) { 260 SubExprs = new (C) Stmt*[1]; 261} 262 263void CallExpr::DoDestroy(ASTContext& C) { 264 DestroyChildren(C); 265 if (SubExprs) C.Deallocate(SubExprs); 266 this->~CallExpr(); 267 C.Deallocate(this); 268} 269 270FunctionDecl *CallExpr::getDirectCallee() { 271 Expr *CEE = getCallee()->IgnoreParenCasts(); 272 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) 273 return dyn_cast<FunctionDecl>(DRE->getDecl()); 274 275 return 0; 276} 277 278/// setNumArgs - This changes the number of arguments present in this call. 279/// Any orphaned expressions are deleted by this, and any new operands are set 280/// to null. 281void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) { 282 // No change, just return. 283 if (NumArgs == getNumArgs()) return; 284 285 // If shrinking # arguments, just delete the extras and forgot them. 286 if (NumArgs < getNumArgs()) { 287 for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 288 getArg(i)->Destroy(C); 289 this->NumArgs = NumArgs; 290 return; 291 } 292 293 // Otherwise, we are growing the # arguments. New an bigger argument array. 294 Stmt **NewSubExprs = new (C) Stmt*[NumArgs+1]; 295 // Copy over args. 296 for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 297 NewSubExprs[i] = SubExprs[i]; 298 // Null out new args. 299 for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 300 NewSubExprs[i] = 0; 301 302 if (SubExprs) C.Deallocate(SubExprs); 303 SubExprs = NewSubExprs; 304 this->NumArgs = NumArgs; 305} 306 307/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If 308/// not, return 0. 309unsigned CallExpr::isBuiltinCall(ASTContext &Context) const { 310 // All simple function calls (e.g. func()) are implicitly cast to pointer to 311 // function. As a result, we try and obtain the DeclRefExpr from the 312 // ImplicitCastExpr. 313 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 314 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 315 return 0; 316 317 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 318 if (!DRE) 319 return 0; 320 321 const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 322 if (!FDecl) 323 return 0; 324 325 if (!FDecl->getIdentifier()) 326 return 0; 327 328 return FDecl->getBuiltinID(Context); 329} 330 331QualType CallExpr::getCallReturnType() const { 332 QualType CalleeType = getCallee()->getType(); 333 if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>()) 334 CalleeType = FnTypePtr->getPointeeType(); 335 else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>()) 336 CalleeType = BPT->getPointeeType(); 337 338 const FunctionType *FnType = CalleeType->getAsFunctionType(); 339 return FnType->getResultType(); 340} 341 342MemberExpr::MemberExpr(Expr *base, bool isarrow, NestedNameSpecifier *qual, 343 SourceRange qualrange, NamedDecl *memberdecl, 344 SourceLocation l, bool has_explicit, 345 SourceLocation langle, 346 const TemplateArgument *targs, unsigned numtargs, 347 SourceLocation rangle, QualType ty) 348 : Expr(MemberExprClass, ty, 349 base->isTypeDependent() || (qual && qual->isDependent()), 350 base->isValueDependent() || (qual && qual->isDependent())), 351 Base(base), MemberDecl(memberdecl), MemberLoc(l), IsArrow(isarrow), 352 HasQualifier(qual != 0), HasExplicitTemplateArgumentList(has_explicit) { 353 // Initialize the qualifier, if any. 354 if (HasQualifier) { 355 NameQualifier *NQ = getMemberQualifier(); 356 NQ->NNS = qual; 357 NQ->Range = qualrange; 358 } 359 360 // Initialize the explicit template argument list, if any. 361 if (HasExplicitTemplateArgumentList) { 362 ExplicitTemplateArgumentList *ETemplateArgs 363 = getExplicitTemplateArgumentList(); 364 ETemplateArgs->LAngleLoc = langle; 365 ETemplateArgs->RAngleLoc = rangle; 366 ETemplateArgs->NumTemplateArgs = numtargs; 367 368 TemplateArgument *TemplateArgs = ETemplateArgs->getTemplateArgs(); 369 for (unsigned I = 0; I < numtargs; ++I) 370 new (TemplateArgs + I) TemplateArgument(targs[I]); 371 } 372} 373 374MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow, 375 NestedNameSpecifier *qual, 376 SourceRange qualrange, 377 NamedDecl *memberdecl, 378 SourceLocation l, 379 bool has_explicit, 380 SourceLocation langle, 381 const TemplateArgument *targs, 382 unsigned numtargs, 383 SourceLocation rangle, 384 QualType ty) { 385 std::size_t Size = sizeof(MemberExpr); 386 if (qual != 0) 387 Size += sizeof(NameQualifier); 388 389 if (has_explicit) 390 Size += sizeof(ExplicitTemplateArgumentList) + 391 sizeof(TemplateArgument) * numtargs; 392 393 void *Mem = C.Allocate(Size, llvm::alignof<MemberExpr>()); 394 return new (Mem) MemberExpr(base, isarrow, qual, qualrange, memberdecl, l, 395 has_explicit, langle, targs, numtargs, rangle, 396 ty); 397} 398 399const char *CastExpr::getCastKindName() const { 400 switch (getCastKind()) { 401 case CastExpr::CK_Unknown: 402 return "Unknown"; 403 case CastExpr::CK_BitCast: 404 return "BitCast"; 405 case CastExpr::CK_NoOp: 406 return "NoOp"; 407 case CastExpr::CK_DerivedToBase: 408 return "DerivedToBase"; 409 case CastExpr::CK_Dynamic: 410 return "Dynamic"; 411 case CastExpr::CK_ToUnion: 412 return "ToUnion"; 413 case CastExpr::CK_ArrayToPointerDecay: 414 return "ArrayToPointerDecay"; 415 case CastExpr::CK_FunctionToPointerDecay: 416 return "FunctionToPointerDecay"; 417 case CastExpr::CK_NullToMemberPointer: 418 return "NullToMemberPointer"; 419 case CastExpr::CK_BaseToDerivedMemberPointer: 420 return "BaseToDerivedMemberPointer"; 421 case CastExpr::CK_UserDefinedConversion: 422 return "UserDefinedConversion"; 423 case CastExpr::CK_ConstructorConversion: 424 return "ConstructorConversion"; 425 } 426 427 assert(0 && "Unhandled cast kind!"); 428 return 0; 429} 430 431/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 432/// corresponds to, e.g. "<<=". 433const char *BinaryOperator::getOpcodeStr(Opcode Op) { 434 switch (Op) { 435 case PtrMemD: return ".*"; 436 case PtrMemI: return "->*"; 437 case Mul: return "*"; 438 case Div: return "/"; 439 case Rem: return "%"; 440 case Add: return "+"; 441 case Sub: return "-"; 442 case Shl: return "<<"; 443 case Shr: return ">>"; 444 case LT: return "<"; 445 case GT: return ">"; 446 case LE: return "<="; 447 case GE: return ">="; 448 case EQ: return "=="; 449 case NE: return "!="; 450 case And: return "&"; 451 case Xor: return "^"; 452 case Or: return "|"; 453 case LAnd: return "&&"; 454 case LOr: return "||"; 455 case Assign: return "="; 456 case MulAssign: return "*="; 457 case DivAssign: return "/="; 458 case RemAssign: return "%="; 459 case AddAssign: return "+="; 460 case SubAssign: return "-="; 461 case ShlAssign: return "<<="; 462 case ShrAssign: return ">>="; 463 case AndAssign: return "&="; 464 case XorAssign: return "^="; 465 case OrAssign: return "|="; 466 case Comma: return ","; 467 } 468 469 return ""; 470} 471 472BinaryOperator::Opcode 473BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) { 474 switch (OO) { 475 default: assert(false && "Not an overloadable binary operator"); 476 case OO_Plus: return Add; 477 case OO_Minus: return Sub; 478 case OO_Star: return Mul; 479 case OO_Slash: return Div; 480 case OO_Percent: return Rem; 481 case OO_Caret: return Xor; 482 case OO_Amp: return And; 483 case OO_Pipe: return Or; 484 case OO_Equal: return Assign; 485 case OO_Less: return LT; 486 case OO_Greater: return GT; 487 case OO_PlusEqual: return AddAssign; 488 case OO_MinusEqual: return SubAssign; 489 case OO_StarEqual: return MulAssign; 490 case OO_SlashEqual: return DivAssign; 491 case OO_PercentEqual: return RemAssign; 492 case OO_CaretEqual: return XorAssign; 493 case OO_AmpEqual: return AndAssign; 494 case OO_PipeEqual: return OrAssign; 495 case OO_LessLess: return Shl; 496 case OO_GreaterGreater: return Shr; 497 case OO_LessLessEqual: return ShlAssign; 498 case OO_GreaterGreaterEqual: return ShrAssign; 499 case OO_EqualEqual: return EQ; 500 case OO_ExclaimEqual: return NE; 501 case OO_LessEqual: return LE; 502 case OO_GreaterEqual: return GE; 503 case OO_AmpAmp: return LAnd; 504 case OO_PipePipe: return LOr; 505 case OO_Comma: return Comma; 506 case OO_ArrowStar: return PtrMemI; 507 } 508} 509 510OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) { 511 static const OverloadedOperatorKind OverOps[] = { 512 /* .* Cannot be overloaded */OO_None, OO_ArrowStar, 513 OO_Star, OO_Slash, OO_Percent, 514 OO_Plus, OO_Minus, 515 OO_LessLess, OO_GreaterGreater, 516 OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual, 517 OO_EqualEqual, OO_ExclaimEqual, 518 OO_Amp, 519 OO_Caret, 520 OO_Pipe, 521 OO_AmpAmp, 522 OO_PipePipe, 523 OO_Equal, OO_StarEqual, 524 OO_SlashEqual, OO_PercentEqual, 525 OO_PlusEqual, OO_MinusEqual, 526 OO_LessLessEqual, OO_GreaterGreaterEqual, 527 OO_AmpEqual, OO_CaretEqual, 528 OO_PipeEqual, 529 OO_Comma 530 }; 531 return OverOps[Opc]; 532} 533 534InitListExpr::InitListExpr(SourceLocation lbraceloc, 535 Expr **initExprs, unsigned numInits, 536 SourceLocation rbraceloc) 537 : Expr(InitListExprClass, QualType(), 538 hasAnyTypeDependentArguments(initExprs, numInits), 539 hasAnyValueDependentArguments(initExprs, numInits)), 540 LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0), 541 UnionFieldInit(0), HadArrayRangeDesignator(false) { 542 543 InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits); 544} 545 546void InitListExpr::reserveInits(unsigned NumInits) { 547 if (NumInits > InitExprs.size()) 548 InitExprs.reserve(NumInits); 549} 550 551void InitListExpr::resizeInits(ASTContext &Context, unsigned NumInits) { 552 for (unsigned Idx = NumInits, LastIdx = InitExprs.size(); 553 Idx < LastIdx; ++Idx) 554 InitExprs[Idx]->Destroy(Context); 555 InitExprs.resize(NumInits, 0); 556} 557 558Expr *InitListExpr::updateInit(unsigned Init, Expr *expr) { 559 if (Init >= InitExprs.size()) { 560 InitExprs.insert(InitExprs.end(), Init - InitExprs.size() + 1, 0); 561 InitExprs.back() = expr; 562 return 0; 563 } 564 565 Expr *Result = cast_or_null<Expr>(InitExprs[Init]); 566 InitExprs[Init] = expr; 567 return Result; 568} 569 570/// getFunctionType - Return the underlying function type for this block. 571/// 572const FunctionType *BlockExpr::getFunctionType() const { 573 return getType()->getAs<BlockPointerType>()-> 574 getPointeeType()->getAsFunctionType(); 575} 576 577SourceLocation BlockExpr::getCaretLocation() const { 578 return TheBlock->getCaretLocation(); 579} 580const Stmt *BlockExpr::getBody() const { 581 return TheBlock->getBody(); 582} 583Stmt *BlockExpr::getBody() { 584 return TheBlock->getBody(); 585} 586 587 588//===----------------------------------------------------------------------===// 589// Generic Expression Routines 590//===----------------------------------------------------------------------===// 591 592/// isUnusedResultAWarning - Return true if this immediate expression should 593/// be warned about if the result is unused. If so, fill in Loc and Ranges 594/// with location to warn on and the source range[s] to report with the 595/// warning. 596bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1, 597 SourceRange &R2) const { 598 // Don't warn if the expr is type dependent. The type could end up 599 // instantiating to void. 600 if (isTypeDependent()) 601 return false; 602 603 switch (getStmtClass()) { 604 default: 605 Loc = getExprLoc(); 606 R1 = getSourceRange(); 607 return true; 608 case ParenExprClass: 609 return cast<ParenExpr>(this)->getSubExpr()-> 610 isUnusedResultAWarning(Loc, R1, R2); 611 case UnaryOperatorClass: { 612 const UnaryOperator *UO = cast<UnaryOperator>(this); 613 614 switch (UO->getOpcode()) { 615 default: break; 616 case UnaryOperator::PostInc: 617 case UnaryOperator::PostDec: 618 case UnaryOperator::PreInc: 619 case UnaryOperator::PreDec: // ++/-- 620 return false; // Not a warning. 621 case UnaryOperator::Deref: 622 // Dereferencing a volatile pointer is a side-effect. 623 if (getType().isVolatileQualified()) 624 return false; 625 break; 626 case UnaryOperator::Real: 627 case UnaryOperator::Imag: 628 // accessing a piece of a volatile complex is a side-effect. 629 if (UO->getSubExpr()->getType().isVolatileQualified()) 630 return false; 631 break; 632 case UnaryOperator::Extension: 633 return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 634 } 635 Loc = UO->getOperatorLoc(); 636 R1 = UO->getSubExpr()->getSourceRange(); 637 return true; 638 } 639 case BinaryOperatorClass: { 640 const BinaryOperator *BO = cast<BinaryOperator>(this); 641 // Consider comma to have side effects if the LHS or RHS does. 642 if (BO->getOpcode() == BinaryOperator::Comma) 643 return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2) || 644 BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2); 645 646 if (BO->isAssignmentOp()) 647 return false; 648 Loc = BO->getOperatorLoc(); 649 R1 = BO->getLHS()->getSourceRange(); 650 R2 = BO->getRHS()->getSourceRange(); 651 return true; 652 } 653 case CompoundAssignOperatorClass: 654 return false; 655 656 case ConditionalOperatorClass: { 657 // The condition must be evaluated, but if either the LHS or RHS is a 658 // warning, warn about them. 659 const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 660 if (Exp->getLHS() && 661 Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2)) 662 return true; 663 return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2); 664 } 665 666 case MemberExprClass: 667 // If the base pointer or element is to a volatile pointer/field, accessing 668 // it is a side effect. 669 if (getType().isVolatileQualified()) 670 return false; 671 Loc = cast<MemberExpr>(this)->getMemberLoc(); 672 R1 = SourceRange(Loc, Loc); 673 R2 = cast<MemberExpr>(this)->getBase()->getSourceRange(); 674 return true; 675 676 case ArraySubscriptExprClass: 677 // If the base pointer or element is to a volatile pointer/field, accessing 678 // it is a side effect. 679 if (getType().isVolatileQualified()) 680 return false; 681 Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc(); 682 R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange(); 683 R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange(); 684 return true; 685 686 case CallExprClass: 687 case CXXOperatorCallExprClass: 688 case CXXMemberCallExprClass: { 689 // If this is a direct call, get the callee. 690 const CallExpr *CE = cast<CallExpr>(this); 691 const Expr *CalleeExpr = CE->getCallee()->IgnoreParenCasts(); 692 if (const DeclRefExpr *CalleeDRE = dyn_cast<DeclRefExpr>(CalleeExpr)) { 693 // If the callee has attribute pure, const, or warn_unused_result, warn 694 // about it. void foo() { strlen("bar"); } should warn. 695 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CalleeDRE->getDecl())) 696 if (FD->getAttr<WarnUnusedResultAttr>() || 697 FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) { 698 Loc = CE->getCallee()->getLocStart(); 699 R1 = CE->getCallee()->getSourceRange(); 700 701 if (unsigned NumArgs = CE->getNumArgs()) 702 R2 = SourceRange(CE->getArg(0)->getLocStart(), 703 CE->getArg(NumArgs-1)->getLocEnd()); 704 return true; 705 } 706 } 707 return false; 708 } 709 case ObjCMessageExprClass: 710 return false; 711 712 case ObjCImplicitSetterGetterRefExprClass: { // Dot syntax for message send. 713#if 0 714 const ObjCImplicitSetterGetterRefExpr *Ref = 715 cast<ObjCImplicitSetterGetterRefExpr>(this); 716 // FIXME: We really want the location of the '.' here. 717 Loc = Ref->getLocation(); 718 R1 = SourceRange(Ref->getLocation(), Ref->getLocation()); 719 if (Ref->getBase()) 720 R2 = Ref->getBase()->getSourceRange(); 721#else 722 Loc = getExprLoc(); 723 R1 = getSourceRange(); 724#endif 725 return true; 726 } 727 case StmtExprClass: { 728 // Statement exprs don't logically have side effects themselves, but are 729 // sometimes used in macros in ways that give them a type that is unused. 730 // For example ({ blah; foo(); }) will end up with a type if foo has a type. 731 // however, if the result of the stmt expr is dead, we don't want to emit a 732 // warning. 733 const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 734 if (!CS->body_empty()) 735 if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 736 return E->isUnusedResultAWarning(Loc, R1, R2); 737 738 Loc = cast<StmtExpr>(this)->getLParenLoc(); 739 R1 = getSourceRange(); 740 return true; 741 } 742 case CStyleCastExprClass: 743 // If this is an explicit cast to void, allow it. People do this when they 744 // think they know what they're doing :). 745 if (getType()->isVoidType()) 746 return false; 747 Loc = cast<CStyleCastExpr>(this)->getLParenLoc(); 748 R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange(); 749 return true; 750 case CXXFunctionalCastExprClass: 751 // If this is a cast to void, check the operand. Otherwise, the result of 752 // the cast is unused. 753 if (getType()->isVoidType()) 754 return cast<CastExpr>(this)->getSubExpr() 755 ->isUnusedResultAWarning(Loc, R1, R2); 756 Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc(); 757 R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange(); 758 return true; 759 760 case ImplicitCastExprClass: 761 // Check the operand, since implicit casts are inserted by Sema 762 return cast<ImplicitCastExpr>(this) 763 ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 764 765 case CXXDefaultArgExprClass: 766 return cast<CXXDefaultArgExpr>(this) 767 ->getExpr()->isUnusedResultAWarning(Loc, R1, R2); 768 769 case CXXNewExprClass: 770 // FIXME: In theory, there might be new expressions that don't have side 771 // effects (e.g. a placement new with an uninitialized POD). 772 case CXXDeleteExprClass: 773 return false; 774 case CXXBindTemporaryExprClass: 775 return cast<CXXBindTemporaryExpr>(this) 776 ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 777 case CXXExprWithTemporariesClass: 778 return cast<CXXExprWithTemporaries>(this) 779 ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 780 } 781} 782 783/// DeclCanBeLvalue - Determine whether the given declaration can be 784/// an lvalue. This is a helper routine for isLvalue. 785static bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) { 786 // C++ [temp.param]p6: 787 // A non-type non-reference template-parameter is not an lvalue. 788 if (const NonTypeTemplateParmDecl *NTTParm 789 = dyn_cast<NonTypeTemplateParmDecl>(Decl)) 790 return NTTParm->getType()->isReferenceType(); 791 792 return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) || 793 // C++ 3.10p2: An lvalue refers to an object or function. 794 (Ctx.getLangOptions().CPlusPlus && 795 (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl) || 796 isa<FunctionTemplateDecl>(Decl))); 797} 798 799/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 800/// incomplete type other than void. Nonarray expressions that can be lvalues: 801/// - name, where name must be a variable 802/// - e[i] 803/// - (e), where e must be an lvalue 804/// - e.name, where e must be an lvalue 805/// - e->name 806/// - *e, the type of e cannot be a function type 807/// - string-constant 808/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 809/// - reference type [C++ [expr]] 810/// 811Expr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const { 812 assert(!TR->isReferenceType() && "Expressions can't have reference type."); 813 814 isLvalueResult Res = isLvalueInternal(Ctx); 815 if (Res != LV_Valid || Ctx.getLangOptions().CPlusPlus) 816 return Res; 817 818 // first, check the type (C99 6.3.2.1). Expressions with function 819 // type in C are not lvalues, but they can be lvalues in C++. 820 if (TR->isFunctionType() || TR == Ctx.OverloadTy) 821 return LV_NotObjectType; 822 823 // Allow qualified void which is an incomplete type other than void (yuck). 824 if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers()) 825 return LV_IncompleteVoidType; 826 827 return LV_Valid; 828} 829 830// Check whether the expression can be sanely treated like an l-value 831Expr::isLvalueResult Expr::isLvalueInternal(ASTContext &Ctx) const { 832 switch (getStmtClass()) { 833 case StringLiteralClass: // C99 6.5.1p4 834 case ObjCEncodeExprClass: // @encode behaves like its string in every way. 835 return LV_Valid; 836 case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 837 // For vectors, make sure base is an lvalue (i.e. not a function call). 838 if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 839 return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx); 840 return LV_Valid; 841 case DeclRefExprClass: 842 case QualifiedDeclRefExprClass: { // C99 6.5.1p2 843 const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl(); 844 if (DeclCanBeLvalue(RefdDecl, Ctx)) 845 return LV_Valid; 846 break; 847 } 848 case BlockDeclRefExprClass: { 849 const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 850 if (isa<VarDecl>(BDR->getDecl())) 851 return LV_Valid; 852 break; 853 } 854 case MemberExprClass: { 855 const MemberExpr *m = cast<MemberExpr>(this); 856 if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4: 857 NamedDecl *Member = m->getMemberDecl(); 858 // C++ [expr.ref]p4: 859 // If E2 is declared to have type "reference to T", then E1.E2 860 // is an lvalue. 861 if (ValueDecl *Value = dyn_cast<ValueDecl>(Member)) 862 if (Value->getType()->isReferenceType()) 863 return LV_Valid; 864 865 // -- If E2 is a static data member [...] then E1.E2 is an lvalue. 866 if (isa<VarDecl>(Member) && Member->getDeclContext()->isRecord()) 867 return LV_Valid; 868 869 // -- If E2 is a non-static data member [...]. If E1 is an 870 // lvalue, then E1.E2 is an lvalue. 871 if (isa<FieldDecl>(Member)) 872 return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 873 874 // -- If it refers to a static member function [...], then 875 // E1.E2 is an lvalue. 876 // -- Otherwise, if E1.E2 refers to a non-static member 877 // function [...], then E1.E2 is not an lvalue. 878 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) 879 return Method->isStatic()? LV_Valid : LV_MemberFunction; 880 881 // -- If E2 is a member enumerator [...], the expression E1.E2 882 // is not an lvalue. 883 if (isa<EnumConstantDecl>(Member)) 884 return LV_InvalidExpression; 885 886 // Not an lvalue. 887 return LV_InvalidExpression; 888 } 889 890 // C99 6.5.2.3p4 891 return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 892 } 893 case UnaryOperatorClass: 894 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 895 return LV_Valid; // C99 6.5.3p4 896 897 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 898 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag || 899 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension) 900 return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU. 901 902 if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1 903 (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc || 904 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec)) 905 return LV_Valid; 906 break; 907 case ImplicitCastExprClass: 908 return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid 909 : LV_InvalidExpression; 910 case ParenExprClass: // C99 6.5.1p5 911 return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx); 912 case BinaryOperatorClass: 913 case CompoundAssignOperatorClass: { 914 const BinaryOperator *BinOp = cast<BinaryOperator>(this); 915 916 if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1 917 BinOp->getOpcode() == BinaryOperator::Comma) 918 return BinOp->getRHS()->isLvalue(Ctx); 919 920 // C++ [expr.mptr.oper]p6 921 if ((BinOp->getOpcode() == BinaryOperator::PtrMemD || 922 BinOp->getOpcode() == BinaryOperator::PtrMemI) && 923 !BinOp->getType()->isFunctionType()) 924 return BinOp->getLHS()->isLvalue(Ctx); 925 926 if (!BinOp->isAssignmentOp()) 927 return LV_InvalidExpression; 928 929 if (Ctx.getLangOptions().CPlusPlus) 930 // C++ [expr.ass]p1: 931 // The result of an assignment operation [...] is an lvalue. 932 return LV_Valid; 933 934 935 // C99 6.5.16: 936 // An assignment expression [...] is not an lvalue. 937 return LV_InvalidExpression; 938 } 939 case CallExprClass: 940 case CXXOperatorCallExprClass: 941 case CXXMemberCallExprClass: { 942 // C++0x [expr.call]p10 943 // A function call is an lvalue if and only if the result type 944 // is an lvalue reference. 945 QualType ReturnType = cast<CallExpr>(this)->getCallReturnType(); 946 if (ReturnType->isLValueReferenceType()) 947 return LV_Valid; 948 949 break; 950 } 951 case CompoundLiteralExprClass: // C99 6.5.2.5p5 952 return LV_Valid; 953 case ChooseExprClass: 954 // __builtin_choose_expr is an lvalue if the selected operand is. 955 return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)->isLvalue(Ctx); 956 case ExtVectorElementExprClass: 957 if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 958 return LV_DuplicateVectorComponents; 959 return LV_Valid; 960 case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 961 return LV_Valid; 962 case ObjCPropertyRefExprClass: // FIXME: check if read-only property. 963 return LV_Valid; 964 case ObjCImplicitSetterGetterRefExprClass: // FIXME: check if read-only property. 965 return LV_Valid; 966 case PredefinedExprClass: 967 return LV_Valid; 968 case CXXDefaultArgExprClass: 969 return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx); 970 case CXXConditionDeclExprClass: 971 return LV_Valid; 972 case CStyleCastExprClass: 973 case CXXFunctionalCastExprClass: 974 case CXXStaticCastExprClass: 975 case CXXDynamicCastExprClass: 976 case CXXReinterpretCastExprClass: 977 case CXXConstCastExprClass: 978 // The result of an explicit cast is an lvalue if the type we are 979 // casting to is an lvalue reference type. See C++ [expr.cast]p1, 980 // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2, 981 // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1. 982 if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()-> 983 isLValueReferenceType()) 984 return LV_Valid; 985 break; 986 case CXXTypeidExprClass: 987 // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ... 988 return LV_Valid; 989 case CXXBindTemporaryExprClass: 990 return cast<CXXBindTemporaryExpr>(this)->getSubExpr()-> 991 isLvalueInternal(Ctx); 992 case ConditionalOperatorClass: { 993 // Complicated handling is only for C++. 994 if (!Ctx.getLangOptions().CPlusPlus) 995 return LV_InvalidExpression; 996 997 // Sema should have taken care to ensure that a CXXTemporaryObjectExpr is 998 // everywhere there's an object converted to an rvalue. Also, any other 999 // casts should be wrapped by ImplicitCastExprs. There's just the special 1000 // case involving throws to work out. 1001 const ConditionalOperator *Cond = cast<ConditionalOperator>(this); 1002 Expr *True = Cond->getTrueExpr(); 1003 Expr *False = Cond->getFalseExpr(); 1004 // C++0x 5.16p2 1005 // If either the second or the third operand has type (cv) void, [...] 1006 // the result [...] is an rvalue. 1007 if (True->getType()->isVoidType() || False->getType()->isVoidType()) 1008 return LV_InvalidExpression; 1009 1010 // Both sides must be lvalues for the result to be an lvalue. 1011 if (True->isLvalue(Ctx) != LV_Valid || False->isLvalue(Ctx) != LV_Valid) 1012 return LV_InvalidExpression; 1013 1014 // That's it. 1015 return LV_Valid; 1016 } 1017 1018 default: 1019 break; 1020 } 1021 return LV_InvalidExpression; 1022} 1023 1024/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 1025/// does not have an incomplete type, does not have a const-qualified type, and 1026/// if it is a structure or union, does not have any member (including, 1027/// recursively, any member or element of all contained aggregates or unions) 1028/// with a const-qualified type. 1029Expr::isModifiableLvalueResult 1030Expr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const { 1031 isLvalueResult lvalResult = isLvalue(Ctx); 1032 1033 switch (lvalResult) { 1034 case LV_Valid: 1035 // C++ 3.10p11: Functions cannot be modified, but pointers to 1036 // functions can be modifiable. 1037 if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 1038 return MLV_NotObjectType; 1039 break; 1040 1041 case LV_NotObjectType: return MLV_NotObjectType; 1042 case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 1043 case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 1044 case LV_InvalidExpression: 1045 // If the top level is a C-style cast, and the subexpression is a valid 1046 // lvalue, then this is probably a use of the old-school "cast as lvalue" 1047 // GCC extension. We don't support it, but we want to produce good 1048 // diagnostics when it happens so that the user knows why. 1049 if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(IgnoreParens())) { 1050 if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) { 1051 if (Loc) 1052 *Loc = CE->getLParenLoc(); 1053 return MLV_LValueCast; 1054 } 1055 } 1056 return MLV_InvalidExpression; 1057 case LV_MemberFunction: return MLV_MemberFunction; 1058 } 1059 1060 // The following is illegal: 1061 // void takeclosure(void (^C)(void)); 1062 // void func() { int x = 1; takeclosure(^{ x = 7; }); } 1063 // 1064 if (isa<BlockDeclRefExpr>(this)) { 1065 const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 1066 if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl())) 1067 return MLV_NotBlockQualified; 1068 } 1069 1070 QualType CT = Ctx.getCanonicalType(getType()); 1071 1072 if (CT.isConstQualified()) 1073 return MLV_ConstQualified; 1074 if (CT->isArrayType()) 1075 return MLV_ArrayType; 1076 if (CT->isIncompleteType()) 1077 return MLV_IncompleteType; 1078 1079 if (const RecordType *r = CT->getAs<RecordType>()) { 1080 if (r->hasConstFields()) 1081 return MLV_ConstQualified; 1082 } 1083 1084 // Assigning to an 'implicit' property? 1085 else if (isa<ObjCImplicitSetterGetterRefExpr>(this)) { 1086 const ObjCImplicitSetterGetterRefExpr* Expr = 1087 cast<ObjCImplicitSetterGetterRefExpr>(this); 1088 if (Expr->getSetterMethod() == 0) 1089 return MLV_NoSetterProperty; 1090 } 1091 return MLV_Valid; 1092} 1093 1094/// isOBJCGCCandidate - Check if an expression is objc gc'able. 1095/// returns true, if it is; false otherwise. 1096bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const { 1097 switch (getStmtClass()) { 1098 default: 1099 return false; 1100 case ObjCIvarRefExprClass: 1101 return true; 1102 case Expr::UnaryOperatorClass: 1103 return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate(Ctx); 1104 case ParenExprClass: 1105 return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx); 1106 case ImplicitCastExprClass: 1107 return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx); 1108 case CStyleCastExprClass: 1109 return cast<CStyleCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx); 1110 case DeclRefExprClass: 1111 case QualifiedDeclRefExprClass: { 1112 const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 1113 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1114 if (VD->hasGlobalStorage()) 1115 return true; 1116 QualType T = VD->getType(); 1117 // dereferencing to a pointer is always a gc'able candidate 1118 return T->isPointerType(); 1119 } 1120 return false; 1121 } 1122 case MemberExprClass: { 1123 const MemberExpr *M = cast<MemberExpr>(this); 1124 return M->getBase()->isOBJCGCCandidate(Ctx); 1125 } 1126 case ArraySubscriptExprClass: 1127 return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate(Ctx); 1128 } 1129} 1130Expr* Expr::IgnoreParens() { 1131 Expr* E = this; 1132 while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 1133 E = P->getSubExpr(); 1134 1135 return E; 1136} 1137 1138/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 1139/// or CastExprs or ImplicitCastExprs, returning their operand. 1140Expr *Expr::IgnoreParenCasts() { 1141 Expr *E = this; 1142 while (true) { 1143 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 1144 E = P->getSubExpr(); 1145 else if (CastExpr *P = dyn_cast<CastExpr>(E)) 1146 E = P->getSubExpr(); 1147 else 1148 return E; 1149 } 1150} 1151 1152/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the 1153/// value (including ptr->int casts of the same size). Strip off any 1154/// ParenExpr or CastExprs, returning their operand. 1155Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) { 1156 Expr *E = this; 1157 while (true) { 1158 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) { 1159 E = P->getSubExpr(); 1160 continue; 1161 } 1162 1163 if (CastExpr *P = dyn_cast<CastExpr>(E)) { 1164 // We ignore integer <-> casts that are of the same width, ptr<->ptr and 1165 // ptr<->int casts of the same width. We also ignore all identify casts. 1166 Expr *SE = P->getSubExpr(); 1167 1168 if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) { 1169 E = SE; 1170 continue; 1171 } 1172 1173 if ((E->getType()->isPointerType() || E->getType()->isIntegralType()) && 1174 (SE->getType()->isPointerType() || SE->getType()->isIntegralType()) && 1175 Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) { 1176 E = SE; 1177 continue; 1178 } 1179 } 1180 1181 return E; 1182 } 1183} 1184 1185 1186/// hasAnyTypeDependentArguments - Determines if any of the expressions 1187/// in Exprs is type-dependent. 1188bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) { 1189 for (unsigned I = 0; I < NumExprs; ++I) 1190 if (Exprs[I]->isTypeDependent()) 1191 return true; 1192 1193 return false; 1194} 1195 1196/// hasAnyValueDependentArguments - Determines if any of the expressions 1197/// in Exprs is value-dependent. 1198bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) { 1199 for (unsigned I = 0; I < NumExprs; ++I) 1200 if (Exprs[I]->isValueDependent()) 1201 return true; 1202 1203 return false; 1204} 1205 1206bool Expr::isConstantInitializer(ASTContext &Ctx) const { 1207 // This function is attempting whether an expression is an initializer 1208 // which can be evaluated at compile-time. isEvaluatable handles most 1209 // of the cases, but it can't deal with some initializer-specific 1210 // expressions, and it can't deal with aggregates; we deal with those here, 1211 // and fall back to isEvaluatable for the other cases. 1212 1213 // FIXME: This function assumes the variable being assigned to 1214 // isn't a reference type! 1215 1216 switch (getStmtClass()) { 1217 default: break; 1218 case StringLiteralClass: 1219 case ObjCStringLiteralClass: 1220 case ObjCEncodeExprClass: 1221 return true; 1222 case CompoundLiteralExprClass: { 1223 // This handles gcc's extension that allows global initializers like 1224 // "struct x {int x;} x = (struct x) {};". 1225 // FIXME: This accepts other cases it shouldn't! 1226 const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer(); 1227 return Exp->isConstantInitializer(Ctx); 1228 } 1229 case InitListExprClass: { 1230 // FIXME: This doesn't deal with fields with reference types correctly. 1231 // FIXME: This incorrectly allows pointers cast to integers to be assigned 1232 // to bitfields. 1233 const InitListExpr *Exp = cast<InitListExpr>(this); 1234 unsigned numInits = Exp->getNumInits(); 1235 for (unsigned i = 0; i < numInits; i++) { 1236 if (!Exp->getInit(i)->isConstantInitializer(Ctx)) 1237 return false; 1238 } 1239 return true; 1240 } 1241 case ImplicitValueInitExprClass: 1242 return true; 1243 case ParenExprClass: { 1244 return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 1245 } 1246 case UnaryOperatorClass: { 1247 const UnaryOperator* Exp = cast<UnaryOperator>(this); 1248 if (Exp->getOpcode() == UnaryOperator::Extension) 1249 return Exp->getSubExpr()->isConstantInitializer(Ctx); 1250 break; 1251 } 1252 case ImplicitCastExprClass: 1253 case CStyleCastExprClass: 1254 // Handle casts with a destination that's a struct or union; this 1255 // deals with both the gcc no-op struct cast extension and the 1256 // cast-to-union extension. 1257 if (getType()->isRecordType()) 1258 return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 1259 break; 1260 } 1261 return isEvaluatable(Ctx); 1262} 1263 1264/// isIntegerConstantExpr - this recursive routine will test if an expression is 1265/// an integer constant expression. 1266 1267/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 1268/// comma, etc 1269/// 1270/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof 1271/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer 1272/// cast+dereference. 1273 1274// CheckICE - This function does the fundamental ICE checking: the returned 1275// ICEDiag contains a Val of 0, 1, or 2, and a possibly null SourceLocation. 1276// Note that to reduce code duplication, this helper does no evaluation 1277// itself; the caller checks whether the expression is evaluatable, and 1278// in the rare cases where CheckICE actually cares about the evaluated 1279// value, it calls into Evalute. 1280// 1281// Meanings of Val: 1282// 0: This expression is an ICE if it can be evaluated by Evaluate. 1283// 1: This expression is not an ICE, but if it isn't evaluated, it's 1284// a legal subexpression for an ICE. This return value is used to handle 1285// the comma operator in C99 mode. 1286// 2: This expression is not an ICE, and is not a legal subexpression for one. 1287 1288struct ICEDiag { 1289 unsigned Val; 1290 SourceLocation Loc; 1291 1292 public: 1293 ICEDiag(unsigned v, SourceLocation l) : Val(v), Loc(l) {} 1294 ICEDiag() : Val(0) {} 1295}; 1296 1297ICEDiag NoDiag() { return ICEDiag(); } 1298 1299static ICEDiag CheckEvalInICE(const Expr* E, ASTContext &Ctx) { 1300 Expr::EvalResult EVResult; 1301 if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects || 1302 !EVResult.Val.isInt()) { 1303 return ICEDiag(2, E->getLocStart()); 1304 } 1305 return NoDiag(); 1306} 1307 1308static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) { 1309 assert(!E->isValueDependent() && "Should not see value dependent exprs!"); 1310 if (!E->getType()->isIntegralType()) { 1311 return ICEDiag(2, E->getLocStart()); 1312 } 1313 1314 switch (E->getStmtClass()) { 1315 default: 1316 return ICEDiag(2, E->getLocStart()); 1317 case Expr::ParenExprClass: 1318 return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx); 1319 case Expr::IntegerLiteralClass: 1320 case Expr::CharacterLiteralClass: 1321 case Expr::CXXBoolLiteralExprClass: 1322 case Expr::CXXZeroInitValueExprClass: 1323 case Expr::TypesCompatibleExprClass: 1324 case Expr::UnaryTypeTraitExprClass: 1325 return NoDiag(); 1326 case Expr::CallExprClass: 1327 case Expr::CXXOperatorCallExprClass: { 1328 const CallExpr *CE = cast<CallExpr>(E); 1329 if (CE->isBuiltinCall(Ctx)) 1330 return CheckEvalInICE(E, Ctx); 1331 return ICEDiag(2, E->getLocStart()); 1332 } 1333 case Expr::DeclRefExprClass: 1334 case Expr::QualifiedDeclRefExprClass: 1335 if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl())) 1336 return NoDiag(); 1337 if (Ctx.getLangOptions().CPlusPlus && 1338 E->getType().getCVRQualifiers() == QualType::Const) { 1339 // C++ 7.1.5.1p2 1340 // A variable of non-volatile const-qualified integral or enumeration 1341 // type initialized by an ICE can be used in ICEs. 1342 if (const VarDecl *Dcl = 1343 dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) { 1344 if (Dcl->isInitKnownICE()) { 1345 // We have already checked whether this subexpression is an 1346 // integral constant expression. 1347 if (Dcl->isInitICE()) 1348 return NoDiag(); 1349 else 1350 return ICEDiag(2, E->getLocStart()); 1351 } 1352 1353 if (const Expr *Init = Dcl->getInit()) { 1354 ICEDiag Result = CheckICE(Init, Ctx); 1355 // Cache the result of the ICE test. 1356 Dcl->setInitKnownICE(Ctx, Result.Val == 0); 1357 return Result; 1358 } 1359 } 1360 } 1361 return ICEDiag(2, E->getLocStart()); 1362 case Expr::UnaryOperatorClass: { 1363 const UnaryOperator *Exp = cast<UnaryOperator>(E); 1364 switch (Exp->getOpcode()) { 1365 default: 1366 return ICEDiag(2, E->getLocStart()); 1367 case UnaryOperator::Extension: 1368 case UnaryOperator::LNot: 1369 case UnaryOperator::Plus: 1370 case UnaryOperator::Minus: 1371 case UnaryOperator::Not: 1372 case UnaryOperator::Real: 1373 case UnaryOperator::Imag: 1374 return CheckICE(Exp->getSubExpr(), Ctx); 1375 case UnaryOperator::OffsetOf: 1376 // Note that per C99, offsetof must be an ICE. And AFAIK, using 1377 // Evaluate matches the proposed gcc behavior for cases like 1378 // "offsetof(struct s{int x[4];}, x[!.0])". This doesn't affect 1379 // compliance: we should warn earlier for offsetof expressions with 1380 // array subscripts that aren't ICEs, and if the array subscripts 1381 // are ICEs, the value of the offsetof must be an integer constant. 1382 return CheckEvalInICE(E, Ctx); 1383 } 1384 } 1385 case Expr::SizeOfAlignOfExprClass: { 1386 const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(E); 1387 if (Exp->isSizeOf() && Exp->getTypeOfArgument()->isVariableArrayType()) 1388 return ICEDiag(2, E->getLocStart()); 1389 return NoDiag(); 1390 } 1391 case Expr::BinaryOperatorClass: { 1392 const BinaryOperator *Exp = cast<BinaryOperator>(E); 1393 switch (Exp->getOpcode()) { 1394 default: 1395 return ICEDiag(2, E->getLocStart()); 1396 case BinaryOperator::Mul: 1397 case BinaryOperator::Div: 1398 case BinaryOperator::Rem: 1399 case BinaryOperator::Add: 1400 case BinaryOperator::Sub: 1401 case BinaryOperator::Shl: 1402 case BinaryOperator::Shr: 1403 case BinaryOperator::LT: 1404 case BinaryOperator::GT: 1405 case BinaryOperator::LE: 1406 case BinaryOperator::GE: 1407 case BinaryOperator::EQ: 1408 case BinaryOperator::NE: 1409 case BinaryOperator::And: 1410 case BinaryOperator::Xor: 1411 case BinaryOperator::Or: 1412 case BinaryOperator::Comma: { 1413 ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 1414 ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 1415 if (Exp->getOpcode() == BinaryOperator::Div || 1416 Exp->getOpcode() == BinaryOperator::Rem) { 1417 // Evaluate gives an error for undefined Div/Rem, so make sure 1418 // we don't evaluate one. 1419 if (LHSResult.Val != 2 && RHSResult.Val != 2) { 1420 llvm::APSInt REval = Exp->getRHS()->EvaluateAsInt(Ctx); 1421 if (REval == 0) 1422 return ICEDiag(1, E->getLocStart()); 1423 if (REval.isSigned() && REval.isAllOnesValue()) { 1424 llvm::APSInt LEval = Exp->getLHS()->EvaluateAsInt(Ctx); 1425 if (LEval.isMinSignedValue()) 1426 return ICEDiag(1, E->getLocStart()); 1427 } 1428 } 1429 } 1430 if (Exp->getOpcode() == BinaryOperator::Comma) { 1431 if (Ctx.getLangOptions().C99) { 1432 // C99 6.6p3 introduces a strange edge case: comma can be in an ICE 1433 // if it isn't evaluated. 1434 if (LHSResult.Val == 0 && RHSResult.Val == 0) 1435 return ICEDiag(1, E->getLocStart()); 1436 } else { 1437 // In both C89 and C++, commas in ICEs are illegal. 1438 return ICEDiag(2, E->getLocStart()); 1439 } 1440 } 1441 if (LHSResult.Val >= RHSResult.Val) 1442 return LHSResult; 1443 return RHSResult; 1444 } 1445 case BinaryOperator::LAnd: 1446 case BinaryOperator::LOr: { 1447 ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 1448 ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 1449 if (LHSResult.Val == 0 && RHSResult.Val == 1) { 1450 // Rare case where the RHS has a comma "side-effect"; we need 1451 // to actually check the condition to see whether the side 1452 // with the comma is evaluated. 1453 if ((Exp->getOpcode() == BinaryOperator::LAnd) != 1454 (Exp->getLHS()->EvaluateAsInt(Ctx) == 0)) 1455 return RHSResult; 1456 return NoDiag(); 1457 } 1458 1459 if (LHSResult.Val >= RHSResult.Val) 1460 return LHSResult; 1461 return RHSResult; 1462 } 1463 } 1464 } 1465 case Expr::ImplicitCastExprClass: 1466 case Expr::CStyleCastExprClass: 1467 case Expr::CXXFunctionalCastExprClass: { 1468 const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr(); 1469 if (SubExpr->getType()->isIntegralType()) 1470 return CheckICE(SubExpr, Ctx); 1471 if (isa<FloatingLiteral>(SubExpr->IgnoreParens())) 1472 return NoDiag(); 1473 return ICEDiag(2, E->getLocStart()); 1474 } 1475 case Expr::ConditionalOperatorClass: { 1476 const ConditionalOperator *Exp = cast<ConditionalOperator>(E); 1477 // If the condition (ignoring parens) is a __builtin_constant_p call, 1478 // then only the true side is actually considered in an integer constant 1479 // expression, and it is fully evaluated. This is an important GNU 1480 // extension. See GCC PR38377 for discussion. 1481 if (const CallExpr *CallCE = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts())) 1482 if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) { 1483 Expr::EvalResult EVResult; 1484 if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects || 1485 !EVResult.Val.isInt()) { 1486 return ICEDiag(2, E->getLocStart()); 1487 } 1488 return NoDiag(); 1489 } 1490 ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx); 1491 ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx); 1492 ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx); 1493 if (CondResult.Val == 2) 1494 return CondResult; 1495 if (TrueResult.Val == 2) 1496 return TrueResult; 1497 if (FalseResult.Val == 2) 1498 return FalseResult; 1499 if (CondResult.Val == 1) 1500 return CondResult; 1501 if (TrueResult.Val == 0 && FalseResult.Val == 0) 1502 return NoDiag(); 1503 // Rare case where the diagnostics depend on which side is evaluated 1504 // Note that if we get here, CondResult is 0, and at least one of 1505 // TrueResult and FalseResult is non-zero. 1506 if (Exp->getCond()->EvaluateAsInt(Ctx) == 0) { 1507 return FalseResult; 1508 } 1509 return TrueResult; 1510 } 1511 case Expr::CXXDefaultArgExprClass: 1512 return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx); 1513 case Expr::ChooseExprClass: { 1514 return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(Ctx), Ctx); 1515 } 1516 } 1517} 1518 1519bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, 1520 SourceLocation *Loc, bool isEvaluated) const { 1521 ICEDiag d = CheckICE(this, Ctx); 1522 if (d.Val != 0) { 1523 if (Loc) *Loc = d.Loc; 1524 return false; 1525 } 1526 EvalResult EvalResult; 1527 if (!Evaluate(EvalResult, Ctx)) 1528 assert(0 && "ICE cannot be evaluated!"); 1529 assert(!EvalResult.HasSideEffects && "ICE with side effects!"); 1530 assert(EvalResult.Val.isInt() && "ICE that isn't integer!"); 1531 Result = EvalResult.Val.getInt(); 1532 return true; 1533} 1534 1535/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an 1536/// integer constant expression with the value zero, or if this is one that is 1537/// cast to void*. 1538bool Expr::isNullPointerConstant(ASTContext &Ctx) const 1539{ 1540 // Strip off a cast to void*, if it exists. Except in C++. 1541 if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 1542 if (!Ctx.getLangOptions().CPlusPlus) { 1543 // Check that it is a cast to void*. 1544 if (const PointerType *PT = CE->getType()->getAs<PointerType>()) { 1545 QualType Pointee = PT->getPointeeType(); 1546 if (Pointee.getCVRQualifiers() == 0 && 1547 Pointee->isVoidType() && // to void* 1548 CE->getSubExpr()->getType()->isIntegerType()) // from int. 1549 return CE->getSubExpr()->isNullPointerConstant(Ctx); 1550 } 1551 } 1552 } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1553 // Ignore the ImplicitCastExpr type entirely. 1554 return ICE->getSubExpr()->isNullPointerConstant(Ctx); 1555 } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1556 // Accept ((void*)0) as a null pointer constant, as many other 1557 // implementations do. 1558 return PE->getSubExpr()->isNullPointerConstant(Ctx); 1559 } else if (const CXXDefaultArgExpr *DefaultArg 1560 = dyn_cast<CXXDefaultArgExpr>(this)) { 1561 // See through default argument expressions 1562 return DefaultArg->getExpr()->isNullPointerConstant(Ctx); 1563 } else if (isa<GNUNullExpr>(this)) { 1564 // The GNU __null extension is always a null pointer constant. 1565 return true; 1566 } 1567 1568 // C++0x nullptr_t is always a null pointer constant. 1569 if (getType()->isNullPtrType()) 1570 return true; 1571 1572 // This expression must be an integer type. 1573 if (!getType()->isIntegerType()) 1574 return false; 1575 1576 // If we have an integer constant expression, we need to *evaluate* it and 1577 // test for the value 0. 1578 llvm::APSInt Result; 1579 return isIntegerConstantExpr(Result, Ctx) && Result == 0; 1580} 1581 1582FieldDecl *Expr::getBitField() { 1583 Expr *E = this->IgnoreParens(); 1584 1585 if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 1586 if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl())) 1587 if (Field->isBitField()) 1588 return Field; 1589 1590 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) 1591 if (BinOp->isAssignmentOp() && BinOp->getLHS()) 1592 return BinOp->getLHS()->getBitField(); 1593 1594 return 0; 1595} 1596 1597/// isArrow - Return true if the base expression is a pointer to vector, 1598/// return false if the base expression is a vector. 1599bool ExtVectorElementExpr::isArrow() const { 1600 return getBase()->getType()->isPointerType(); 1601} 1602 1603unsigned ExtVectorElementExpr::getNumElements() const { 1604 if (const VectorType *VT = getType()->getAsVectorType()) 1605 return VT->getNumElements(); 1606 return 1; 1607} 1608 1609/// containsDuplicateElements - Return true if any element access is repeated. 1610bool ExtVectorElementExpr::containsDuplicateElements() const { 1611 const char *compStr = Accessor->getName(); 1612 unsigned length = Accessor->getLength(); 1613 1614 // Halving swizzles do not contain duplicate elements. 1615 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") || 1616 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) 1617 return false; 1618 1619 // Advance past s-char prefix on hex swizzles. 1620 if (*compStr == 's' || *compStr == 'S') { 1621 compStr++; 1622 length--; 1623 } 1624 1625 for (unsigned i = 0; i != length-1; i++) { 1626 const char *s = compStr+i; 1627 for (const char c = *s++; *s; s++) 1628 if (c == *s) 1629 return true; 1630 } 1631 return false; 1632} 1633 1634/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 1635void ExtVectorElementExpr::getEncodedElementAccess( 1636 llvm::SmallVectorImpl<unsigned> &Elts) const { 1637 const char *compStr = Accessor->getName(); 1638 if (*compStr == 's' || *compStr == 'S') 1639 compStr++; 1640 1641 bool isHi = !strcmp(compStr, "hi"); 1642 bool isLo = !strcmp(compStr, "lo"); 1643 bool isEven = !strcmp(compStr, "even"); 1644 bool isOdd = !strcmp(compStr, "odd"); 1645 1646 for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 1647 uint64_t Index; 1648 1649 if (isHi) 1650 Index = e + i; 1651 else if (isLo) 1652 Index = i; 1653 else if (isEven) 1654 Index = 2 * i; 1655 else if (isOdd) 1656 Index = 2 * i + 1; 1657 else 1658 Index = ExtVectorType::getAccessorIdx(compStr[i]); 1659 1660 Elts.push_back(Index); 1661 } 1662} 1663 1664// constructor for instance messages. 1665ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1666 QualType retType, ObjCMethodDecl *mproto, 1667 SourceLocation LBrac, SourceLocation RBrac, 1668 Expr **ArgExprs, unsigned nargs) 1669 : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1670 MethodProto(mproto) { 1671 NumArgs = nargs; 1672 SubExprs = new Stmt*[NumArgs+1]; 1673 SubExprs[RECEIVER] = receiver; 1674 if (NumArgs) { 1675 for (unsigned i = 0; i != NumArgs; ++i) 1676 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1677 } 1678 LBracloc = LBrac; 1679 RBracloc = RBrac; 1680} 1681 1682// constructor for class messages. 1683// FIXME: clsName should be typed to ObjCInterfaceType 1684ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1685 QualType retType, ObjCMethodDecl *mproto, 1686 SourceLocation LBrac, SourceLocation RBrac, 1687 Expr **ArgExprs, unsigned nargs) 1688 : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1689 MethodProto(mproto) { 1690 NumArgs = nargs; 1691 SubExprs = new Stmt*[NumArgs+1]; 1692 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown); 1693 if (NumArgs) { 1694 for (unsigned i = 0; i != NumArgs; ++i) 1695 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1696 } 1697 LBracloc = LBrac; 1698 RBracloc = RBrac; 1699} 1700 1701// constructor for class messages. 1702ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo, 1703 QualType retType, ObjCMethodDecl *mproto, 1704 SourceLocation LBrac, SourceLocation RBrac, 1705 Expr **ArgExprs, unsigned nargs) 1706: Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1707MethodProto(mproto) { 1708 NumArgs = nargs; 1709 SubExprs = new Stmt*[NumArgs+1]; 1710 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown); 1711 if (NumArgs) { 1712 for (unsigned i = 0; i != NumArgs; ++i) 1713 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1714 } 1715 LBracloc = LBrac; 1716 RBracloc = RBrac; 1717} 1718 1719ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const { 1720 uintptr_t x = (uintptr_t) SubExprs[RECEIVER]; 1721 switch (x & Flags) { 1722 default: 1723 assert(false && "Invalid ObjCMessageExpr."); 1724 case IsInstMeth: 1725 return ClassInfo(0, 0); 1726 case IsClsMethDeclUnknown: 1727 return ClassInfo(0, (IdentifierInfo*) (x & ~Flags)); 1728 case IsClsMethDeclKnown: { 1729 ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags); 1730 return ClassInfo(D, D->getIdentifier()); 1731 } 1732 } 1733} 1734 1735void ObjCMessageExpr::setClassInfo(const ObjCMessageExpr::ClassInfo &CI) { 1736 if (CI.first == 0 && CI.second == 0) 1737 SubExprs[RECEIVER] = (Expr*)((uintptr_t)0 | IsInstMeth); 1738 else if (CI.first == 0) 1739 SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.second | IsClsMethDeclUnknown); 1740 else 1741 SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.first | IsClsMethDeclKnown); 1742} 1743 1744 1745bool ChooseExpr::isConditionTrue(ASTContext &C) const { 1746 return getCond()->EvaluateAsInt(C) != 0; 1747} 1748 1749void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs, 1750 unsigned NumExprs) { 1751 if (SubExprs) C.Deallocate(SubExprs); 1752 1753 SubExprs = new (C) Stmt* [NumExprs]; 1754 this->NumExprs = NumExprs; 1755 memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs); 1756} 1757 1758void ShuffleVectorExpr::DoDestroy(ASTContext& C) { 1759 DestroyChildren(C); 1760 if (SubExprs) C.Deallocate(SubExprs); 1761 this->~ShuffleVectorExpr(); 1762 C.Deallocate(this); 1763} 1764 1765void SizeOfAlignOfExpr::DoDestroy(ASTContext& C) { 1766 // Override default behavior of traversing children. If this has a type 1767 // operand and the type is a variable-length array, the child iteration 1768 // will iterate over the size expression. However, this expression belongs 1769 // to the type, not to this, so we don't want to delete it. 1770 // We still want to delete this expression. 1771 if (isArgumentType()) { 1772 this->~SizeOfAlignOfExpr(); 1773 C.Deallocate(this); 1774 } 1775 else 1776 Expr::DoDestroy(C); 1777} 1778 1779//===----------------------------------------------------------------------===// 1780// DesignatedInitExpr 1781//===----------------------------------------------------------------------===// 1782 1783IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() { 1784 assert(Kind == FieldDesignator && "Only valid on a field designator"); 1785 if (Field.NameOrField & 0x01) 1786 return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01); 1787 else 1788 return getField()->getIdentifier(); 1789} 1790 1791DesignatedInitExpr::DesignatedInitExpr(QualType Ty, unsigned NumDesignators, 1792 const Designator *Designators, 1793 SourceLocation EqualOrColonLoc, 1794 bool GNUSyntax, 1795 Expr **IndexExprs, 1796 unsigned NumIndexExprs, 1797 Expr *Init) 1798 : Expr(DesignatedInitExprClass, Ty, 1799 Init->isTypeDependent(), Init->isValueDependent()), 1800 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax), 1801 NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) { 1802 this->Designators = new Designator[NumDesignators]; 1803 1804 // Record the initializer itself. 1805 child_iterator Child = child_begin(); 1806 *Child++ = Init; 1807 1808 // Copy the designators and their subexpressions, computing 1809 // value-dependence along the way. 1810 unsigned IndexIdx = 0; 1811 for (unsigned I = 0; I != NumDesignators; ++I) { 1812 this->Designators[I] = Designators[I]; 1813 1814 if (this->Designators[I].isArrayDesignator()) { 1815 // Compute type- and value-dependence. 1816 Expr *Index = IndexExprs[IndexIdx]; 1817 ValueDependent = ValueDependent || 1818 Index->isTypeDependent() || Index->isValueDependent(); 1819 1820 // Copy the index expressions into permanent storage. 1821 *Child++ = IndexExprs[IndexIdx++]; 1822 } else if (this->Designators[I].isArrayRangeDesignator()) { 1823 // Compute type- and value-dependence. 1824 Expr *Start = IndexExprs[IndexIdx]; 1825 Expr *End = IndexExprs[IndexIdx + 1]; 1826 ValueDependent = ValueDependent || 1827 Start->isTypeDependent() || Start->isValueDependent() || 1828 End->isTypeDependent() || End->isValueDependent(); 1829 1830 // Copy the start/end expressions into permanent storage. 1831 *Child++ = IndexExprs[IndexIdx++]; 1832 *Child++ = IndexExprs[IndexIdx++]; 1833 } 1834 } 1835 1836 assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions"); 1837} 1838 1839DesignatedInitExpr * 1840DesignatedInitExpr::Create(ASTContext &C, Designator *Designators, 1841 unsigned NumDesignators, 1842 Expr **IndexExprs, unsigned NumIndexExprs, 1843 SourceLocation ColonOrEqualLoc, 1844 bool UsesColonSyntax, Expr *Init) { 1845 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 1846 sizeof(Stmt *) * (NumIndexExprs + 1), 8); 1847 return new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators, Designators, 1848 ColonOrEqualLoc, UsesColonSyntax, 1849 IndexExprs, NumIndexExprs, Init); 1850} 1851 1852DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C, 1853 unsigned NumIndexExprs) { 1854 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 1855 sizeof(Stmt *) * (NumIndexExprs + 1), 8); 1856 return new (Mem) DesignatedInitExpr(NumIndexExprs + 1); 1857} 1858 1859void DesignatedInitExpr::setDesignators(const Designator *Desigs, 1860 unsigned NumDesigs) { 1861 if (Designators) 1862 delete [] Designators; 1863 1864 Designators = new Designator[NumDesigs]; 1865 NumDesignators = NumDesigs; 1866 for (unsigned I = 0; I != NumDesigs; ++I) 1867 Designators[I] = Desigs[I]; 1868} 1869 1870SourceRange DesignatedInitExpr::getSourceRange() const { 1871 SourceLocation StartLoc; 1872 Designator &First = 1873 *const_cast<DesignatedInitExpr*>(this)->designators_begin(); 1874 if (First.isFieldDesignator()) { 1875 if (GNUSyntax) 1876 StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc); 1877 else 1878 StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc); 1879 } else 1880 StartLoc = 1881 SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc); 1882 return SourceRange(StartLoc, getInit()->getSourceRange().getEnd()); 1883} 1884 1885Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) { 1886 assert(D.Kind == Designator::ArrayDesignator && "Requires array designator"); 1887 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 1888 Ptr += sizeof(DesignatedInitExpr); 1889 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 1890 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 1891} 1892 1893Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) { 1894 assert(D.Kind == Designator::ArrayRangeDesignator && 1895 "Requires array range designator"); 1896 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 1897 Ptr += sizeof(DesignatedInitExpr); 1898 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 1899 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 1900} 1901 1902Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) { 1903 assert(D.Kind == Designator::ArrayRangeDesignator && 1904 "Requires array range designator"); 1905 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 1906 Ptr += sizeof(DesignatedInitExpr); 1907 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 1908 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2)); 1909} 1910 1911/// \brief Replaces the designator at index @p Idx with the series 1912/// of designators in [First, Last). 1913void DesignatedInitExpr::ExpandDesignator(unsigned Idx, 1914 const Designator *First, 1915 const Designator *Last) { 1916 unsigned NumNewDesignators = Last - First; 1917 if (NumNewDesignators == 0) { 1918 std::copy_backward(Designators + Idx + 1, 1919 Designators + NumDesignators, 1920 Designators + Idx); 1921 --NumNewDesignators; 1922 return; 1923 } else if (NumNewDesignators == 1) { 1924 Designators[Idx] = *First; 1925 return; 1926 } 1927 1928 Designator *NewDesignators 1929 = new Designator[NumDesignators - 1 + NumNewDesignators]; 1930 std::copy(Designators, Designators + Idx, NewDesignators); 1931 std::copy(First, Last, NewDesignators + Idx); 1932 std::copy(Designators + Idx + 1, Designators + NumDesignators, 1933 NewDesignators + Idx + NumNewDesignators); 1934 delete [] Designators; 1935 Designators = NewDesignators; 1936 NumDesignators = NumDesignators - 1 + NumNewDesignators; 1937} 1938 1939void DesignatedInitExpr::DoDestroy(ASTContext &C) { 1940 delete [] Designators; 1941 Expr::DoDestroy(C); 1942} 1943 1944ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc, 1945 Expr **exprs, unsigned nexprs, 1946 SourceLocation rparenloc) 1947: Expr(ParenListExprClass, QualType(), 1948 hasAnyTypeDependentArguments(exprs, nexprs), 1949 hasAnyValueDependentArguments(exprs, nexprs)), 1950 NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) { 1951 1952 Exprs = new (C) Stmt*[nexprs]; 1953 for (unsigned i = 0; i != nexprs; ++i) 1954 Exprs[i] = exprs[i]; 1955} 1956 1957void ParenListExpr::DoDestroy(ASTContext& C) { 1958 DestroyChildren(C); 1959 if (Exprs) C.Deallocate(Exprs); 1960 this->~ParenListExpr(); 1961 C.Deallocate(this); 1962} 1963 1964//===----------------------------------------------------------------------===// 1965// ExprIterator. 1966//===----------------------------------------------------------------------===// 1967 1968Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 1969Expr* ExprIterator::operator*() const { return cast<Expr>(*I); } 1970Expr* ExprIterator::operator->() const { return cast<Expr>(*I); } 1971const Expr* ConstExprIterator::operator[](size_t idx) const { 1972 return cast<Expr>(I[idx]); 1973} 1974const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 1975const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 1976 1977//===----------------------------------------------------------------------===// 1978// Child Iterators for iterating over subexpressions/substatements 1979//===----------------------------------------------------------------------===// 1980 1981// DeclRefExpr 1982Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 1983Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 1984 1985// ObjCIvarRefExpr 1986Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; } 1987Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; } 1988 1989// ObjCPropertyRefExpr 1990Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; } 1991Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; } 1992 1993// ObjCImplicitSetterGetterRefExpr 1994Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_begin() { 1995 return &Base; 1996} 1997Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_end() { 1998 return &Base+1; 1999} 2000 2001// ObjCSuperExpr 2002Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); } 2003Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); } 2004 2005// ObjCIsaExpr 2006Stmt::child_iterator ObjCIsaExpr::child_begin() { return &Base; } 2007Stmt::child_iterator ObjCIsaExpr::child_end() { return &Base+1; } 2008 2009// PredefinedExpr 2010Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); } 2011Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); } 2012 2013// IntegerLiteral 2014Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 2015Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 2016 2017// CharacterLiteral 2018Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();} 2019Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 2020 2021// FloatingLiteral 2022Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 2023Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 2024 2025// ImaginaryLiteral 2026Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; } 2027Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; } 2028 2029// StringLiteral 2030Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 2031Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 2032 2033// ParenExpr 2034Stmt::child_iterator ParenExpr::child_begin() { return &Val; } 2035Stmt::child_iterator ParenExpr::child_end() { return &Val+1; } 2036 2037// UnaryOperator 2038Stmt::child_iterator UnaryOperator::child_begin() { return &Val; } 2039Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; } 2040 2041// SizeOfAlignOfExpr 2042Stmt::child_iterator SizeOfAlignOfExpr::child_begin() { 2043 // If this is of a type and the type is a VLA type (and not a typedef), the 2044 // size expression of the VLA needs to be treated as an executable expression. 2045 // Why isn't this weirdness documented better in StmtIterator? 2046 if (isArgumentType()) { 2047 if (VariableArrayType* T = dyn_cast<VariableArrayType>( 2048 getArgumentType().getTypePtr())) 2049 return child_iterator(T); 2050 return child_iterator(); 2051 } 2052 return child_iterator(&Argument.Ex); 2053} 2054Stmt::child_iterator SizeOfAlignOfExpr::child_end() { 2055 if (isArgumentType()) 2056 return child_iterator(); 2057 return child_iterator(&Argument.Ex + 1); 2058} 2059 2060// ArraySubscriptExpr 2061Stmt::child_iterator ArraySubscriptExpr::child_begin() { 2062 return &SubExprs[0]; 2063} 2064Stmt::child_iterator ArraySubscriptExpr::child_end() { 2065 return &SubExprs[0]+END_EXPR; 2066} 2067 2068// CallExpr 2069Stmt::child_iterator CallExpr::child_begin() { 2070 return &SubExprs[0]; 2071} 2072Stmt::child_iterator CallExpr::child_end() { 2073 return &SubExprs[0]+NumArgs+ARGS_START; 2074} 2075 2076// MemberExpr 2077Stmt::child_iterator MemberExpr::child_begin() { return &Base; } 2078Stmt::child_iterator MemberExpr::child_end() { return &Base+1; } 2079 2080// ExtVectorElementExpr 2081Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; } 2082Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; } 2083 2084// CompoundLiteralExpr 2085Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; } 2086Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; } 2087 2088// CastExpr 2089Stmt::child_iterator CastExpr::child_begin() { return &Op; } 2090Stmt::child_iterator CastExpr::child_end() { return &Op+1; } 2091 2092// BinaryOperator 2093Stmt::child_iterator BinaryOperator::child_begin() { 2094 return &SubExprs[0]; 2095} 2096Stmt::child_iterator BinaryOperator::child_end() { 2097 return &SubExprs[0]+END_EXPR; 2098} 2099 2100// ConditionalOperator 2101Stmt::child_iterator ConditionalOperator::child_begin() { 2102 return &SubExprs[0]; 2103} 2104Stmt::child_iterator ConditionalOperator::child_end() { 2105 return &SubExprs[0]+END_EXPR; 2106} 2107 2108// AddrLabelExpr 2109Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 2110Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 2111 2112// StmtExpr 2113Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; } 2114Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; } 2115 2116// TypesCompatibleExpr 2117Stmt::child_iterator TypesCompatibleExpr::child_begin() { 2118 return child_iterator(); 2119} 2120 2121Stmt::child_iterator TypesCompatibleExpr::child_end() { 2122 return child_iterator(); 2123} 2124 2125// ChooseExpr 2126Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; } 2127Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; } 2128 2129// GNUNullExpr 2130Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); } 2131Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); } 2132 2133// ShuffleVectorExpr 2134Stmt::child_iterator ShuffleVectorExpr::child_begin() { 2135 return &SubExprs[0]; 2136} 2137Stmt::child_iterator ShuffleVectorExpr::child_end() { 2138 return &SubExprs[0]+NumExprs; 2139} 2140 2141// VAArgExpr 2142Stmt::child_iterator VAArgExpr::child_begin() { return &Val; } 2143Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; } 2144 2145// InitListExpr 2146Stmt::child_iterator InitListExpr::child_begin() { 2147 return InitExprs.size() ? &InitExprs[0] : 0; 2148} 2149Stmt::child_iterator InitListExpr::child_end() { 2150 return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0; 2151} 2152 2153// DesignatedInitExpr 2154Stmt::child_iterator DesignatedInitExpr::child_begin() { 2155 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 2156 Ptr += sizeof(DesignatedInitExpr); 2157 return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 2158} 2159Stmt::child_iterator DesignatedInitExpr::child_end() { 2160 return child_iterator(&*child_begin() + NumSubExprs); 2161} 2162 2163// ImplicitValueInitExpr 2164Stmt::child_iterator ImplicitValueInitExpr::child_begin() { 2165 return child_iterator(); 2166} 2167 2168Stmt::child_iterator ImplicitValueInitExpr::child_end() { 2169 return child_iterator(); 2170} 2171 2172// ParenListExpr 2173Stmt::child_iterator ParenListExpr::child_begin() { 2174 return &Exprs[0]; 2175} 2176Stmt::child_iterator ParenListExpr::child_end() { 2177 return &Exprs[0]+NumExprs; 2178} 2179 2180// ObjCStringLiteral 2181Stmt::child_iterator ObjCStringLiteral::child_begin() { 2182 return &String; 2183} 2184Stmt::child_iterator ObjCStringLiteral::child_end() { 2185 return &String+1; 2186} 2187 2188// ObjCEncodeExpr 2189Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 2190Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 2191 2192// ObjCSelectorExpr 2193Stmt::child_iterator ObjCSelectorExpr::child_begin() { 2194 return child_iterator(); 2195} 2196Stmt::child_iterator ObjCSelectorExpr::child_end() { 2197 return child_iterator(); 2198} 2199 2200// ObjCProtocolExpr 2201Stmt::child_iterator ObjCProtocolExpr::child_begin() { 2202 return child_iterator(); 2203} 2204Stmt::child_iterator ObjCProtocolExpr::child_end() { 2205 return child_iterator(); 2206} 2207 2208// ObjCMessageExpr 2209Stmt::child_iterator ObjCMessageExpr::child_begin() { 2210 return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START; 2211} 2212Stmt::child_iterator ObjCMessageExpr::child_end() { 2213 return &SubExprs[0]+ARGS_START+getNumArgs(); 2214} 2215 2216// Blocks 2217Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); } 2218Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); } 2219 2220Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();} 2221Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); } 2222