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