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