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