Expr.cpp revision 72c3f314d92d65c050ee1c07b7753623c044d6c7
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/RecordLayout.h" 20#include "clang/AST/StmtVisitor.h" 21#include "clang/Basic/TargetInfo.h" 22using namespace clang; 23 24//===----------------------------------------------------------------------===// 25// Primary Expressions. 26//===----------------------------------------------------------------------===// 27 28/// getValueAsApproximateDouble - This returns the value as an inaccurate 29/// double. Note that this may cause loss of precision, but is useful for 30/// debugging dumps, etc. 31double FloatingLiteral::getValueAsApproximateDouble() const { 32 llvm::APFloat V = getValue(); 33 bool ignored; 34 V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 35 &ignored); 36 return V.convertToDouble(); 37} 38 39 40StringLiteral::StringLiteral(const char *strData, unsigned byteLength, 41 bool Wide, QualType t, SourceLocation firstLoc, 42 SourceLocation lastLoc) : 43 Expr(StringLiteralClass, t) { 44 // OPTIMIZE: could allocate this appended to the StringLiteral. 45 char *AStrData = new char[byteLength]; 46 memcpy(AStrData, strData, byteLength); 47 StrData = AStrData; 48 ByteLength = byteLength; 49 IsWide = Wide; 50 firstTokLoc = firstLoc; 51 lastTokLoc = lastLoc; 52} 53 54StringLiteral::~StringLiteral() { 55 delete[] StrData; 56} 57 58bool UnaryOperator::isPostfix(Opcode Op) { 59 switch (Op) { 60 case PostInc: 61 case PostDec: 62 return true; 63 default: 64 return false; 65 } 66} 67 68bool UnaryOperator::isPrefix(Opcode Op) { 69 switch (Op) { 70 case PreInc: 71 case PreDec: 72 return true; 73 default: 74 return false; 75 } 76} 77 78/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 79/// corresponds to, e.g. "sizeof" or "[pre]++". 80const char *UnaryOperator::getOpcodeStr(Opcode Op) { 81 switch (Op) { 82 default: assert(0 && "Unknown unary operator"); 83 case PostInc: return "++"; 84 case PostDec: return "--"; 85 case PreInc: return "++"; 86 case PreDec: return "--"; 87 case AddrOf: return "&"; 88 case Deref: return "*"; 89 case Plus: return "+"; 90 case Minus: return "-"; 91 case Not: return "~"; 92 case LNot: return "!"; 93 case Real: return "__real"; 94 case Imag: return "__imag"; 95 case Extension: return "__extension__"; 96 case OffsetOf: return "__builtin_offsetof"; 97 } 98} 99 100//===----------------------------------------------------------------------===// 101// Postfix Operators. 102//===----------------------------------------------------------------------===// 103 104CallExpr::CallExpr(StmtClass SC, Expr *fn, Expr **args, unsigned numargs, 105 QualType t, SourceLocation rparenloc) 106 : Expr(SC, t), NumArgs(numargs) { 107 SubExprs = new Stmt*[numargs+1]; 108 SubExprs[FN] = fn; 109 for (unsigned i = 0; i != numargs; ++i) 110 SubExprs[i+ARGS_START] = args[i]; 111 RParenLoc = rparenloc; 112} 113 114CallExpr::CallExpr(Expr *fn, Expr **args, unsigned numargs, QualType t, 115 SourceLocation rparenloc) 116 : Expr(CallExprClass, t), NumArgs(numargs) { 117 SubExprs = new Stmt*[numargs+1]; 118 SubExprs[FN] = fn; 119 for (unsigned i = 0; i != numargs; ++i) 120 SubExprs[i+ARGS_START] = args[i]; 121 RParenLoc = rparenloc; 122} 123 124/// setNumArgs - This changes the number of arguments present in this call. 125/// Any orphaned expressions are deleted by this, and any new operands are set 126/// to null. 127void CallExpr::setNumArgs(unsigned NumArgs) { 128 // No change, just return. 129 if (NumArgs == getNumArgs()) return; 130 131 // If shrinking # arguments, just delete the extras and forgot them. 132 if (NumArgs < getNumArgs()) { 133 for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 134 delete getArg(i); 135 this->NumArgs = NumArgs; 136 return; 137 } 138 139 // Otherwise, we are growing the # arguments. New an bigger argument array. 140 Stmt **NewSubExprs = new Stmt*[NumArgs+1]; 141 // Copy over args. 142 for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 143 NewSubExprs[i] = SubExprs[i]; 144 // Null out new args. 145 for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 146 NewSubExprs[i] = 0; 147 148 delete[] SubExprs; 149 SubExprs = NewSubExprs; 150 this->NumArgs = NumArgs; 151} 152 153/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If 154/// not, return 0. 155unsigned CallExpr::isBuiltinCall() const { 156 // All simple function calls (e.g. func()) are implicitly cast to pointer to 157 // function. As a result, we try and obtain the DeclRefExpr from the 158 // ImplicitCastExpr. 159 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 160 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 161 return 0; 162 163 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 164 if (!DRE) 165 return 0; 166 167 const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 168 if (!FDecl) 169 return 0; 170 171 if (!FDecl->getIdentifier()) 172 return 0; 173 174 return FDecl->getIdentifier()->getBuiltinID(); 175} 176 177 178/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 179/// corresponds to, e.g. "<<=". 180const char *BinaryOperator::getOpcodeStr(Opcode Op) { 181 switch (Op) { 182 default: assert(0 && "Unknown binary operator"); 183 case Mul: return "*"; 184 case Div: return "/"; 185 case Rem: return "%"; 186 case Add: return "+"; 187 case Sub: return "-"; 188 case Shl: return "<<"; 189 case Shr: return ">>"; 190 case LT: return "<"; 191 case GT: return ">"; 192 case LE: return "<="; 193 case GE: return ">="; 194 case EQ: return "=="; 195 case NE: return "!="; 196 case And: return "&"; 197 case Xor: return "^"; 198 case Or: return "|"; 199 case LAnd: return "&&"; 200 case LOr: return "||"; 201 case Assign: return "="; 202 case MulAssign: return "*="; 203 case DivAssign: return "/="; 204 case RemAssign: return "%="; 205 case AddAssign: return "+="; 206 case SubAssign: return "-="; 207 case ShlAssign: return "<<="; 208 case ShrAssign: return ">>="; 209 case AndAssign: return "&="; 210 case XorAssign: return "^="; 211 case OrAssign: return "|="; 212 case Comma: return ","; 213 } 214} 215 216InitListExpr::InitListExpr(SourceLocation lbraceloc, 217 Expr **initExprs, unsigned numInits, 218 SourceLocation rbraceloc, bool hadDesignators) 219 : Expr(InitListExprClass, QualType()), 220 LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), HadDesignators(hadDesignators) { 221 222 InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits); 223} 224 225/// getFunctionType - Return the underlying function type for this block. 226/// 227const FunctionType *BlockExpr::getFunctionType() const { 228 return getType()->getAsBlockPointerType()-> 229 getPointeeType()->getAsFunctionType(); 230} 231 232SourceLocation BlockExpr::getCaretLocation() const { 233 return TheBlock->getCaretLocation(); 234} 235const Stmt *BlockExpr::getBody() const { return TheBlock->getBody(); } 236Stmt *BlockExpr::getBody() { return TheBlock->getBody(); } 237 238 239//===----------------------------------------------------------------------===// 240// Generic Expression Routines 241//===----------------------------------------------------------------------===// 242 243/// hasLocalSideEffect - Return true if this immediate expression has side 244/// effects, not counting any sub-expressions. 245bool Expr::hasLocalSideEffect() const { 246 switch (getStmtClass()) { 247 default: 248 return false; 249 case ParenExprClass: 250 return cast<ParenExpr>(this)->getSubExpr()->hasLocalSideEffect(); 251 case UnaryOperatorClass: { 252 const UnaryOperator *UO = cast<UnaryOperator>(this); 253 254 switch (UO->getOpcode()) { 255 default: return false; 256 case UnaryOperator::PostInc: 257 case UnaryOperator::PostDec: 258 case UnaryOperator::PreInc: 259 case UnaryOperator::PreDec: 260 return true; // ++/-- 261 262 case UnaryOperator::Deref: 263 // Dereferencing a volatile pointer is a side-effect. 264 return getType().isVolatileQualified(); 265 case UnaryOperator::Real: 266 case UnaryOperator::Imag: 267 // accessing a piece of a volatile complex is a side-effect. 268 return UO->getSubExpr()->getType().isVolatileQualified(); 269 270 case UnaryOperator::Extension: 271 return UO->getSubExpr()->hasLocalSideEffect(); 272 } 273 } 274 case BinaryOperatorClass: { 275 const BinaryOperator *BinOp = cast<BinaryOperator>(this); 276 // Consider comma to have side effects if the LHS and RHS both do. 277 if (BinOp->getOpcode() == BinaryOperator::Comma) 278 return BinOp->getLHS()->hasLocalSideEffect() && 279 BinOp->getRHS()->hasLocalSideEffect(); 280 281 return BinOp->isAssignmentOp(); 282 } 283 case CompoundAssignOperatorClass: 284 return true; 285 286 case ConditionalOperatorClass: { 287 const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 288 return Exp->getCond()->hasLocalSideEffect() 289 || (Exp->getLHS() && Exp->getLHS()->hasLocalSideEffect()) 290 || (Exp->getRHS() && Exp->getRHS()->hasLocalSideEffect()); 291 } 292 293 case MemberExprClass: 294 case ArraySubscriptExprClass: 295 // If the base pointer or element is to a volatile pointer/field, accessing 296 // if is a side effect. 297 return getType().isVolatileQualified(); 298 299 case CallExprClass: 300 case CXXOperatorCallExprClass: 301 // TODO: check attributes for pure/const. "void foo() { strlen("bar"); }" 302 // should warn. 303 return true; 304 case ObjCMessageExprClass: 305 return true; 306 case StmtExprClass: { 307 // Statement exprs don't logically have side effects themselves, but are 308 // sometimes used in macros in ways that give them a type that is unused. 309 // For example ({ blah; foo(); }) will end up with a type if foo has a type. 310 // however, if the result of the stmt expr is dead, we don't want to emit a 311 // warning. 312 const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 313 if (!CS->body_empty()) 314 if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 315 return E->hasLocalSideEffect(); 316 return false; 317 } 318 case CStyleCastExprClass: 319 case CXXFunctionalCastExprClass: 320 // If this is a cast to void, check the operand. Otherwise, the result of 321 // the cast is unused. 322 if (getType()->isVoidType()) 323 return cast<CastExpr>(this)->getSubExpr()->hasLocalSideEffect(); 324 return false; 325 326 case ImplicitCastExprClass: 327 // Check the operand, since implicit casts are inserted by Sema 328 return cast<ImplicitCastExpr>(this)->getSubExpr()->hasLocalSideEffect(); 329 330 case CXXDefaultArgExprClass: 331 return cast<CXXDefaultArgExpr>(this)->getExpr()->hasLocalSideEffect(); 332 333 case CXXNewExprClass: 334 // FIXME: In theory, there might be new expressions that don't have side 335 // effects (e.g. a placement new with an uninitialized POD). 336 case CXXDeleteExprClass: 337 return true; 338 } 339} 340 341/// DeclCanBeLvalue - Determine whether the given declaration can be 342/// an lvalue. This is a helper routine for isLvalue. 343static bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) { 344 // C++ [temp.param]p6: 345 // A non-type non-reference template-parameter is not an lvalue. 346 if (const NonTypeTemplateParmDecl *NTTParm 347 = dyn_cast<NonTypeTemplateParmDecl>(Decl)) 348 return NTTParm->getType()->isReferenceType(); 349 350 return isa<VarDecl>(Decl) || isa<CXXFieldDecl>(Decl) || 351 // C++ 3.10p2: An lvalue refers to an object or function. 352 (Ctx.getLangOptions().CPlusPlus && 353 (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl))); 354} 355 356/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 357/// incomplete type other than void. Nonarray expressions that can be lvalues: 358/// - name, where name must be a variable 359/// - e[i] 360/// - (e), where e must be an lvalue 361/// - e.name, where e must be an lvalue 362/// - e->name 363/// - *e, the type of e cannot be a function type 364/// - string-constant 365/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 366/// - reference type [C++ [expr]] 367/// 368Expr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const { 369 // first, check the type (C99 6.3.2.1). Expressions with function 370 // type in C are not lvalues, but they can be lvalues in C++. 371 if (!Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 372 return LV_NotObjectType; 373 374 // Allow qualified void which is an incomplete type other than void (yuck). 375 if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers()) 376 return LV_IncompleteVoidType; 377 378 /// FIXME: Expressions can't have reference type, so the following 379 /// isn't needed. 380 if (TR->isReferenceType()) // C++ [expr] 381 return LV_Valid; 382 383 // the type looks fine, now check the expression 384 switch (getStmtClass()) { 385 case StringLiteralClass: // C99 6.5.1p4 386 return LV_Valid; 387 case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 388 // For vectors, make sure base is an lvalue (i.e. not a function call). 389 if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 390 return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx); 391 return LV_Valid; 392 case DeclRefExprClass: { // C99 6.5.1p2 393 const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl(); 394 if (DeclCanBeLvalue(RefdDecl, Ctx)) 395 return LV_Valid; 396 break; 397 } 398 case BlockDeclRefExprClass: { 399 const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 400 if (isa<VarDecl>(BDR->getDecl())) 401 return LV_Valid; 402 break; 403 } 404 case MemberExprClass: { // C99 6.5.2.3p4 405 const MemberExpr *m = cast<MemberExpr>(this); 406 return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 407 } 408 case UnaryOperatorClass: 409 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 410 return LV_Valid; // C99 6.5.3p4 411 412 if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 413 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag || 414 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension) 415 return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU. 416 417 if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1 418 (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc || 419 cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec)) 420 return LV_Valid; 421 break; 422 case ImplicitCastExprClass: 423 return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid 424 : LV_InvalidExpression; 425 case ParenExprClass: // C99 6.5.1p5 426 return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx); 427 case BinaryOperatorClass: 428 case CompoundAssignOperatorClass: { 429 const BinaryOperator *BinOp = cast<BinaryOperator>(this); 430 431 if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1 432 BinOp->getOpcode() == BinaryOperator::Comma) 433 return BinOp->getRHS()->isLvalue(Ctx); 434 435 if (!BinOp->isAssignmentOp()) 436 return LV_InvalidExpression; 437 438 if (Ctx.getLangOptions().CPlusPlus) 439 // C++ [expr.ass]p1: 440 // The result of an assignment operation [...] is an lvalue. 441 return LV_Valid; 442 443 444 // C99 6.5.16: 445 // An assignment expression [...] is not an lvalue. 446 return LV_InvalidExpression; 447 } 448 case CallExprClass: 449 case CXXOperatorCallExprClass: { 450 // C++ [expr.call]p10: 451 // A function call is an lvalue if and only if the result type 452 // is a reference. 453 QualType CalleeType = cast<CallExpr>(this)->getCallee()->getType(); 454 if (const PointerType *FnTypePtr = CalleeType->getAsPointerType()) 455 if (const FunctionType *FnType 456 = FnTypePtr->getPointeeType()->getAsFunctionType()) 457 if (FnType->getResultType()->isReferenceType()) 458 return LV_Valid; 459 460 break; 461 } 462 case CompoundLiteralExprClass: // C99 6.5.2.5p5 463 return LV_Valid; 464 case ExtVectorElementExprClass: 465 if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 466 return LV_DuplicateVectorComponents; 467 return LV_Valid; 468 case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 469 return LV_Valid; 470 case ObjCPropertyRefExprClass: // FIXME: check if read-only property. 471 return LV_Valid; 472 case ObjCKVCRefExprClass: // FIXME: check if read-only property. 473 return LV_Valid; 474 case PredefinedExprClass: 475 return LV_Valid; 476 case VAArgExprClass: 477 return LV_Valid; 478 case CXXDefaultArgExprClass: 479 return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx); 480 case CXXConditionDeclExprClass: 481 return LV_Valid; 482 case CStyleCastExprClass: 483 case CXXFunctionalCastExprClass: 484 case CXXStaticCastExprClass: 485 case CXXDynamicCastExprClass: 486 case CXXReinterpretCastExprClass: 487 case CXXConstCastExprClass: 488 // The result of an explicit cast is an lvalue if the type we are 489 // casting to is a reference type. See C++ [expr.cast]p1, 490 // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2, 491 // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1. 492 if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()->isReferenceType()) 493 return LV_Valid; 494 break; 495 case CXXTypeidExprClass: 496 // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ... 497 return LV_Valid; 498 default: 499 break; 500 } 501 return LV_InvalidExpression; 502} 503 504/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 505/// does not have an incomplete type, does not have a const-qualified type, and 506/// if it is a structure or union, does not have any member (including, 507/// recursively, any member or element of all contained aggregates or unions) 508/// with a const-qualified type. 509Expr::isModifiableLvalueResult Expr::isModifiableLvalue(ASTContext &Ctx) const { 510 isLvalueResult lvalResult = isLvalue(Ctx); 511 512 switch (lvalResult) { 513 case LV_Valid: 514 // C++ 3.10p11: Functions cannot be modified, but pointers to 515 // functions can be modifiable. 516 if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 517 return MLV_NotObjectType; 518 break; 519 520 case LV_NotObjectType: return MLV_NotObjectType; 521 case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 522 case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 523 case LV_InvalidExpression: 524 // If the top level is a C-style cast, and the subexpression is a valid 525 // lvalue, then this is probably a use of the old-school "cast as lvalue" 526 // GCC extension. We don't support it, but we want to produce good 527 // diagnostics when it happens so that the user knows why. 528 if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(this)) 529 if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) 530 return MLV_LValueCast; 531 return MLV_InvalidExpression; 532 } 533 534 QualType CT = Ctx.getCanonicalType(getType()); 535 536 if (CT.isConstQualified()) 537 return MLV_ConstQualified; 538 if (CT->isArrayType()) 539 return MLV_ArrayType; 540 if (CT->isIncompleteType()) 541 return MLV_IncompleteType; 542 543 if (const RecordType *r = CT->getAsRecordType()) { 544 if (r->hasConstFields()) 545 return MLV_ConstQualified; 546 } 547 // The following is illegal: 548 // void takeclosure(void (^C)(void)); 549 // void func() { int x = 1; takeclosure(^{ x = 7 }); } 550 // 551 if (getStmtClass() == BlockDeclRefExprClass) { 552 const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 553 if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl())) 554 return MLV_NotBlockQualified; 555 } 556 // Assigning to a readonly property? 557 if (getStmtClass() == ObjCPropertyRefExprClass) { 558 const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(this); 559 if (ObjCPropertyDecl *PDecl = PropExpr->getProperty()) { 560 QualType BaseType = PropExpr->getBase()->getType(); 561 if (const PointerType *PTy = BaseType->getAsPointerType()) 562 if (const ObjCInterfaceType *IFTy = 563 PTy->getPointeeType()->getAsObjCInterfaceType()) 564 if (ObjCInterfaceDecl *IFace = IFTy->getDecl()) 565 if (IFace->isPropertyReadonly(PDecl)) 566 return MLV_ReadonlyProperty; 567 } 568 } 569 // Assigning to an 'implicit' property? 570 else if (getStmtClass() == ObjCKVCRefExprClass) { 571 const ObjCKVCRefExpr* KVCExpr = cast<ObjCKVCRefExpr>(this); 572 if (KVCExpr->getSetterMethod() == 0) 573 return MLV_NoSetterProperty; 574 } 575 return MLV_Valid; 576} 577 578/// hasGlobalStorage - Return true if this expression has static storage 579/// duration. This means that the address of this expression is a link-time 580/// constant. 581bool Expr::hasGlobalStorage() const { 582 switch (getStmtClass()) { 583 default: 584 return false; 585 case ParenExprClass: 586 return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage(); 587 case ImplicitCastExprClass: 588 return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage(); 589 case CompoundLiteralExprClass: 590 return cast<CompoundLiteralExpr>(this)->isFileScope(); 591 case DeclRefExprClass: { 592 const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 593 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 594 return VD->hasGlobalStorage(); 595 if (isa<FunctionDecl>(D)) 596 return true; 597 return false; 598 } 599 case MemberExprClass: { 600 const MemberExpr *M = cast<MemberExpr>(this); 601 return !M->isArrow() && M->getBase()->hasGlobalStorage(); 602 } 603 case ArraySubscriptExprClass: 604 return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage(); 605 case PredefinedExprClass: 606 return true; 607 case CXXDefaultArgExprClass: 608 return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage(); 609 } 610} 611 612Expr* Expr::IgnoreParens() { 613 Expr* E = this; 614 while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 615 E = P->getSubExpr(); 616 617 return E; 618} 619 620/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 621/// or CastExprs or ImplicitCastExprs, returning their operand. 622Expr *Expr::IgnoreParenCasts() { 623 Expr *E = this; 624 while (true) { 625 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 626 E = P->getSubExpr(); 627 else if (CastExpr *P = dyn_cast<CastExpr>(E)) 628 E = P->getSubExpr(); 629 else 630 return E; 631 } 632} 633 634bool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const { 635 switch (getStmtClass()) { 636 default: 637 if (!isEvaluatable(Ctx)) { 638 if (Loc) *Loc = getLocStart(); 639 return false; 640 } 641 break; 642 case StringLiteralClass: 643 return true; 644 case InitListExprClass: { 645 const InitListExpr *Exp = cast<InitListExpr>(this); 646 unsigned numInits = Exp->getNumInits(); 647 for (unsigned i = 0; i < numInits; i++) { 648 if (!Exp->getInit(i)->isConstantExpr(Ctx, Loc)) 649 return false; 650 } 651 } 652 } 653 654 return true; 655} 656 657/// isIntegerConstantExpr - this recursive routine will test if an expression is 658/// an integer constant expression. Note: With the introduction of VLA's in 659/// C99 the result of the sizeof operator is no longer always a constant 660/// expression. The generalization of the wording to include any subexpression 661/// that is not evaluated (C99 6.6p3) means that nonconstant subexpressions 662/// can appear as operands to other operators (e.g. &&, ||, ?:). For instance, 663/// "0 || f()" can be treated as a constant expression. In C90 this expression, 664/// occurring in a context requiring a constant, would have been a constraint 665/// violation. FIXME: This routine currently implements C90 semantics. 666/// To properly implement C99 semantics this routine will need to evaluate 667/// expressions involving operators previously mentioned. 668 669/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 670/// comma, etc 671/// 672/// FIXME: This should ext-warn on overflow during evaluation! ISO C does not 673/// permit this. This includes things like (int)1e1000 674/// 675/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof 676/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer 677/// cast+dereference. 678bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, 679 SourceLocation *Loc, bool isEvaluated) const { 680 // Pretest for integral type; some parts of the code crash for types that 681 // can't be sized. 682 if (!getType()->isIntegralType()) { 683 if (Loc) *Loc = getLocStart(); 684 return false; 685 } 686 switch (getStmtClass()) { 687 default: 688 if (Loc) *Loc = getLocStart(); 689 return false; 690 case ParenExprClass: 691 return cast<ParenExpr>(this)->getSubExpr()-> 692 isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 693 case IntegerLiteralClass: 694 Result = cast<IntegerLiteral>(this)->getValue(); 695 break; 696 case CharacterLiteralClass: { 697 const CharacterLiteral *CL = cast<CharacterLiteral>(this); 698 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 699 Result = CL->getValue(); 700 Result.setIsUnsigned(!getType()->isSignedIntegerType()); 701 break; 702 } 703 case CXXBoolLiteralExprClass: { 704 const CXXBoolLiteralExpr *BL = cast<CXXBoolLiteralExpr>(this); 705 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 706 Result = BL->getValue(); 707 Result.setIsUnsigned(!getType()->isSignedIntegerType()); 708 break; 709 } 710 case CXXZeroInitValueExprClass: 711 Result.clear(); 712 break; 713 case TypesCompatibleExprClass: { 714 const TypesCompatibleExpr *TCE = cast<TypesCompatibleExpr>(this); 715 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 716 // Per gcc docs "this built-in function ignores top level 717 // qualifiers". We need to use the canonical version to properly 718 // be able to strip CRV qualifiers from the type. 719 QualType T0 = Ctx.getCanonicalType(TCE->getArgType1()); 720 QualType T1 = Ctx.getCanonicalType(TCE->getArgType2()); 721 Result = Ctx.typesAreCompatible(T0.getUnqualifiedType(), 722 T1.getUnqualifiedType()); 723 break; 724 } 725 case CallExprClass: 726 case CXXOperatorCallExprClass: { 727 const CallExpr *CE = cast<CallExpr>(this); 728 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 729 730 // If this is a call to a builtin function, constant fold it otherwise 731 // reject it. 732 if (CE->isBuiltinCall()) { 733 APValue ResultAP; 734 if (CE->Evaluate(ResultAP, Ctx)) { 735 Result = ResultAP.getInt(); 736 break; // It is a constant, expand it. 737 } 738 } 739 740 if (Loc) *Loc = getLocStart(); 741 return false; 742 } 743 case DeclRefExprClass: 744 if (const EnumConstantDecl *D = 745 dyn_cast<EnumConstantDecl>(cast<DeclRefExpr>(this)->getDecl())) { 746 Result = D->getInitVal(); 747 break; 748 } 749 if (Loc) *Loc = getLocStart(); 750 return false; 751 case UnaryOperatorClass: { 752 const UnaryOperator *Exp = cast<UnaryOperator>(this); 753 754 // Get the operand value. If this is offsetof, do not evalute the 755 // operand. This affects C99 6.6p3. 756 if (!Exp->isOffsetOfOp() && !Exp->getSubExpr()-> 757 isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 758 return false; 759 760 switch (Exp->getOpcode()) { 761 // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 762 // See C99 6.6p3. 763 default: 764 if (Loc) *Loc = Exp->getOperatorLoc(); 765 return false; 766 case UnaryOperator::Extension: 767 return true; // FIXME: this is wrong. 768 case UnaryOperator::LNot: { 769 bool Val = Result == 0; 770 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 771 Result = Val; 772 break; 773 } 774 case UnaryOperator::Plus: 775 break; 776 case UnaryOperator::Minus: 777 Result = -Result; 778 break; 779 case UnaryOperator::Not: 780 Result = ~Result; 781 break; 782 case UnaryOperator::OffsetOf: 783 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 784 Result = Exp->evaluateOffsetOf(Ctx); 785 } 786 break; 787 } 788 case SizeOfAlignOfExprClass: { 789 const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(this); 790 791 // Return the result in the right width. 792 Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 793 794 QualType ArgTy = Exp->getTypeOfArgument(); 795 // sizeof(void) and __alignof__(void) = 1 as a gcc extension. 796 if (ArgTy->isVoidType()) { 797 Result = 1; 798 break; 799 } 800 801 // alignof always evaluates to a constant, sizeof does if arg is not VLA. 802 if (Exp->isSizeOf() && !ArgTy->isConstantSizeType()) { 803 if (Loc) *Loc = Exp->getOperatorLoc(); 804 return false; 805 } 806 807 // Get information about the size or align. 808 if (ArgTy->isFunctionType()) { 809 // GCC extension: sizeof(function) = 1. 810 Result = Exp->isSizeOf() ? 1 : 4; 811 } else { 812 unsigned CharSize = Ctx.Target.getCharWidth(); 813 if (Exp->isSizeOf()) 814 Result = Ctx.getTypeSize(ArgTy) / CharSize; 815 else 816 Result = Ctx.getTypeAlign(ArgTy) / CharSize; 817 } 818 break; 819 } 820 case BinaryOperatorClass: { 821 const BinaryOperator *Exp = cast<BinaryOperator>(this); 822 llvm::APSInt LHS, RHS; 823 824 // Initialize result to have correct signedness and width. 825 Result = llvm::APSInt(static_cast<uint32_t>(Ctx.getTypeSize(getType())), 826 !getType()->isSignedIntegerType()); 827 828 // The LHS of a constant expr is always evaluated and needed. 829 if (!Exp->getLHS()->isIntegerConstantExpr(LHS, Ctx, Loc, isEvaluated)) 830 return false; 831 832 // The short-circuiting &&/|| operators don't necessarily evaluate their 833 // RHS. Make sure to pass isEvaluated down correctly. 834 if (Exp->isLogicalOp()) { 835 bool RHSEval; 836 if (Exp->getOpcode() == BinaryOperator::LAnd) 837 RHSEval = LHS != 0; 838 else { 839 assert(Exp->getOpcode() == BinaryOperator::LOr &&"Unexpected logical"); 840 RHSEval = LHS == 0; 841 } 842 843 if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, 844 isEvaluated & RHSEval)) 845 return false; 846 } else { 847 if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, isEvaluated)) 848 return false; 849 } 850 851 switch (Exp->getOpcode()) { 852 default: 853 if (Loc) *Loc = getLocStart(); 854 return false; 855 case BinaryOperator::Mul: 856 Result = LHS * RHS; 857 break; 858 case BinaryOperator::Div: 859 if (RHS == 0) { 860 if (!isEvaluated) break; 861 if (Loc) *Loc = getLocStart(); 862 return false; 863 } 864 Result = LHS / RHS; 865 break; 866 case BinaryOperator::Rem: 867 if (RHS == 0) { 868 if (!isEvaluated) break; 869 if (Loc) *Loc = getLocStart(); 870 return false; 871 } 872 Result = LHS % RHS; 873 break; 874 case BinaryOperator::Add: Result = LHS + RHS; break; 875 case BinaryOperator::Sub: Result = LHS - RHS; break; 876 case BinaryOperator::Shl: 877 Result = LHS << 878 static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1)); 879 break; 880 case BinaryOperator::Shr: 881 Result = LHS >> 882 static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1)); 883 break; 884 case BinaryOperator::LT: Result = LHS < RHS; break; 885 case BinaryOperator::GT: Result = LHS > RHS; break; 886 case BinaryOperator::LE: Result = LHS <= RHS; break; 887 case BinaryOperator::GE: Result = LHS >= RHS; break; 888 case BinaryOperator::EQ: Result = LHS == RHS; break; 889 case BinaryOperator::NE: Result = LHS != RHS; break; 890 case BinaryOperator::And: Result = LHS & RHS; break; 891 case BinaryOperator::Xor: Result = LHS ^ RHS; break; 892 case BinaryOperator::Or: Result = LHS | RHS; break; 893 case BinaryOperator::LAnd: 894 Result = LHS != 0 && RHS != 0; 895 break; 896 case BinaryOperator::LOr: 897 Result = LHS != 0 || RHS != 0; 898 break; 899 900 case BinaryOperator::Comma: 901 // C99 6.6p3: "shall not contain assignment, ..., or comma operators, 902 // *except* when they are contained within a subexpression that is not 903 // evaluated". Note that Assignment can never happen due to constraints 904 // on the LHS subexpr, so we don't need to check it here. 905 if (isEvaluated) { 906 if (Loc) *Loc = getLocStart(); 907 return false; 908 } 909 910 // The result of the constant expr is the RHS. 911 Result = RHS; 912 return true; 913 } 914 915 assert(!Exp->isAssignmentOp() && "LHS can't be a constant expr!"); 916 break; 917 } 918 case ImplicitCastExprClass: 919 case CStyleCastExprClass: 920 case CXXFunctionalCastExprClass: { 921 const Expr *SubExpr = cast<CastExpr>(this)->getSubExpr(); 922 SourceLocation CastLoc = getLocStart(); 923 924 // C99 6.6p6: shall only convert arithmetic types to integer types. 925 if (!SubExpr->getType()->isArithmeticType() || 926 !getType()->isIntegerType()) { 927 if (Loc) *Loc = SubExpr->getLocStart(); 928 return false; 929 } 930 931 uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType())); 932 933 // Handle simple integer->integer casts. 934 if (SubExpr->getType()->isIntegerType()) { 935 if (!SubExpr->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 936 return false; 937 938 // Figure out if this is a truncate, extend or noop cast. 939 // If the input is signed, do a sign extend, noop, or truncate. 940 if (getType()->isBooleanType()) { 941 // Conversion to bool compares against zero. 942 Result = Result != 0; 943 Result.zextOrTrunc(DestWidth); 944 } else if (SubExpr->getType()->isSignedIntegerType()) 945 Result.sextOrTrunc(DestWidth); 946 else // If the input is unsigned, do a zero extend, noop, or truncate. 947 Result.zextOrTrunc(DestWidth); 948 break; 949 } 950 951 // Allow floating constants that are the immediate operands of casts or that 952 // are parenthesized. 953 const Expr *Operand = SubExpr; 954 while (const ParenExpr *PE = dyn_cast<ParenExpr>(Operand)) 955 Operand = PE->getSubExpr(); 956 957 // If this isn't a floating literal, we can't handle it. 958 const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(Operand); 959 if (!FL) { 960 if (Loc) *Loc = Operand->getLocStart(); 961 return false; 962 } 963 964 // If the destination is boolean, compare against zero. 965 if (getType()->isBooleanType()) { 966 Result = !FL->getValue().isZero(); 967 Result.zextOrTrunc(DestWidth); 968 break; 969 } 970 971 // Determine whether we are converting to unsigned or signed. 972 bool DestSigned = getType()->isSignedIntegerType(); 973 974 // TODO: Warn on overflow, but probably not here: isIntegerConstantExpr can 975 // be called multiple times per AST. 976 uint64_t Space[4]; 977 bool ignored; 978 (void)FL->getValue().convertToInteger(Space, DestWidth, DestSigned, 979 llvm::APFloat::rmTowardZero, 980 &ignored); 981 Result = llvm::APInt(DestWidth, 4, Space); 982 break; 983 } 984 case ConditionalOperatorClass: { 985 const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 986 987 if (!Exp->getCond()->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 988 return false; 989 990 const Expr *TrueExp = Exp->getLHS(); 991 const Expr *FalseExp = Exp->getRHS(); 992 if (Result == 0) std::swap(TrueExp, FalseExp); 993 994 // Evaluate the false one first, discard the result. 995 if (FalseExp && !FalseExp->isIntegerConstantExpr(Result, Ctx, Loc, false)) 996 return false; 997 // Evalute the true one, capture the result. 998 if (TrueExp && 999 !TrueExp->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 1000 return false; 1001 break; 1002 } 1003 case CXXDefaultArgExprClass: 1004 return cast<CXXDefaultArgExpr>(this) 1005 ->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 1006 } 1007 1008 // Cases that are valid constant exprs fall through to here. 1009 Result.setIsUnsigned(getType()->isUnsignedIntegerType()); 1010 return true; 1011} 1012 1013/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an 1014/// integer constant expression with the value zero, or if this is one that is 1015/// cast to void*. 1016bool Expr::isNullPointerConstant(ASTContext &Ctx) const 1017{ 1018 // Strip off a cast to void*, if it exists. Except in C++. 1019 if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 1020 if (!Ctx.getLangOptions().CPlusPlus) { 1021 // Check that it is a cast to void*. 1022 if (const PointerType *PT = CE->getType()->getAsPointerType()) { 1023 QualType Pointee = PT->getPointeeType(); 1024 if (Pointee.getCVRQualifiers() == 0 && 1025 Pointee->isVoidType() && // to void* 1026 CE->getSubExpr()->getType()->isIntegerType()) // from int. 1027 return CE->getSubExpr()->isNullPointerConstant(Ctx); 1028 } 1029 } 1030 } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1031 // Ignore the ImplicitCastExpr type entirely. 1032 return ICE->getSubExpr()->isNullPointerConstant(Ctx); 1033 } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1034 // Accept ((void*)0) as a null pointer constant, as many other 1035 // implementations do. 1036 return PE->getSubExpr()->isNullPointerConstant(Ctx); 1037 } else if (const CXXDefaultArgExpr *DefaultArg 1038 = dyn_cast<CXXDefaultArgExpr>(this)) { 1039 // See through default argument expressions 1040 return DefaultArg->getExpr()->isNullPointerConstant(Ctx); 1041 } else if (isa<GNUNullExpr>(this)) { 1042 // The GNU __null extension is always a null pointer constant. 1043 return true; 1044 } 1045 1046 // This expression must be an integer type. 1047 if (!getType()->isIntegerType()) 1048 return false; 1049 1050 // If we have an integer constant expression, we need to *evaluate* it and 1051 // test for the value 0. 1052 // FIXME: We should probably return false if we're compiling in strict mode 1053 // and Diag is not null (this indicates that the value was foldable but not 1054 // an ICE. 1055 EvalResult Result; 1056 return Evaluate(Result, Ctx) && !Result.HasSideEffects && 1057 Result.Val.isInt() && Result.Val.getInt() == 0; 1058} 1059 1060/// isBitField - Return true if this expression is a bit-field. 1061bool Expr::isBitField() { 1062 Expr *E = this->IgnoreParenCasts(); 1063 if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 1064 return MemRef->getMemberDecl()->isBitField(); 1065 return false; 1066} 1067 1068unsigned ExtVectorElementExpr::getNumElements() const { 1069 if (const VectorType *VT = getType()->getAsVectorType()) 1070 return VT->getNumElements(); 1071 return 1; 1072} 1073 1074/// containsDuplicateElements - Return true if any element access is repeated. 1075bool ExtVectorElementExpr::containsDuplicateElements() const { 1076 const char *compStr = Accessor.getName(); 1077 unsigned length = Accessor.getLength(); 1078 1079 for (unsigned i = 0; i != length-1; i++) { 1080 const char *s = compStr+i; 1081 for (const char c = *s++; *s; s++) 1082 if (c == *s) 1083 return true; 1084 } 1085 return false; 1086} 1087 1088/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 1089void ExtVectorElementExpr::getEncodedElementAccess( 1090 llvm::SmallVectorImpl<unsigned> &Elts) const { 1091 bool isHi = Accessor.isStr("hi"); 1092 bool isLo = Accessor.isStr("lo"); 1093 bool isEven = Accessor.isStr("e"); 1094 bool isOdd = Accessor.isStr("o"); 1095 1096 const char *compStr = Accessor.getName(); 1097 for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 1098 uint64_t Index; 1099 1100 if (isHi) 1101 Index = e + i; 1102 else if (isLo) 1103 Index = i; 1104 else if (isEven) 1105 Index = 2 * i; 1106 else if (isOdd) 1107 Index = 2 * i + 1; 1108 else 1109 Index = ExtVectorType::getAccessorIdx(compStr[i]); 1110 1111 Elts.push_back(Index); 1112 } 1113} 1114 1115// constructor for instance messages. 1116ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1117 QualType retType, ObjCMethodDecl *mproto, 1118 SourceLocation LBrac, SourceLocation RBrac, 1119 Expr **ArgExprs, unsigned nargs) 1120 : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1121 MethodProto(mproto) { 1122 NumArgs = nargs; 1123 SubExprs = new Stmt*[NumArgs+1]; 1124 SubExprs[RECEIVER] = receiver; 1125 if (NumArgs) { 1126 for (unsigned i = 0; i != NumArgs; ++i) 1127 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1128 } 1129 LBracloc = LBrac; 1130 RBracloc = RBrac; 1131} 1132 1133// constructor for class messages. 1134// FIXME: clsName should be typed to ObjCInterfaceType 1135ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1136 QualType retType, ObjCMethodDecl *mproto, 1137 SourceLocation LBrac, SourceLocation RBrac, 1138 Expr **ArgExprs, unsigned nargs) 1139 : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1140 MethodProto(mproto) { 1141 NumArgs = nargs; 1142 SubExprs = new Stmt*[NumArgs+1]; 1143 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown); 1144 if (NumArgs) { 1145 for (unsigned i = 0; i != NumArgs; ++i) 1146 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1147 } 1148 LBracloc = LBrac; 1149 RBracloc = RBrac; 1150} 1151 1152// constructor for class messages. 1153ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo, 1154 QualType retType, ObjCMethodDecl *mproto, 1155 SourceLocation LBrac, SourceLocation RBrac, 1156 Expr **ArgExprs, unsigned nargs) 1157: Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1158MethodProto(mproto) { 1159 NumArgs = nargs; 1160 SubExprs = new Stmt*[NumArgs+1]; 1161 SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown); 1162 if (NumArgs) { 1163 for (unsigned i = 0; i != NumArgs; ++i) 1164 SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 1165 } 1166 LBracloc = LBrac; 1167 RBracloc = RBrac; 1168} 1169 1170ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const { 1171 uintptr_t x = (uintptr_t) SubExprs[RECEIVER]; 1172 switch (x & Flags) { 1173 default: 1174 assert(false && "Invalid ObjCMessageExpr."); 1175 case IsInstMeth: 1176 return ClassInfo(0, 0); 1177 case IsClsMethDeclUnknown: 1178 return ClassInfo(0, (IdentifierInfo*) (x & ~Flags)); 1179 case IsClsMethDeclKnown: { 1180 ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags); 1181 return ClassInfo(D, D->getIdentifier()); 1182 } 1183 } 1184} 1185 1186bool ChooseExpr::isConditionTrue(ASTContext &C) const { 1187 return getCond()->getIntegerConstantExprValue(C) != 0; 1188} 1189 1190static int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) 1191{ 1192 if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 1193 QualType Ty = ME->getBase()->getType(); 1194 1195 RecordDecl *RD = Ty->getAsRecordType()->getDecl(); 1196 const ASTRecordLayout &RL = C.getASTRecordLayout(RD); 1197 FieldDecl *FD = ME->getMemberDecl(); 1198 1199 // FIXME: This is linear time. 1200 unsigned i = 0, e = 0; 1201 for (i = 0, e = RD->getNumMembers(); i != e; i++) { 1202 if (RD->getMember(i) == FD) 1203 break; 1204 } 1205 1206 return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase()); 1207 } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) { 1208 const Expr *Base = ASE->getBase(); 1209 1210 int64_t size = C.getTypeSize(ASE->getType()); 1211 size *= ASE->getIdx()->getIntegerConstantExprValue(C).getSExtValue(); 1212 1213 return size + evaluateOffsetOf(C, Base); 1214 } else if (isa<CompoundLiteralExpr>(E)) 1215 return 0; 1216 1217 assert(0 && "Unknown offsetof subexpression!"); 1218 return 0; 1219} 1220 1221int64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const 1222{ 1223 assert(Opc == OffsetOf && "Unary operator not offsetof!"); 1224 1225 unsigned CharSize = C.Target.getCharWidth(); 1226 return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize; 1227} 1228 1229void SizeOfAlignOfExpr::Destroy(ASTContext& C) { 1230 // Override default behavior of traversing children. If this has a type 1231 // operand and the type is a variable-length array, the child iteration 1232 // will iterate over the size expression. However, this expression belongs 1233 // to the type, not to this, so we don't want to delete it. 1234 // We still want to delete this expression. 1235 // FIXME: Same as in Stmt::Destroy - will be eventually in ASTContext's 1236 // pool allocator. 1237 if (isArgumentType()) 1238 delete this; 1239 else 1240 Expr::Destroy(C); 1241} 1242 1243//===----------------------------------------------------------------------===// 1244// ExprIterator. 1245//===----------------------------------------------------------------------===// 1246 1247Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 1248Expr* ExprIterator::operator*() const { return cast<Expr>(*I); } 1249Expr* ExprIterator::operator->() const { return cast<Expr>(*I); } 1250const Expr* ConstExprIterator::operator[](size_t idx) const { 1251 return cast<Expr>(I[idx]); 1252} 1253const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 1254const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 1255 1256//===----------------------------------------------------------------------===// 1257// Child Iterators for iterating over subexpressions/substatements 1258//===----------------------------------------------------------------------===// 1259 1260// DeclRefExpr 1261Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 1262Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 1263 1264// ObjCIvarRefExpr 1265Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; } 1266Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; } 1267 1268// ObjCPropertyRefExpr 1269Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; } 1270Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; } 1271 1272// ObjCKVCRefExpr 1273Stmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; } 1274Stmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; } 1275 1276// ObjCSuperExpr 1277Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); } 1278Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); } 1279 1280// PredefinedExpr 1281Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); } 1282Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); } 1283 1284// IntegerLiteral 1285Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 1286Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 1287 1288// CharacterLiteral 1289Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator(); } 1290Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 1291 1292// FloatingLiteral 1293Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 1294Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 1295 1296// ImaginaryLiteral 1297Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; } 1298Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; } 1299 1300// StringLiteral 1301Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 1302Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 1303 1304// ParenExpr 1305Stmt::child_iterator ParenExpr::child_begin() { return &Val; } 1306Stmt::child_iterator ParenExpr::child_end() { return &Val+1; } 1307 1308// UnaryOperator 1309Stmt::child_iterator UnaryOperator::child_begin() { return &Val; } 1310Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; } 1311 1312// SizeOfAlignOfExpr 1313Stmt::child_iterator SizeOfAlignOfExpr::child_begin() { 1314 // If this is of a type and the type is a VLA type (and not a typedef), the 1315 // size expression of the VLA needs to be treated as an executable expression. 1316 // Why isn't this weirdness documented better in StmtIterator? 1317 if (isArgumentType()) { 1318 if (VariableArrayType* T = dyn_cast<VariableArrayType>( 1319 getArgumentType().getTypePtr())) 1320 return child_iterator(T); 1321 return child_iterator(); 1322 } 1323 return child_iterator(&Argument.Ex); 1324} 1325Stmt::child_iterator SizeOfAlignOfExpr::child_end() { 1326 if (isArgumentType()) 1327 return child_iterator(); 1328 return child_iterator(&Argument.Ex + 1); 1329} 1330 1331// ArraySubscriptExpr 1332Stmt::child_iterator ArraySubscriptExpr::child_begin() { 1333 return &SubExprs[0]; 1334} 1335Stmt::child_iterator ArraySubscriptExpr::child_end() { 1336 return &SubExprs[0]+END_EXPR; 1337} 1338 1339// CallExpr 1340Stmt::child_iterator CallExpr::child_begin() { 1341 return &SubExprs[0]; 1342} 1343Stmt::child_iterator CallExpr::child_end() { 1344 return &SubExprs[0]+NumArgs+ARGS_START; 1345} 1346 1347// MemberExpr 1348Stmt::child_iterator MemberExpr::child_begin() { return &Base; } 1349Stmt::child_iterator MemberExpr::child_end() { return &Base+1; } 1350 1351// ExtVectorElementExpr 1352Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; } 1353Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; } 1354 1355// CompoundLiteralExpr 1356Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; } 1357Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; } 1358 1359// CastExpr 1360Stmt::child_iterator CastExpr::child_begin() { return &Op; } 1361Stmt::child_iterator CastExpr::child_end() { return &Op+1; } 1362 1363// BinaryOperator 1364Stmt::child_iterator BinaryOperator::child_begin() { 1365 return &SubExprs[0]; 1366} 1367Stmt::child_iterator BinaryOperator::child_end() { 1368 return &SubExprs[0]+END_EXPR; 1369} 1370 1371// ConditionalOperator 1372Stmt::child_iterator ConditionalOperator::child_begin() { 1373 return &SubExprs[0]; 1374} 1375Stmt::child_iterator ConditionalOperator::child_end() { 1376 return &SubExprs[0]+END_EXPR; 1377} 1378 1379// AddrLabelExpr 1380Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 1381Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 1382 1383// StmtExpr 1384Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; } 1385Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; } 1386 1387// TypesCompatibleExpr 1388Stmt::child_iterator TypesCompatibleExpr::child_begin() { 1389 return child_iterator(); 1390} 1391 1392Stmt::child_iterator TypesCompatibleExpr::child_end() { 1393 return child_iterator(); 1394} 1395 1396// ChooseExpr 1397Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; } 1398Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; } 1399 1400// GNUNullExpr 1401Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); } 1402Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); } 1403 1404// OverloadExpr 1405Stmt::child_iterator OverloadExpr::child_begin() { return &SubExprs[0]; } 1406Stmt::child_iterator OverloadExpr::child_end() { return &SubExprs[0]+NumExprs; } 1407 1408// ShuffleVectorExpr 1409Stmt::child_iterator ShuffleVectorExpr::child_begin() { 1410 return &SubExprs[0]; 1411} 1412Stmt::child_iterator ShuffleVectorExpr::child_end() { 1413 return &SubExprs[0]+NumExprs; 1414} 1415 1416// VAArgExpr 1417Stmt::child_iterator VAArgExpr::child_begin() { return &Val; } 1418Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; } 1419 1420// InitListExpr 1421Stmt::child_iterator InitListExpr::child_begin() { 1422 return InitExprs.size() ? &InitExprs[0] : 0; 1423} 1424Stmt::child_iterator InitListExpr::child_end() { 1425 return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0; 1426} 1427 1428// ObjCStringLiteral 1429Stmt::child_iterator ObjCStringLiteral::child_begin() { 1430 return child_iterator(); 1431} 1432Stmt::child_iterator ObjCStringLiteral::child_end() { 1433 return child_iterator(); 1434} 1435 1436// ObjCEncodeExpr 1437Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 1438Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 1439 1440// ObjCSelectorExpr 1441Stmt::child_iterator ObjCSelectorExpr::child_begin() { 1442 return child_iterator(); 1443} 1444Stmt::child_iterator ObjCSelectorExpr::child_end() { 1445 return child_iterator(); 1446} 1447 1448// ObjCProtocolExpr 1449Stmt::child_iterator ObjCProtocolExpr::child_begin() { 1450 return child_iterator(); 1451} 1452Stmt::child_iterator ObjCProtocolExpr::child_end() { 1453 return child_iterator(); 1454} 1455 1456// ObjCMessageExpr 1457Stmt::child_iterator ObjCMessageExpr::child_begin() { 1458 return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START; 1459} 1460Stmt::child_iterator ObjCMessageExpr::child_end() { 1461 return &SubExprs[0]+ARGS_START+getNumArgs(); 1462} 1463 1464// Blocks 1465Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); } 1466Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); } 1467 1468Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();} 1469Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); } 1470