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