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