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