Expr.cpp revision 1eb4433ac451dc16f4133a88af2d002ac26c58ef
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 // Strip off a cast to void*, if it exists. Except in C++. 1540 if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 1541 if (!Ctx.getLangOptions().CPlusPlus) { 1542 // Check that it is a cast to void*. 1543 if (const PointerType *PT = CE->getType()->getAs<PointerType>()) { 1544 QualType Pointee = PT->getPointeeType(); 1545 if (Pointee.getCVRQualifiers() == 0 && 1546 Pointee->isVoidType() && // to void* 1547 CE->getSubExpr()->getType()->isIntegerType()) // from int. 1548 return CE->getSubExpr()->isNullPointerConstant(Ctx); 1549 } 1550 } 1551 } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1552 // Ignore the ImplicitCastExpr type entirely. 1553 return ICE->getSubExpr()->isNullPointerConstant(Ctx); 1554 } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1555 // Accept ((void*)0) as a null pointer constant, as many other 1556 // implementations do. 1557 return PE->getSubExpr()->isNullPointerConstant(Ctx); 1558 } else if (const CXXDefaultArgExpr *DefaultArg 1559 = dyn_cast<CXXDefaultArgExpr>(this)) { 1560 // See through default argument expressions 1561 return DefaultArg->getExpr()->isNullPointerConstant(Ctx); 1562 } else if (isa<GNUNullExpr>(this)) { 1563 // The GNU __null extension is always a null pointer constant. 1564 return true; 1565 } 1566 1567 // C++0x nullptr_t is always a null pointer constant. 1568 if (getType()->isNullPtrType()) 1569 return true; 1570 1571 // This expression must be an integer type. 1572 if (!getType()->isIntegerType()) 1573 return false; 1574 1575 // If we have an integer constant expression, we need to *evaluate* it and 1576 // test for the value 0. 1577 llvm::APSInt Result; 1578 return isIntegerConstantExpr(Result, Ctx) && Result == 0; 1579} 1580 1581FieldDecl *Expr::getBitField() { 1582 Expr *E = this->IgnoreParens(); 1583 1584 if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 1585 if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl())) 1586 if (Field->isBitField()) 1587 return Field; 1588 1589 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) 1590 if (BinOp->isAssignmentOp() && BinOp->getLHS()) 1591 return BinOp->getLHS()->getBitField(); 1592 1593 return 0; 1594} 1595 1596/// isArrow - Return true if the base expression is a pointer to vector, 1597/// return false if the base expression is a vector. 1598bool ExtVectorElementExpr::isArrow() const { 1599 return getBase()->getType()->isPointerType(); 1600} 1601 1602unsigned ExtVectorElementExpr::getNumElements() const { 1603 if (const VectorType *VT = getType()->getAsVectorType()) 1604 return VT->getNumElements(); 1605 return 1; 1606} 1607 1608/// containsDuplicateElements - Return true if any element access is repeated. 1609bool ExtVectorElementExpr::containsDuplicateElements() const { 1610 const char *compStr = Accessor->getName(); 1611 unsigned length = Accessor->getLength(); 1612 1613 // Halving swizzles do not contain duplicate elements. 1614 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") || 1615 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) 1616 return false; 1617 1618 // Advance past s-char prefix on hex swizzles. 1619 if (*compStr == 's' || *compStr == 'S') { 1620 compStr++; 1621 length--; 1622 } 1623 1624 for (unsigned i = 0; i != length-1; i++) { 1625 const char *s = compStr+i; 1626 for (const char c = *s++; *s; s++) 1627 if (c == *s) 1628 return true; 1629 } 1630 return false; 1631} 1632 1633/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 1634void ExtVectorElementExpr::getEncodedElementAccess( 1635 llvm::SmallVectorImpl<unsigned> &Elts) const { 1636 const char *compStr = Accessor->getName(); 1637 if (*compStr == 's' || *compStr == 'S') 1638 compStr++; 1639 1640 bool isHi = !strcmp(compStr, "hi"); 1641 bool isLo = !strcmp(compStr, "lo"); 1642 bool isEven = !strcmp(compStr, "even"); 1643 bool isOdd = !strcmp(compStr, "odd"); 1644 1645 for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 1646 uint64_t Index; 1647 1648 if (isHi) 1649 Index = e + i; 1650 else if (isLo) 1651 Index = i; 1652 else if (isEven) 1653 Index = 2 * i; 1654 else if (isOdd) 1655 Index = 2 * i + 1; 1656 else 1657 Index = ExtVectorType::getAccessorIdx(compStr[i]); 1658 1659 Elts.push_back(Index); 1660 } 1661} 1662 1663// constructor for instance messages. 1664ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1665 QualType retType, ObjCMethodDecl *mproto, 1666 SourceLocation LBrac, SourceLocation RBrac, 1667 Expr **ArgExprs, unsigned nargs) 1668 : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1669 MethodProto(mproto) { 1670 NumArgs = nargs; 1671 SubExprs = new Stmt*[NumArgs+1]; 1672 SubExprs[RECEIVER] = receiver; 1673 if (NumArgs) { 1674 for (unsigned i = 0; i != NumArgs; ++i) 1675 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1676 } 1677 LBracloc = LBrac; 1678 RBracloc = RBrac; 1679} 1680 1681// constructor for class messages. 1682// FIXME: clsName should be typed to ObjCInterfaceType 1683ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1684 QualType retType, ObjCMethodDecl *mproto, 1685 SourceLocation LBrac, SourceLocation RBrac, 1686 Expr **ArgExprs, unsigned nargs) 1687 : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1688 MethodProto(mproto) { 1689 NumArgs = nargs; 1690 SubExprs = new Stmt*[NumArgs+1]; 1691 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown); 1692 if (NumArgs) { 1693 for (unsigned i = 0; i != NumArgs; ++i) 1694 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1695 } 1696 LBracloc = LBrac; 1697 RBracloc = RBrac; 1698} 1699 1700// constructor for class messages. 1701ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo, 1702 QualType retType, ObjCMethodDecl *mproto, 1703 SourceLocation LBrac, SourceLocation RBrac, 1704 Expr **ArgExprs, unsigned nargs) 1705: Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1706MethodProto(mproto) { 1707 NumArgs = nargs; 1708 SubExprs = new Stmt*[NumArgs+1]; 1709 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown); 1710 if (NumArgs) { 1711 for (unsigned i = 0; i != NumArgs; ++i) 1712 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1713 } 1714 LBracloc = LBrac; 1715 RBracloc = RBrac; 1716} 1717 1718ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const { 1719 uintptr_t x = (uintptr_t) SubExprs[RECEIVER]; 1720 switch (x & Flags) { 1721 default: 1722 assert(false && "Invalid ObjCMessageExpr."); 1723 case IsInstMeth: 1724 return ClassInfo(0, 0); 1725 case IsClsMethDeclUnknown: 1726 return ClassInfo(0, (IdentifierInfo*) (x & ~Flags)); 1727 case IsClsMethDeclKnown: { 1728 ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags); 1729 return ClassInfo(D, D->getIdentifier()); 1730 } 1731 } 1732} 1733 1734void ObjCMessageExpr::setClassInfo(const ObjCMessageExpr::ClassInfo &CI) { 1735 if (CI.first == 0 && CI.second == 0) 1736 SubExprs[RECEIVER] = (Expr*)((uintptr_t)0 | IsInstMeth); 1737 else if (CI.first == 0) 1738 SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.second | IsClsMethDeclUnknown); 1739 else 1740 SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.first | IsClsMethDeclKnown); 1741} 1742 1743 1744bool ChooseExpr::isConditionTrue(ASTContext &C) const { 1745 return getCond()->EvaluateAsInt(C) != 0; 1746} 1747 1748void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs, 1749 unsigned NumExprs) { 1750 if (SubExprs) C.Deallocate(SubExprs); 1751 1752 SubExprs = new (C) Stmt* [NumExprs]; 1753 this->NumExprs = NumExprs; 1754 memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs); 1755} 1756 1757void ShuffleVectorExpr::DoDestroy(ASTContext& C) { 1758 DestroyChildren(C); 1759 if (SubExprs) C.Deallocate(SubExprs); 1760 this->~ShuffleVectorExpr(); 1761 C.Deallocate(this); 1762} 1763 1764void SizeOfAlignOfExpr::DoDestroy(ASTContext& C) { 1765 // Override default behavior of traversing children. If this has a type 1766 // operand and the type is a variable-length array, the child iteration 1767 // will iterate over the size expression. However, this expression belongs 1768 // to the type, not to this, so we don't want to delete it. 1769 // We still want to delete this expression. 1770 if (isArgumentType()) { 1771 this->~SizeOfAlignOfExpr(); 1772 C.Deallocate(this); 1773 } 1774 else 1775 Expr::DoDestroy(C); 1776} 1777 1778//===----------------------------------------------------------------------===// 1779// DesignatedInitExpr 1780//===----------------------------------------------------------------------===// 1781 1782IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() { 1783 assert(Kind == FieldDesignator && "Only valid on a field designator"); 1784 if (Field.NameOrField & 0x01) 1785 return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01); 1786 else 1787 return getField()->getIdentifier(); 1788} 1789 1790DesignatedInitExpr::DesignatedInitExpr(QualType Ty, unsigned NumDesignators, 1791 const Designator *Designators, 1792 SourceLocation EqualOrColonLoc, 1793 bool GNUSyntax, 1794 Expr **IndexExprs, 1795 unsigned NumIndexExprs, 1796 Expr *Init) 1797 : Expr(DesignatedInitExprClass, Ty, 1798 Init->isTypeDependent(), Init->isValueDependent()), 1799 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax), 1800 NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) { 1801 this->Designators = new Designator[NumDesignators]; 1802 1803 // Record the initializer itself. 1804 child_iterator Child = child_begin(); 1805 *Child++ = Init; 1806 1807 // Copy the designators and their subexpressions, computing 1808 // value-dependence along the way. 1809 unsigned IndexIdx = 0; 1810 for (unsigned I = 0; I != NumDesignators; ++I) { 1811 this->Designators[I] = Designators[I]; 1812 1813 if (this->Designators[I].isArrayDesignator()) { 1814 // Compute type- and value-dependence. 1815 Expr *Index = IndexExprs[IndexIdx]; 1816 ValueDependent = ValueDependent || 1817 Index->isTypeDependent() || Index->isValueDependent(); 1818 1819 // Copy the index expressions into permanent storage. 1820 *Child++ = IndexExprs[IndexIdx++]; 1821 } else if (this->Designators[I].isArrayRangeDesignator()) { 1822 // Compute type- and value-dependence. 1823 Expr *Start = IndexExprs[IndexIdx]; 1824 Expr *End = IndexExprs[IndexIdx + 1]; 1825 ValueDependent = ValueDependent || 1826 Start->isTypeDependent() || Start->isValueDependent() || 1827 End->isTypeDependent() || End->isValueDependent(); 1828 1829 // Copy the start/end expressions into permanent storage. 1830 *Child++ = IndexExprs[IndexIdx++]; 1831 *Child++ = IndexExprs[IndexIdx++]; 1832 } 1833 } 1834 1835 assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions"); 1836} 1837 1838DesignatedInitExpr * 1839DesignatedInitExpr::Create(ASTContext &C, Designator *Designators, 1840 unsigned NumDesignators, 1841 Expr **IndexExprs, unsigned NumIndexExprs, 1842 SourceLocation ColonOrEqualLoc, 1843 bool UsesColonSyntax, Expr *Init) { 1844 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 1845 sizeof(Stmt *) * (NumIndexExprs + 1), 8); 1846 return new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators, Designators, 1847 ColonOrEqualLoc, UsesColonSyntax, 1848 IndexExprs, NumIndexExprs, Init); 1849} 1850 1851DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C, 1852 unsigned NumIndexExprs) { 1853 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 1854 sizeof(Stmt *) * (NumIndexExprs + 1), 8); 1855 return new (Mem) DesignatedInitExpr(NumIndexExprs + 1); 1856} 1857 1858void DesignatedInitExpr::setDesignators(const Designator *Desigs, 1859 unsigned NumDesigs) { 1860 if (Designators) 1861 delete [] Designators; 1862 1863 Designators = new Designator[NumDesigs]; 1864 NumDesignators = NumDesigs; 1865 for (unsigned I = 0; I != NumDesigs; ++I) 1866 Designators[I] = Desigs[I]; 1867} 1868 1869SourceRange DesignatedInitExpr::getSourceRange() const { 1870 SourceLocation StartLoc; 1871 Designator &First = 1872 *const_cast<DesignatedInitExpr*>(this)->designators_begin(); 1873 if (First.isFieldDesignator()) { 1874 if (GNUSyntax) 1875 StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc); 1876 else 1877 StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc); 1878 } else 1879 StartLoc = 1880 SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc); 1881 return SourceRange(StartLoc, getInit()->getSourceRange().getEnd()); 1882} 1883 1884Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) { 1885 assert(D.Kind == Designator::ArrayDesignator && "Requires array designator"); 1886 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 1887 Ptr += sizeof(DesignatedInitExpr); 1888 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 1889 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 1890} 1891 1892Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) { 1893 assert(D.Kind == Designator::ArrayRangeDesignator && 1894 "Requires array range designator"); 1895 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 1896 Ptr += sizeof(DesignatedInitExpr); 1897 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 1898 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 1899} 1900 1901Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) { 1902 assert(D.Kind == Designator::ArrayRangeDesignator && 1903 "Requires array range designator"); 1904 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 1905 Ptr += sizeof(DesignatedInitExpr); 1906 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 1907 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2)); 1908} 1909 1910/// \brief Replaces the designator at index @p Idx with the series 1911/// of designators in [First, Last). 1912void DesignatedInitExpr::ExpandDesignator(unsigned Idx, 1913 const Designator *First, 1914 const Designator *Last) { 1915 unsigned NumNewDesignators = Last - First; 1916 if (NumNewDesignators == 0) { 1917 std::copy_backward(Designators + Idx + 1, 1918 Designators + NumDesignators, 1919 Designators + Idx); 1920 --NumNewDesignators; 1921 return; 1922 } else if (NumNewDesignators == 1) { 1923 Designators[Idx] = *First; 1924 return; 1925 } 1926 1927 Designator *NewDesignators 1928 = new Designator[NumDesignators - 1 + NumNewDesignators]; 1929 std::copy(Designators, Designators + Idx, NewDesignators); 1930 std::copy(First, Last, NewDesignators + Idx); 1931 std::copy(Designators + Idx + 1, Designators + NumDesignators, 1932 NewDesignators + Idx + NumNewDesignators); 1933 delete [] Designators; 1934 Designators = NewDesignators; 1935 NumDesignators = NumDesignators - 1 + NumNewDesignators; 1936} 1937 1938void DesignatedInitExpr::DoDestroy(ASTContext &C) { 1939 delete [] Designators; 1940 Expr::DoDestroy(C); 1941} 1942 1943ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc, 1944 Expr **exprs, unsigned nexprs, 1945 SourceLocation rparenloc) 1946: Expr(ParenListExprClass, QualType(), 1947 hasAnyTypeDependentArguments(exprs, nexprs), 1948 hasAnyValueDependentArguments(exprs, nexprs)), 1949 NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) { 1950 1951 Exprs = new (C) Stmt*[nexprs]; 1952 for (unsigned i = 0; i != nexprs; ++i) 1953 Exprs[i] = exprs[i]; 1954} 1955 1956void ParenListExpr::DoDestroy(ASTContext& C) { 1957 DestroyChildren(C); 1958 if (Exprs) C.Deallocate(Exprs); 1959 this->~ParenListExpr(); 1960 C.Deallocate(this); 1961} 1962 1963//===----------------------------------------------------------------------===// 1964// ExprIterator. 1965//===----------------------------------------------------------------------===// 1966 1967Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 1968Expr* ExprIterator::operator*() const { return cast<Expr>(*I); } 1969Expr* ExprIterator::operator->() const { return cast<Expr>(*I); } 1970const Expr* ConstExprIterator::operator[](size_t idx) const { 1971 return cast<Expr>(I[idx]); 1972} 1973const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 1974const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 1975 1976//===----------------------------------------------------------------------===// 1977// Child Iterators for iterating over subexpressions/substatements 1978//===----------------------------------------------------------------------===// 1979 1980// DeclRefExpr 1981Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 1982Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 1983 1984// ObjCIvarRefExpr 1985Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; } 1986Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; } 1987 1988// ObjCPropertyRefExpr 1989Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; } 1990Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; } 1991 1992// ObjCImplicitSetterGetterRefExpr 1993Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_begin() { 1994 return &Base; 1995} 1996Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_end() { 1997 return &Base+1; 1998} 1999 2000// ObjCSuperExpr 2001Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); } 2002Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); } 2003 2004// ObjCIsaExpr 2005Stmt::child_iterator ObjCIsaExpr::child_begin() { return &Base; } 2006Stmt::child_iterator ObjCIsaExpr::child_end() { return &Base+1; } 2007 2008// PredefinedExpr 2009Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); } 2010Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); } 2011 2012// IntegerLiteral 2013Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 2014Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 2015 2016// CharacterLiteral 2017Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();} 2018Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 2019 2020// FloatingLiteral 2021Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 2022Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 2023 2024// ImaginaryLiteral 2025Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; } 2026Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; } 2027 2028// StringLiteral 2029Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 2030Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 2031 2032// ParenExpr 2033Stmt::child_iterator ParenExpr::child_begin() { return &Val; } 2034Stmt::child_iterator ParenExpr::child_end() { return &Val+1; } 2035 2036// UnaryOperator 2037Stmt::child_iterator UnaryOperator::child_begin() { return &Val; } 2038Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; } 2039 2040// SizeOfAlignOfExpr 2041Stmt::child_iterator SizeOfAlignOfExpr::child_begin() { 2042 // If this is of a type and the type is a VLA type (and not a typedef), the 2043 // size expression of the VLA needs to be treated as an executable expression. 2044 // Why isn't this weirdness documented better in StmtIterator? 2045 if (isArgumentType()) { 2046 if (VariableArrayType* T = dyn_cast<VariableArrayType>( 2047 getArgumentType().getTypePtr())) 2048 return child_iterator(T); 2049 return child_iterator(); 2050 } 2051 return child_iterator(&Argument.Ex); 2052} 2053Stmt::child_iterator SizeOfAlignOfExpr::child_end() { 2054 if (isArgumentType()) 2055 return child_iterator(); 2056 return child_iterator(&Argument.Ex + 1); 2057} 2058 2059// ArraySubscriptExpr 2060Stmt::child_iterator ArraySubscriptExpr::child_begin() { 2061 return &SubExprs[0]; 2062} 2063Stmt::child_iterator ArraySubscriptExpr::child_end() { 2064 return &SubExprs[0]+END_EXPR; 2065} 2066 2067// CallExpr 2068Stmt::child_iterator CallExpr::child_begin() { 2069 return &SubExprs[0]; 2070} 2071Stmt::child_iterator CallExpr::child_end() { 2072 return &SubExprs[0]+NumArgs+ARGS_START; 2073} 2074 2075// MemberExpr 2076Stmt::child_iterator MemberExpr::child_begin() { return &Base; } 2077Stmt::child_iterator MemberExpr::child_end() { return &Base+1; } 2078 2079// ExtVectorElementExpr 2080Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; } 2081Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; } 2082 2083// CompoundLiteralExpr 2084Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; } 2085Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; } 2086 2087// CastExpr 2088Stmt::child_iterator CastExpr::child_begin() { return &Op; } 2089Stmt::child_iterator CastExpr::child_end() { return &Op+1; } 2090 2091// BinaryOperator 2092Stmt::child_iterator BinaryOperator::child_begin() { 2093 return &SubExprs[0]; 2094} 2095Stmt::child_iterator BinaryOperator::child_end() { 2096 return &SubExprs[0]+END_EXPR; 2097} 2098 2099// ConditionalOperator 2100Stmt::child_iterator ConditionalOperator::child_begin() { 2101 return &SubExprs[0]; 2102} 2103Stmt::child_iterator ConditionalOperator::child_end() { 2104 return &SubExprs[0]+END_EXPR; 2105} 2106 2107// AddrLabelExpr 2108Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 2109Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 2110 2111// StmtExpr 2112Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; } 2113Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; } 2114 2115// TypesCompatibleExpr 2116Stmt::child_iterator TypesCompatibleExpr::child_begin() { 2117 return child_iterator(); 2118} 2119 2120Stmt::child_iterator TypesCompatibleExpr::child_end() { 2121 return child_iterator(); 2122} 2123 2124// ChooseExpr 2125Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; } 2126Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; } 2127 2128// GNUNullExpr 2129Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); } 2130Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); } 2131 2132// ShuffleVectorExpr 2133Stmt::child_iterator ShuffleVectorExpr::child_begin() { 2134 return &SubExprs[0]; 2135} 2136Stmt::child_iterator ShuffleVectorExpr::child_end() { 2137 return &SubExprs[0]+NumExprs; 2138} 2139 2140// VAArgExpr 2141Stmt::child_iterator VAArgExpr::child_begin() { return &Val; } 2142Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; } 2143 2144// InitListExpr 2145Stmt::child_iterator InitListExpr::child_begin() { 2146 return InitExprs.size() ? &InitExprs[0] : 0; 2147} 2148Stmt::child_iterator InitListExpr::child_end() { 2149 return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0; 2150} 2151 2152// DesignatedInitExpr 2153Stmt::child_iterator DesignatedInitExpr::child_begin() { 2154 char* Ptr = static_cast<char*>(static_cast<void *>(this)); 2155 Ptr += sizeof(DesignatedInitExpr); 2156 return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 2157} 2158Stmt::child_iterator DesignatedInitExpr::child_end() { 2159 return child_iterator(&*child_begin() + NumSubExprs); 2160} 2161 2162// ImplicitValueInitExpr 2163Stmt::child_iterator ImplicitValueInitExpr::child_begin() { 2164 return child_iterator(); 2165} 2166 2167Stmt::child_iterator ImplicitValueInitExpr::child_end() { 2168 return child_iterator(); 2169} 2170 2171// ParenListExpr 2172Stmt::child_iterator ParenListExpr::child_begin() { 2173 return &Exprs[0]; 2174} 2175Stmt::child_iterator ParenListExpr::child_end() { 2176 return &Exprs[0]+NumExprs; 2177} 2178 2179// ObjCStringLiteral 2180Stmt::child_iterator ObjCStringLiteral::child_begin() { 2181 return &String; 2182} 2183Stmt::child_iterator ObjCStringLiteral::child_end() { 2184 return &String+1; 2185} 2186 2187// ObjCEncodeExpr 2188Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 2189Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 2190 2191// ObjCSelectorExpr 2192Stmt::child_iterator ObjCSelectorExpr::child_begin() { 2193 return child_iterator(); 2194} 2195Stmt::child_iterator ObjCSelectorExpr::child_end() { 2196 return child_iterator(); 2197} 2198 2199// ObjCProtocolExpr 2200Stmt::child_iterator ObjCProtocolExpr::child_begin() { 2201 return child_iterator(); 2202} 2203Stmt::child_iterator ObjCProtocolExpr::child_end() { 2204 return child_iterator(); 2205} 2206 2207// ObjCMessageExpr 2208Stmt::child_iterator ObjCMessageExpr::child_begin() { 2209 return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START; 2210} 2211Stmt::child_iterator ObjCMessageExpr::child_end() { 2212 return &SubExprs[0]+ARGS_START+getNumArgs(); 2213} 2214 2215// Blocks 2216Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); } 2217Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); } 2218 2219Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();} 2220Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); } 2221