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