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