Expr.cpp revision cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- Expr.cpp - Expression AST Node Implementation --------------------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This file implements the Expr class and subclasses. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/Expr.h" 15a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner#include "clang/AST/APValue.h" 162eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner#include "clang/AST/ASTContext.h" 17a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner#include "clang/AST/DeclObjC.h" 1898cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor#include "clang/AST/DeclCXX.h" 19e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar#include "clang/AST/RecordLayout.h" 205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/StmtVisitor.h" 21da5a6b6d9fd52899499d5b7b46273ec844dcaa6eChris Lattner#include "clang/Basic/TargetInfo.h" 225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Primary Expressions. 265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 28da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// getValueAsApproximateDouble - This returns the value as an inaccurate 29da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// double. Note that this may cause loss of precision, but is useful for 30da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// debugging dumps, etc. 31da8249e57f3badecf925571881fe57243935c6c1Chris Lattnerdouble FloatingLiteral::getValueAsApproximateDouble() const { 32da8249e57f3badecf925571881fe57243935c6c1Chris Lattner llvm::APFloat V = getValue(); 33ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen bool ignored; 34ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 35ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen &ignored); 36da8249e57f3badecf925571881fe57243935c6c1Chris Lattner return V.convertToDouble(); 37da8249e57f3badecf925571881fe57243935c6c1Chris Lattner} 38da8249e57f3badecf925571881fe57243935c6c1Chris Lattner 39da8249e57f3badecf925571881fe57243935c6c1Chris Lattner 405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerStringLiteral::StringLiteral(const char *strData, unsigned byteLength, 415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer bool Wide, QualType t, SourceLocation firstLoc, 425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation lastLoc) : 435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Expr(StringLiteralClass, t) { 445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // OPTIMIZE: could allocate this appended to the StringLiteral. 455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer char *AStrData = new char[byteLength]; 465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer memcpy(AStrData, strData, byteLength); 475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer StrData = AStrData; 485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ByteLength = byteLength; 495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer IsWide = Wide; 505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer firstTokLoc = firstLoc; 515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer lastTokLoc = lastLoc; 525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerStringLiteral::~StringLiteral() { 555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer delete[] StrData; 565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool UnaryOperator::isPostfix(Opcode Op) { 595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostInc: 615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostDec: 625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 685a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenekbool UnaryOperator::isPrefix(Opcode Op) { 695a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek switch (Op) { 705a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek case PreInc: 715a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek case PreDec: 725a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek return true; 735a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek default: 745a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek return false; 755a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek } 765a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek} 775a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek 785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "sizeof" or "[pre]++". 805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *UnaryOperator::getOpcodeStr(Opcode Op) { 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown unary operator"); 835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostInc: return "++"; 845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostDec: return "--"; 855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreInc: return "++"; 865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreDec: return "--"; 875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddrOf: return "&"; 885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Deref: return "*"; 895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Plus: return "+"; 905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Minus: return "-"; 915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Not: return "~"; 925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LNot: return "!"; 935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Real: return "__real"; 945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Imag: return "__imag"; 955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SizeOf: return "sizeof"; 965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AlignOf: return "alignof"; 975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Extension: return "__extension__"; 9873d0d4fac161ed12926e010dcf8b448a8de6a2ecChris Lattner case OffsetOf: return "__builtin_offsetof"; 995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Postfix Operators. 1045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 106e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman 1075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerCallExpr::CallExpr(Expr *fn, Expr **args, unsigned numargs, QualType t, 1085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation rparenloc) 10977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek : Expr(CallExprClass, t), NumArgs(numargs) { 1105549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[numargs+1]; 11177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[FN] = fn; 1125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != numargs; ++i) 11377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[i+ARGS_START] = args[i]; 1145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RParenLoc = rparenloc; 1155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 117d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// setNumArgs - This changes the number of arguments present in this call. 118d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// Any orphaned expressions are deleted by this, and any new operands are set 119d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// to null. 120d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattnervoid CallExpr::setNumArgs(unsigned NumArgs) { 121d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // No change, just return. 122d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs == getNumArgs()) return; 123d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 124d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // If shrinking # arguments, just delete the extras and forgot them. 125d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs < getNumArgs()) { 126d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 127d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner delete getArg(i); 128d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 129d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner return; 130d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner } 131d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 132d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Otherwise, we are growing the # arguments. New an bigger argument array. 1335549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek Stmt **NewSubExprs = new Stmt*[NumArgs+1]; 134d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Copy over args. 135d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 136d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = SubExprs[i]; 137d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Null out new args. 138d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 139d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = 0; 140d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 141d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner delete[] SubExprs; 142d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner SubExprs = NewSubExprs; 143d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 144d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner} 145d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 146cb888967400a03504c88acedd5248d6778a82f46Chris Lattner/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If 147cb888967400a03504c88acedd5248d6778a82f46Chris Lattner/// not, return 0. 148cb888967400a03504c88acedd5248d6778a82f46Chris Lattnerunsigned CallExpr::isBuiltinCall() const { 149c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // All simple function calls (e.g. func()) are implicitly cast to pointer to 150c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // function. As a result, we try and obtain the DeclRefExpr from the 151c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // ImplicitCastExpr. 152c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 153c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 154cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 155cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 156c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 157c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!DRE) 158cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 159cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 160bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 161bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson if (!FDecl) 162cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 163cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 164cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return FDecl->getIdentifier()->getBuiltinID(); 165cb888967400a03504c88acedd5248d6778a82f46Chris Lattner} 166bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson 167cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 1685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 1695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "<<=". 1705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *BinaryOperator::getOpcodeStr(Opcode Op) { 1715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 1725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown binary operator"); 1735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Mul: return "*"; 1745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Div: return "/"; 1755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Rem: return "%"; 1765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Add: return "+"; 1775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Sub: return "-"; 1785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shl: return "<<"; 1795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shr: return ">>"; 1805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LT: return "<"; 1815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GT: return ">"; 1825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LE: return "<="; 1835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GE: return ">="; 1845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case EQ: return "=="; 1855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case NE: return "!="; 1865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case And: return "&"; 1875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Xor: return "^"; 1885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Or: return "|"; 1895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LAnd: return "&&"; 1905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LOr: return "||"; 1915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Assign: return "="; 1925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MulAssign: return "*="; 1935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DivAssign: return "/="; 1945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case RemAssign: return "%="; 1955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddAssign: return "+="; 1965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SubAssign: return "-="; 1975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShlAssign: return "<<="; 1985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShrAssign: return ">>="; 1995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AndAssign: return "&="; 2005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case XorAssign: return "^="; 2015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case OrAssign: return "|="; 2025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Comma: return ","; 2035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 20666b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonInitListExpr::InitListExpr(SourceLocation lbraceloc, 207418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner Expr **initExprs, unsigned numInits, 208418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner SourceLocation rbraceloc, bool hadDesignators) 209c5ae899b4bbf65488445316c63168079177db0edSteve Naroff : Expr(InitListExprClass, QualType()), 210418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), HadDesignators(hadDesignators) { 211418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner 212418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits); 21366b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 2145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 215bfdcae678d44906293e21c0cddc6537f3ee8b5a4Steve Naroff/// getFunctionType - Return the underlying function type for this block. 2164eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff/// 2174eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroffconst FunctionType *BlockExpr::getFunctionType() const { 2184eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff return getType()->getAsBlockPointerType()-> 2194eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff getPointeeType()->getAsFunctionType(); 2204eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff} 2214eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff 22256ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffSourceLocation BlockExpr::getCaretLocation() const { 22356ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff return TheBlock->getCaretLocation(); 22456ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff} 22556ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroffconst Stmt *BlockExpr::getBody() const { return TheBlock->getBody(); } 22656ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt *BlockExpr::getBody() { return TheBlock->getBody(); } 22756ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff 22856ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff 2295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 2305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Generic Expression Routines 2315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 2325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// hasLocalSideEffect - Return true if this immediate expression has side 2345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// effects, not counting any sub-expressions. 2355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Expr::hasLocalSideEffect() const { 2365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 2375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 2385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 2395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: 2405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return cast<ParenExpr>(this)->getSubExpr()->hasLocalSideEffect(); 2415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperatorClass: { 2425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const UnaryOperator *UO = cast<UnaryOperator>(this); 2435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (UO->getOpcode()) { 2455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: return false; 2465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostInc: 2475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostDec: 2485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PreInc: 2495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PreDec: 2505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; // ++/-- 2515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Deref: 2535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Dereferencing a volatile pointer is a side-effect. 2545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return getType().isVolatileQualified(); 2555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Real: 2565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Imag: 2575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // accessing a piece of a volatile complex is a side-effect. 2585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return UO->getSubExpr()->getType().isVolatileQualified(); 2595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 2615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return UO->getSubExpr()->hasLocalSideEffect(); 2625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 264e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner case BinaryOperatorClass: { 265e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(this); 266e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner // Consider comma to have side effects if the LHS and RHS both do. 267e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner if (BinOp->getOpcode() == BinaryOperator::Comma) 268e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner return BinOp->getLHS()->hasLocalSideEffect() && 269e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner BinOp->getRHS()->hasLocalSideEffect(); 270e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner 271e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner return BinOp->isAssignmentOp(); 272e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner } 273eb14fe839ec24c2ca14e5f094be147a34e3d3339Chris Lattner case CompoundAssignOperatorClass: 2741f683e9cf2e855b32d3fb4b142aa121cd3cf1088Chris Lattner return true; 2755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 276ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian case ConditionalOperatorClass: { 277ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 278ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian return Exp->getCond()->hasLocalSideEffect() 279ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian || (Exp->getLHS() && Exp->getLHS()->hasLocalSideEffect()) 280ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian || (Exp->getRHS() && Exp->getRHS()->hasLocalSideEffect()); 281ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian } 282ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian 2835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MemberExprClass: 2845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: 2855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the base pointer or element is to a volatile pointer/field, accessing 2865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // if is a side effect. 2875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return getType().isVolatileQualified(); 288211f6adf1301a1461015fb6cb08a05f0a35b65f3Eli Friedman 2895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case CallExprClass: 2905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // TODO: check attributes for pure/const. "void foo() { strlen("bar"); }" 2915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // should warn. 2925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 293a9c01021724b9b546d282b8609cbe559734812ecChris Lattner case ObjCMessageExprClass: 294a9c01021724b9b546d282b8609cbe559734812ecChris Lattner return true; 295611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner case StmtExprClass: { 296611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // Statement exprs don't logically have side effects themselves, but are 297611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // sometimes used in macros in ways that give them a type that is unused. 298611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // For example ({ blah; foo(); }) will end up with a type if foo has a type. 299611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // however, if the result of the stmt expr is dead, we don't want to emit a 300611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // warning. 301611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 302611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (!CS->body_empty()) 303611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 304611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner return E->hasLocalSideEffect(); 305611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner return false; 306611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner } 3076eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 308987a14bf5883ef6e5d07f1c83eb6d41a8212a78cArgyrios Kyrtzidis case CXXFunctionalCastExprClass: 3095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is a cast to void, check the operand. Otherwise, the result of 3105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the cast is unused. 3115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (getType()->isVoidType()) 3125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return cast<CastExpr>(this)->getSubExpr()->hasLocalSideEffect(); 3135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 31404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner 3154be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman case ImplicitCastExprClass: 3164be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman // Check the operand, since implicit casts are inserted by Sema 3174be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman return cast<ImplicitCastExpr>(this)->getSubExpr()->hasLocalSideEffect(); 3184be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman 31904421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 32004421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->hasLocalSideEffect(); 3215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 324ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor/// DeclCanBeLvalue - Determine whether the given declaration can be 325ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor/// an lvalue. This is a helper routine for isLvalue. 326ba7e210a999275695f58be03ef402758cfec3635Douglas Gregorstatic bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) { 32790b7bc67518a408d397f2400ff6c40e5465b45e4Argyrios Kyrtzidis return isa<VarDecl>(Decl) || isa<CXXFieldDecl>(Decl) || 328ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor // C++ 3.10p2: An lvalue refers to an object or function. 329ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor (Ctx.getLangOptions().CPlusPlus && 330ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl))); 331ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor} 332ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor 3335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 3345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// incomplete type other than void. Nonarray expressions that can be lvalues: 3355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - name, where name must be a variable 3365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e[i] 3375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - (e), where e must be an lvalue 3385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e.name, where e must be an lvalue 3395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e->name 3405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - *e, the type of e cannot be a function type 3415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - string-constant 3427da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 34308ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling/// - reference type [C++ [expr]] 3445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 34528be73f74c9e241a23ea24fe5756623de6bf1084Chris LattnerExpr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const { 34698cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor // first, check the type (C99 6.3.2.1). Expressions with function 34798cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor // type in C are not lvalues, but they can be lvalues in C++. 34898cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor if (!Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 3495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_NotObjectType; 3505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 351acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff // Allow qualified void which is an incomplete type other than void (yuck). 35228be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers()) 353acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff return LV_IncompleteVoidType; 354acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff 35598cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor /// FIXME: Expressions can't have reference type, so the following 35698cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor /// isn't needed. 357cb4f9a6d0be445d84af35ba81323be6127816f9eChris Lattner if (TR->isReferenceType()) // C++ [expr] 35808ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling return LV_Valid; 35908ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling 3605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the type looks fine, now check the expression 3615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 3625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case StringLiteralClass: // C99 6.5.1p4 3637323a6297edad643c202594dcf3d9a174de96ca6Anders Carlsson return LV_Valid; 3645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 3655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // For vectors, make sure base is an lvalue (i.e. not a function call). 3665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 36728be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx); 3685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 3694111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner case DeclRefExprClass: { // C99 6.5.1p2 370ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl(); 371ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor if (DeclCanBeLvalue(RefdDecl, Ctx)) 3725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 3735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 3744111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner } 375dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff case BlockDeclRefExprClass: { 376dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 3774f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (isa<VarDecl>(BDR->getDecl())) 378dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff return LV_Valid; 379dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff break; 380dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff } 381fdd75663fffeb2058a7847975e50837e61200593Anton Korobeynikov case MemberExprClass: { // C99 6.5.2.3p4 3825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const MemberExpr *m = cast<MemberExpr>(this); 38328be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 384fdd75663fffeb2058a7847975e50837e61200593Anton Korobeynikov } 3857da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner case UnaryOperatorClass: 3865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 3877da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner return LV_Valid; // C99 6.5.3p4 3887da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner 3897da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 390baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag || 391baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension) 39228be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU. 3935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 3945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: // C99 6.5.1p5 39528be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx); 3969d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CallExprClass: { 3979d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.call]p10: 3989d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // A function call is an lvalue if and only if the result type 3999d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // is a reference. 40027c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor QualType CalleeType = cast<CallExpr>(this)->getCallee()->getType(); 4019d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor if (const PointerType *FnTypePtr = CalleeType->getAsPointerType()) 4029d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor if (const FunctionType *FnType 4039d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor = FnTypePtr->getPointeeType()->getAsFunctionType()) 4049d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor if (FnType->getResultType()->isReferenceType()) 4059d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor return LV_Valid; 4069d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor 4079d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor break; 4089d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor } 409e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff case CompoundLiteralExprClass: // C99 6.5.2.5p5 410e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff return LV_Valid; 411213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case ExtVectorElementExprClass: 412213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 413fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_DuplicateVectorComponents; 414fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_Valid; 415027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 416027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff return LV_Valid; 417799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff case ObjCPropertyRefExprClass: // FIXME: check if read-only property. 418799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff return LV_Valid; 419d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 420796da18402f286b897782a298ae3b20c459c102eDouglas Gregor return LV_Valid; 4219d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case VAArgExprClass: 4229d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor return LV_Valid; 42304421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 42428be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx); 42524b41fa8239c63b9eb570d3e83c4a82840656a65Argyrios Kyrtzidis case CXXConditionDeclExprClass: 42624b41fa8239c63b9eb570d3e83c4a82840656a65Argyrios Kyrtzidis return LV_Valid; 4276eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 4289d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXFunctionalCastExprClass: 4299d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXStaticCastExprClass: 4309d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXDynamicCastExprClass: 4319d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXReinterpretCastExprClass: 4329d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXConstCastExprClass: 4339d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // The result of an explicit cast is an lvalue if the type we are 4349d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // casting to is a reference type. See C++ [expr.cast]p1, 4359d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2, 4369d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1. 4379d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()->isReferenceType()) 4389d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor return LV_Valid; 4399d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor break; 440796da18402f286b897782a298ae3b20c459c102eDouglas Gregor case CXXThisExprClass: 441796da18402f286b897782a298ae3b20c459c102eDouglas Gregor return LV_InvalidExpression; 4425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 4435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 4445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_InvalidExpression; 4465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 4495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// does not have an incomplete type, does not have a const-qualified type, and 4505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// if it is a structure or union, does not have any member (including, 4515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// recursively, any member or element of all contained aggregates or unions) 4525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// with a const-qualified type. 45328be73f74c9e241a23ea24fe5756623de6bf1084Chris LattnerExpr::isModifiableLvalueResult Expr::isModifiableLvalue(ASTContext &Ctx) const { 45428be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner isLvalueResult lvalResult = isLvalue(Ctx); 4555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (lvalResult) { 457ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor case LV_Valid: 458ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor // C++ 3.10p11: Functions cannot be modified, but pointers to 459ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor // functions can be modifiable. 460ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 461ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor return MLV_NotObjectType; 462ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor break; 463ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor 4645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_NotObjectType: return MLV_NotObjectType; 4655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 466fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 4675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_InvalidExpression: return MLV_InvalidExpression; 4685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 469c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 470c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType CT = Ctx.getCanonicalType(getType()); 471c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 472c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT.isConstQualified()) 4735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 474c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isArrayType()) 4755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ArrayType; 476c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isIncompleteType()) 4775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_IncompleteType; 4785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 479c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const RecordType *r = CT->getAsRecordType()) { 4805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (r->hasConstFields()) 4815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 4825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4834f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // The following is illegal: 4844f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // void takeclosure(void (^C)(void)); 4854f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // void func() { int x = 1; takeclosure(^{ x = 7 }); } 4864f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // 4874f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (getStmtClass() == BlockDeclRefExprClass) { 4884f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 4894f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl())) 4904f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff return MLV_NotBlockQualified; 4914f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff } 4925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_Valid; 4935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4952e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek/// hasGlobalStorage - Return true if this expression has static storage 4964cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// duration. This means that the address of this expression is a link-time 4974cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// constant. 4982e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenekbool Expr::hasGlobalStorage() const { 4991d09ecca892185ba067e47ba879f424de59950efChris Lattner switch (getStmtClass()) { 5001d09ecca892185ba067e47ba879f424de59950efChris Lattner default: 5011d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 5024cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ParenExprClass: 5032e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage(); 5044cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ImplicitCastExprClass: 5052e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage(); 506e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff case CompoundLiteralExprClass: 507e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff return cast<CompoundLiteralExpr>(this)->isFileScope(); 5081d09ecca892185ba067e47ba879f424de59950efChris Lattner case DeclRefExprClass: { 5091d09ecca892185ba067e47ba879f424de59950efChris Lattner const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 5101d09ecca892185ba067e47ba879f424de59950efChris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 5112e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return VD->hasGlobalStorage(); 51263f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon if (isa<FunctionDecl>(D)) 51363f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon return true; 5141d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 5151d09ecca892185ba067e47ba879f424de59950efChris Lattner } 516fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner case MemberExprClass: { 5171d09ecca892185ba067e47ba879f424de59950efChris Lattner const MemberExpr *M = cast<MemberExpr>(this); 5182e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return !M->isArrow() && M->getBase()->hasGlobalStorage(); 519fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner } 5204cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ArraySubscriptExprClass: 5212e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage(); 522d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 523fa28b30d5a1e93e5263be33e343532b900d2c643Chris Lattner return true; 52404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 52504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage(); 5261d09ecca892185ba067e47ba879f424de59950efChris Lattner } 5271d09ecca892185ba067e47ba879f424de59950efChris Lattner} 5281d09ecca892185ba067e47ba879f424de59950efChris Lattner 5294e99a5fc3b203397a91136c6e695e405fb8fc606Ted KremenekExpr* Expr::IgnoreParens() { 5304e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek Expr* E = this; 5314e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 5324e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek E = P->getSubExpr(); 5334e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 5344e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek return E; 5354e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek} 5364e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 53756f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 53856f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// or CastExprs or ImplicitCastExprs, returning their operand. 53956f349400c5932a196509c0480ff6f99a9a0b48fChris LattnerExpr *Expr::IgnoreParenCasts() { 54056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner Expr *E = this; 54156f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner while (true) { 54256f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 54356f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 54456f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else if (CastExpr *P = dyn_cast<CastExpr>(E)) 54556f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 54656f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else 54756f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner return E; 54856f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner } 54956f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner} 55056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner 55156f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner 55238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroffbool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const { 55338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff switch (getStmtClass()) { 55438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff default: 55538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (Loc) *Loc = getLocStart(); 55638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 55738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case ParenExprClass: 55838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return cast<ParenExpr>(this)->getSubExpr()->isConstantExpr(Ctx, Loc); 55938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case StringLiteralClass: 5605d37e32a5bfefacdd7b4d0664199d72c703d489dSteve Naroff case ObjCStringLiteralClass: 56138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case FloatingLiteralClass: 56238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case IntegerLiteralClass: 56338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case CharacterLiteralClass: 56438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case ImaginaryLiteralClass: 5651a86b33c1870fee08d281c9f07ac1280195a7faeAnders Carlsson case TypesCompatibleExprClass: 5661a86b33c1870fee08d281c9f07ac1280195a7faeAnders Carlsson case CXXBoolLiteralExprClass: 56715425f9d2d92e2a5f99b09b8e2fc00025631e593Anders Carlsson case AddrLabelExprClass: 5682777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 56938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case CallExprClass: { 57038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const CallExpr *CE = cast<CallExpr>(this); 57145b6b9d080ac56917337d73d8f1cd6374b27b05dChris Lattner 57245b6b9d080ac56917337d73d8f1cd6374b27b05dChris Lattner // Allow any constant foldable calls to builtins. 57345b6b9d080ac56917337d73d8f1cd6374b27b05dChris Lattner if (CE->isBuiltinCall() && CE->isEvaluatable(Ctx)) 574c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff return true; 57545b6b9d080ac56917337d73d8f1cd6374b27b05dChris Lattner 57638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (Loc) *Loc = getLocStart(); 57738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 57838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 5794ef8dd6e8736097bf9e3c387139c668565d89dcaChris Lattner case DeclRefExprClass: { 5804ef8dd6e8736097bf9e3c387139c668565d89dcaChris Lattner const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 5814ef8dd6e8736097bf9e3c387139c668565d89dcaChris Lattner // Accept address of function. 5824ef8dd6e8736097bf9e3c387139c668565d89dcaChris Lattner if (isa<EnumConstantDecl>(D) || isa<FunctionDecl>(D)) 5832777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 58438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (Loc) *Loc = getLocStart(); 5851d09ecca892185ba067e47ba879f424de59950efChris Lattner if (isa<VarDecl>(D)) 5861d09ecca892185ba067e47ba879f424de59950efChris Lattner return TR->isArrayType(); 58738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 5884ef8dd6e8736097bf9e3c387139c668565d89dcaChris Lattner } 589b8f13a8baff3df080fe024fec47746e9a79fe649Steve Naroff case CompoundLiteralExprClass: 590b8f13a8baff3df080fe024fec47746e9a79fe649Steve Naroff if (Loc) *Loc = getLocStart(); 591b8f13a8baff3df080fe024fec47746e9a79fe649Steve Naroff // Allow "(int []){2,4}", since the array will be converted to a pointer. 592d47d4f518e43eaa716e2d18359bd725a03b87f58Nate Begeman // Allow "(vector type){2,4}" since the elements are all constant. 593d47d4f518e43eaa716e2d18359bd725a03b87f58Nate Begeman return TR->isArrayType() || TR->isVectorType(); 59438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperatorClass: { 59538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const UnaryOperator *Exp = cast<UnaryOperator>(this); 59638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 5971d09ecca892185ba067e47ba879f424de59950efChris Lattner // C99 6.6p9 598239c15e5b07a6cc84278ede87edf638922767520Chris Lattner if (Exp->getOpcode() == UnaryOperator::AddrOf) { 5992e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek if (!Exp->getSubExpr()->hasGlobalStorage()) { 600239c15e5b07a6cc84278ede87edf638922767520Chris Lattner if (Loc) *Loc = getLocStart(); 601239c15e5b07a6cc84278ede87edf638922767520Chris Lattner return false; 602239c15e5b07a6cc84278ede87edf638922767520Chris Lattner } 603239c15e5b07a6cc84278ede87edf638922767520Chris Lattner return true; 604239c15e5b07a6cc84278ede87edf638922767520Chris Lattner } 6051d09ecca892185ba067e47ba879f424de59950efChris Lattner 60638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // Get the operand value. If this is sizeof/alignof, do not evalute the 60738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // operand. This affects C99 6.6p3. 608d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff if (!Exp->isSizeOfAlignOfOp() && 609d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff Exp->getOpcode() != UnaryOperator::OffsetOf && 61038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff !Exp->getSubExpr()->isConstantExpr(Ctx, Loc)) 61138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 61238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 61338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff switch (Exp->getOpcode()) { 61438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 61538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // See C99 6.6p3. 61638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff default: 61738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (Loc) *Loc = Exp->getOperatorLoc(); 61838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 61938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::Extension: 62038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return true; // FIXME: this is wrong. 62138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::SizeOf: 62238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::AlignOf: 623d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff case UnaryOperator::OffsetOf: 62438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2. 6253c2b3170041f69a92904e3bab9b6d654eaf260acEli Friedman if (!Exp->getSubExpr()->getType()->isConstantSizeType()) { 62665383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner if (Loc) *Loc = Exp->getOperatorLoc(); 62738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 62865383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner } 6292777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 63038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::LNot: 63138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::Plus: 63238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::Minus: 63338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::Not: 6342777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 63538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 63638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 63738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case SizeOfAlignOfTypeExprClass: { 63838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(this); 63938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // alignof always evaluates to a constant. 640a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner if (Exp->isSizeOf() && !Exp->getArgumentType()->isVoidType() && 641a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner !Exp->getArgumentType()->isConstantSizeType()) { 64265383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner if (Loc) *Loc = Exp->getOperatorLoc(); 64338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 64465383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner } 6452777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 64638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 64738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case BinaryOperatorClass: { 64838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const BinaryOperator *Exp = cast<BinaryOperator>(this); 64938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 65038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // The LHS of a constant expr is always evaluated and needed. 65138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (!Exp->getLHS()->isConstantExpr(Ctx, Loc)) 65238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 65338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 65438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (!Exp->getRHS()->isConstantExpr(Ctx, Loc)) 65538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 6562777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 65738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 65838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case ImplicitCastExprClass: 6596eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 660987a14bf5883ef6e5d07f1c83eb6d41a8212a78cArgyrios Kyrtzidis case CXXFunctionalCastExprClass: { 6610835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis const Expr *SubExpr = cast<CastExpr>(this)->getSubExpr(); 6620835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis SourceLocation CastLoc = getLocStart(); 66338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (!SubExpr->isConstantExpr(Ctx, Loc)) { 66438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (Loc) *Loc = SubExpr->getLocStart(); 66538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 66638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 6672777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 66838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 66938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case ConditionalOperatorClass: { 67038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 6712777e494c96bee69141a10a0174d5da16e7b927bChris Lattner if (!Exp->getCond()->isConstantExpr(Ctx, Loc) || 6723907323dd6665c0c4e383435cb145233f4533406Anders Carlsson // Handle the GNU extension for missing LHS. 6733907323dd6665c0c4e383435cb145233f4533406Anders Carlsson !(Exp->getLHS() && Exp->getLHS()->isConstantExpr(Ctx, Loc)) || 6742777e494c96bee69141a10a0174d5da16e7b927bChris Lattner !Exp->getRHS()->isConstantExpr(Ctx, Loc)) 67538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 6762777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 67738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 678d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff case InitListExprClass: { 679d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff const InitListExpr *Exp = cast<InitListExpr>(this); 680d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff unsigned numInits = Exp->getNumInits(); 681d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff for (unsigned i = 0; i < numInits; i++) { 682d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff if (!Exp->getInit(i)->isConstantExpr(Ctx, Loc)) { 683d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff if (Loc) *Loc = Exp->getInit(i)->getLocStart(); 684d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff return false; 685d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff } 686d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff } 687d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff return true; 688d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff } 68904421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 69004421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->isConstantExpr(Ctx, Loc); 69138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 69238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff} 69338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 6945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isIntegerConstantExpr - this recursive routine will test if an expression is 6955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// an integer constant expression. Note: With the introduction of VLA's in 6965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// C99 the result of the sizeof operator is no longer always a constant 6975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// expression. The generalization of the wording to include any subexpression 6985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// that is not evaluated (C99 6.6p3) means that nonconstant subexpressions 6995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// can appear as operands to other operators (e.g. &&, ||, ?:). For instance, 7005f6b632391e24b08ead3e62ba2e2765e770382edNuno Lopes/// "0 || f()" can be treated as a constant expression. In C90 this expression, 7015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// occurring in a context requiring a constant, would have been a constraint 7025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// violation. FIXME: This routine currently implements C90 semantics. 7035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// To properly implement C99 semantics this routine will need to evaluate 7045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// expressions involving operators previously mentioned. 7055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 7075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// comma, etc 7085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 7095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FIXME: This should ext-warn on overflow during evaluation! ISO C does not 710ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner/// permit this. This includes things like (int)1e1000 711ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// 712ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof 713ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer 714ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// cast+dereference. 715590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattnerbool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, 716590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner SourceLocation *Loc, bool isEvaluated) const { 7175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 7185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 7195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 7205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 7215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: 7225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return cast<ParenExpr>(this)->getSubExpr()-> 723590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 7245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case IntegerLiteralClass: 7255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = cast<IntegerLiteral>(this)->getValue(); 7265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 7272eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner case CharacterLiteralClass: { 7282eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner const CharacterLiteral *CL = cast<CharacterLiteral>(this); 72998be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 7302eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner Result = CL->getValue(); 731f0fbcb356bc4eb5f6467dc4fc4bc447e9a630102Chris Lattner Result.setIsUnsigned(!getType()->isSignedIntegerType()); 7325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 7332eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner } 734b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson case CXXBoolLiteralExprClass: { 735b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson const CXXBoolLiteralExpr *BL = cast<CXXBoolLiteralExpr>(this); 736b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 737b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson Result = BL->getValue(); 738b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson Result.setIsUnsigned(!getType()->isSignedIntegerType()); 739b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson break; 740b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson } 7417267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis case CXXZeroInitValueExprClass: 7427267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis Result.clear(); 7437267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis break; 7447b658aa315784fa489a32daeacfe400512ce468dSteve Naroff case TypesCompatibleExprClass: { 7457b658aa315784fa489a32daeacfe400512ce468dSteve Naroff const TypesCompatibleExpr *TCE = cast<TypesCompatibleExpr>(this); 74698be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 747ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar // Per gcc docs "this built-in function ignores top level 748ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar // qualifiers". We need to use the canonical version to properly 749ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar // be able to strip CRV qualifiers from the type. 750ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar QualType T0 = Ctx.getCanonicalType(TCE->getArgType1()); 751ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar QualType T1 = Ctx.getCanonicalType(TCE->getArgType2()); 752ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar Result = Ctx.typesAreCompatible(T0.getUnqualifiedType(), 753ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar T1.getUnqualifiedType()); 754389cecc83f33e93c8ba6bf2e8269b8690404416fSteve Naroff break; 7557b658aa315784fa489a32daeacfe400512ce468dSteve Naroff } 75613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff case CallExprClass: { 75713b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff const CallExpr *CE = cast<CallExpr>(this); 75898be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 759a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner 760a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner // If this is a call to a builtin function, constant fold it otherwise 761a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner // reject it. 762a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner if (CE->isBuiltinCall()) { 763a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner APValue ResultAP; 764a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner if (CE->tryEvaluate(ResultAP, Ctx)) { 765a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner Result = ResultAP.getInt(); 766a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner break; // It is a constant, expand it. 767a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner } 768a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner } 769a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner 77013b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (Loc) *Loc = getLocStart(); 77113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return false; 77213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff } 7735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclRefExprClass: 7745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const EnumConstantDecl *D = 7755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer dyn_cast<EnumConstantDecl>(cast<DeclRefExpr>(this)->getDecl())) { 7765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = D->getInitVal(); 7775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 7785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 7795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 7805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 7815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperatorClass: { 7825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const UnaryOperator *Exp = cast<UnaryOperator>(this); 7835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the operand value. If this is sizeof/alignof, do not evalute the 7855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // operand. This affects C99 6.6p3. 7865a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson if (!Exp->isSizeOfAlignOfOp() && !Exp->isOffsetOfOp() && 787602dafdea34b78c7bc1f4601f94062afa4139e76Chris Lattner !Exp->getSubExpr()->isIntegerConstantExpr(Result, Ctx, Loc,isEvaluated)) 7885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 7895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 7915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 7925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // See C99 6.6p3. 7935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 7945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = Exp->getOperatorLoc(); 7955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 7965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 79776e773a443be9f006610f46529e07d4c8d857680Chris Lattner return true; // FIXME: this is wrong. 7985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::SizeOf: 7995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::AlignOf: 800a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // Return the result in the right width. 80198be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 802a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 803a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // sizeof(void) and __alignof__(void) = 1 as a gcc extension. 804a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner if (Exp->getSubExpr()->getType()->isVoidType()) { 805a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner Result = 1; 806a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner break; 807a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner } 808a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 8095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2. 8103c2b3170041f69a92904e3bab9b6d654eaf260acEli Friedman if (!Exp->getSubExpr()->getType()->isConstantSizeType()) { 81165383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner if (Loc) *Loc = Exp->getOperatorLoc(); 8125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 81365383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner } 8145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 81576e773a443be9f006610f46529e07d4c8d857680Chris Lattner // Get information about the size or align. 816efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner if (Exp->getSubExpr()->getType()->isFunctionType()) { 817efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner // GCC extension: sizeof(function) = 1. 818efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner Result = Exp->getOpcode() == UnaryOperator::AlignOf ? 4 : 1; 819da5a6b6d9fd52899499d5b7b46273ec844dcaa6eChris Lattner } else { 82098be4943e8dc4f3905629a7102668960873cf863Chris Lattner unsigned CharSize = Ctx.Target.getCharWidth(); 82164a31ef8d46fcdf2bca38098e3206a45052b515dAnders Carlsson if (Exp->getOpcode() == UnaryOperator::AlignOf) 82298be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result = Ctx.getTypeAlign(Exp->getSubExpr()->getType()) / CharSize; 82364a31ef8d46fcdf2bca38098e3206a45052b515dAnders Carlsson else 82498be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result = Ctx.getTypeSize(Exp->getSubExpr()->getType()) / CharSize; 825da5a6b6d9fd52899499d5b7b46273ec844dcaa6eChris Lattner } 8265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::LNot: { 828bf7553889594886213e05cd3f94a6d6f7747bf7bChris Lattner bool Val = Result == 0; 82998be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 8305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = Val; 8315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Plus: 8345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Minus: 8365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = -Result; 8375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Not: 8395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = ~Result; 8405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8415a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson case UnaryOperator::OffsetOf: 842aa1f9f1d50adf294674b74510b62e863b68572bcDaniel Dunbar Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 8435a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson Result = Exp->evaluateOffsetOf(Ctx); 8445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SizeOfAlignOfTypeExprClass: { 8485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(this); 849a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 850a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // Return the result in the right width. 85198be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 852a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 853a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // sizeof(void) and __alignof__(void) = 1 as a gcc extension. 854a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner if (Exp->getArgumentType()->isVoidType()) { 855a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner Result = 1; 856a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner break; 857a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner } 858a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 859a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // alignof always evaluates to a constant, sizeof does if arg is not VLA. 8603c2b3170041f69a92904e3bab9b6d654eaf260acEli Friedman if (Exp->isSizeOf() && !Exp->getArgumentType()->isConstantSizeType()) { 86165383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner if (Loc) *Loc = Exp->getOperatorLoc(); 8625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 86365383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner } 8645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 86576e773a443be9f006610f46529e07d4c8d857680Chris Lattner // Get information about the size or align. 866efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner if (Exp->getArgumentType()->isFunctionType()) { 867efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner // GCC extension: sizeof(function) = 1. 868efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner Result = Exp->isSizeOf() ? 1 : 4; 8696a24acbb3dbb3bea9426716bee6ad6023ad15f3fAnders Carlsson } else { 87098be4943e8dc4f3905629a7102668960873cf863Chris Lattner unsigned CharSize = Ctx.Target.getCharWidth(); 8716a24acbb3dbb3bea9426716bee6ad6023ad15f3fAnders Carlsson if (Exp->isSizeOf()) 87298be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result = Ctx.getTypeSize(Exp->getArgumentType()) / CharSize; 8736a24acbb3dbb3bea9426716bee6ad6023ad15f3fAnders Carlsson else 87498be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result = Ctx.getTypeAlign(Exp->getArgumentType()) / CharSize; 875060e470e53b73167114284eb0b8c3e25bb3dad99Ted Kremenek } 8765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperatorClass: { 8795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const BinaryOperator *Exp = cast<BinaryOperator>(this); 880e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar llvm::APSInt LHS, RHS; 881e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar 882e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar // Initialize result to have correct signedness and width. 883e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = llvm::APSInt(static_cast<uint32_t>(Ctx.getTypeSize(getType())), 884e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar !getType()->isSignedIntegerType()); 8855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // The LHS of a constant expr is always evaluated and needed. 887e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar if (!Exp->getLHS()->isIntegerConstantExpr(LHS, Ctx, Loc, isEvaluated)) 8885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 8895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // The short-circuiting &&/|| operators don't necessarily evaluate their 8915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // RHS. Make sure to pass isEvaluated down correctly. 8925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Exp->isLogicalOp()) { 8935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer bool RHSEval; 8945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Exp->getOpcode() == BinaryOperator::LAnd) 895e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar RHSEval = LHS != 0; 8965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else { 8975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(Exp->getOpcode() == BinaryOperator::LOr &&"Unexpected logical"); 898e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar RHSEval = LHS == 0; 8995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 901590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, 9025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer isEvaluated & RHSEval)) 9035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 905590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, isEvaluated)) 9065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 9105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 9115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 9125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Mul: 914e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS * RHS; 9155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Div: 9175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (RHS == 0) { 9185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!isEvaluated) break; 9195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 9205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 922e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS / RHS; 9235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Rem: 9255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (RHS == 0) { 9265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!isEvaluated) break; 9275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 9285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 930e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS % RHS; 9315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 932e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::Add: Result = LHS + RHS; break; 933e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::Sub: Result = LHS - RHS; break; 9345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shl: 935e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS << 936e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1)); 937e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar break; 9385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shr: 939e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS >> 940e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1)); 9415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 942e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::LT: Result = LHS < RHS; break; 943e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::GT: Result = LHS > RHS; break; 944e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::LE: Result = LHS <= RHS; break; 945e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::GE: Result = LHS >= RHS; break; 946e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::EQ: Result = LHS == RHS; break; 947e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::NE: Result = LHS != RHS; break; 948e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::And: Result = LHS & RHS; break; 949e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::Xor: Result = LHS ^ RHS; break; 950e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::Or: Result = LHS | RHS; break; 9515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::LAnd: 952e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS != 0 && RHS != 0; 9535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::LOr: 955e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS != 0 || RHS != 0; 9565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Comma: 9595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.6p3: "shall not contain assignment, ..., or comma operators, 9605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // *except* when they are contained within a subexpression that is not 9615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // evaluated". Note that Assignment can never happen due to constraints 9625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // on the LHS subexpr, so we don't need to check it here. 9635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (isEvaluated) { 9645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 9655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // The result of the constant expr is the RHS. 9695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = RHS; 9705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 9715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(!Exp->isAssignmentOp() && "LHS can't be a constant expr!"); 9745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 97626dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner case ImplicitCastExprClass: 9776eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 978987a14bf5883ef6e5d07f1c83eb6d41a8212a78cArgyrios Kyrtzidis case CXXFunctionalCastExprClass: { 9790835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis const Expr *SubExpr = cast<CastExpr>(this)->getSubExpr(); 9800835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis SourceLocation CastLoc = getLocStart(); 98126dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner 9825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.6p6: shall only convert arithmetic types to integer types. 98326dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (!SubExpr->getType()->isArithmeticType() || 98426dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner !getType()->isIntegerType()) { 98526dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (Loc) *Loc = SubExpr->getLocStart(); 9865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 988987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner 98998be4943e8dc4f3905629a7102668960873cf863Chris Lattner uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType())); 990987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner 9915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Handle simple integer->integer casts. 99226dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (SubExpr->getType()->isIntegerType()) { 99326dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (!SubExpr->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 9945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 99526dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner 99626dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner // Figure out if this is a truncate, extend or noop cast. 99726dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner // If the input is signed, do a sign extend, noop, or truncate. 998c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner if (getType()->isBooleanType()) { 999c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner // Conversion to bool compares against zero. 1000c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner Result = Result != 0; 1001c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner Result.zextOrTrunc(DestWidth); 1002c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner } else if (SubExpr->getType()->isSignedIntegerType()) 100326dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner Result.sextOrTrunc(DestWidth); 100426dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner else // If the input is unsigned, do a zero extend, noop, or truncate. 100526dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner Result.zextOrTrunc(DestWidth); 10065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 10075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Allow floating constants that are the immediate operands of casts or that 10105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // are parenthesized. 101126dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner const Expr *Operand = SubExpr; 10125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer while (const ParenExpr *PE = dyn_cast<ParenExpr>(Operand)) 10135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Operand = PE->getSubExpr(); 1014987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner 1015987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner // If this isn't a floating literal, we can't handle it. 1016987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(Operand); 1017987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner if (!FL) { 1018987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner if (Loc) *Loc = Operand->getLocStart(); 1019987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner return false; 1020987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner } 1021c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner 1022c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner // If the destination is boolean, compare against zero. 1023c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner if (getType()->isBooleanType()) { 1024c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner Result = !FL->getValue().isZero(); 1025c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner Result.zextOrTrunc(DestWidth); 1026c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner break; 1027c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner } 10285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1029987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner // Determine whether we are converting to unsigned or signed. 1030987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner bool DestSigned = getType()->isSignedIntegerType(); 1031ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner 1032ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner // TODO: Warn on overflow, but probably not here: isIntegerConstantExpr can 1033ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner // be called multiple times per AST. 1034ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen uint64_t Space[4]; 1035ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen bool ignored; 1036ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner (void)FL->getValue().convertToInteger(Space, DestWidth, DestSigned, 1037ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen llvm::APFloat::rmTowardZero, 1038ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen &ignored); 1039987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner Result = llvm::APInt(DestWidth, 4, Space); 1040987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner break; 10415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ConditionalOperatorClass: { 10435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 10445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1045590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner if (!Exp->getCond()->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 10465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const Expr *TrueExp = Exp->getLHS(); 10495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const Expr *FalseExp = Exp->getRHS(); 10505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Result == 0) std::swap(TrueExp, FalseExp); 10515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Evaluate the false one first, discard the result. 10533907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (FalseExp && !FalseExp->isIntegerConstantExpr(Result, Ctx, Loc, false)) 10545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Evalute the true one, capture the result. 10563907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (TrueExp && 10573907323dd6665c0c4e383435cb145233f4533406Anders Carlsson !TrueExp->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 10585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 10605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 106104421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 106204421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this) 106304421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner ->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 10645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Cases that are valid constant exprs fall through to here. 10675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result.setIsUnsigned(getType()->isUnsignedIntegerType()); 10685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 10695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 10705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an 10725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// integer constant expression with the value zero, or if this is one that is 10735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// cast to void*. 1074590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattnerbool Expr::isNullPointerConstant(ASTContext &Ctx) const { 10750777972d38a3125efed962b045704c30ae6965cfSebastian Redl // Strip off a cast to void*, if it exists. Except in C++. 10760835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 10776215dee86c0e715b9f2b0d401ab2a5fcf629f1afSebastian Redl if (!Ctx.getLangOptions().CPlusPlus) { 10780777972d38a3125efed962b045704c30ae6965cfSebastian Redl // Check that it is a cast to void*. 10790777972d38a3125efed962b045704c30ae6965cfSebastian Redl if (const PointerType *PT = CE->getType()->getAsPointerType()) { 10800777972d38a3125efed962b045704c30ae6965cfSebastian Redl QualType Pointee = PT->getPointeeType(); 10810777972d38a3125efed962b045704c30ae6965cfSebastian Redl if (Pointee.getCVRQualifiers() == 0 && 10820777972d38a3125efed962b045704c30ae6965cfSebastian Redl Pointee->isVoidType() && // to void* 10830777972d38a3125efed962b045704c30ae6965cfSebastian Redl CE->getSubExpr()->getType()->isIntegerType()) // from int. 10840777972d38a3125efed962b045704c30ae6965cfSebastian Redl return CE->getSubExpr()->isNullPointerConstant(Ctx); 10850777972d38a3125efed962b045704c30ae6965cfSebastian Redl } 10865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1087aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1088aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Ignore the ImplicitCastExpr type entirely. 1089aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return ICE->getSubExpr()->isNullPointerConstant(Ctx); 1090aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1091aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Accept ((void*)0) as a null pointer constant, as many other 1092aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // implementations do. 1093aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return PE->getSubExpr()->isNullPointerConstant(Ctx); 10948123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner } else if (const CXXDefaultArgExpr *DefaultArg 10958123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner = dyn_cast<CXXDefaultArgExpr>(this)) { 109604421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner // See through default argument expressions 109704421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return DefaultArg->getExpr()->isNullPointerConstant(Ctx); 1098aaffbf7c790a324ed114184db771aae2d2e9151cSteve Naroff } 1099aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff 1100aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // This expression must be an integer type. 1101aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff if (!getType()->isIntegerType()) 1102aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return false; 1103aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff 11045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If we have an integer constant expression, we need to *evaluate* it and 11055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // test for the value 0. 11065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::APSInt Val(32); 1107aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return isIntegerConstantExpr(Val, Ctx, 0, true) && Val == 0; 11085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 110931a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff 111027c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor/// isBitField - Return true if this expression is a bit-field. 111127c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregorbool Expr::isBitField() { 111227c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor Expr *E = this->IgnoreParenCasts(); 111327c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 111427c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor return MemRef->getMemberDecl()->isBitField(); 111527c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor return false; 111627c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor} 111727c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor 1118213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanunsigned ExtVectorElementExpr::getNumElements() const { 11198a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (const VectorType *VT = getType()->getAsVectorType()) 11208a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return VT->getNumElements(); 11218a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return 1; 11224d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner} 11234d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner 11248a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// containsDuplicateElements - Return true if any element access is repeated. 1125213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanbool ExtVectorElementExpr::containsDuplicateElements() const { 1126fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *compStr = Accessor.getName(); 1127fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff unsigned length = strlen(compStr); 1128fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff 1129fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff for (unsigned i = 0; i < length-1; i++) { 1130fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *s = compStr+i; 1131fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff for (const char c = *s++; *s; s++) 1132fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff if (c == *s) 1133fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return true; 1134fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff } 1135fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return false; 1136fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff} 1137b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 11388a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 11393b8d116703db8018f855cbb4733ace426422623bNate Begemanvoid ExtVectorElementExpr::getEncodedElementAccess( 11403b8d116703db8018f855cbb4733ace426422623bNate Begeman llvm::SmallVectorImpl<unsigned> &Elts) const { 1141b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner const char *compStr = Accessor.getName(); 11428a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 11438a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman bool isHi = !strcmp(compStr, "hi"); 11448a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman bool isLo = !strcmp(compStr, "lo"); 11458a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman bool isEven = !strcmp(compStr, "e"); 11468a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman bool isOdd = !strcmp(compStr, "o"); 11478a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 11488a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 11498a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman uint64_t Index; 11508a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 11518a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (isHi) 11528a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = e + i; 11538a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isLo) 11548a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = i; 11558a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isEven) 11568a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i; 11578a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isOdd) 11588a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i + 1; 11598a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else 11608a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = ExtVectorType::getAccessorIdx(compStr[i]); 1161b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 11623b8d116703db8018f855cbb4733ace426422623bNate Begeman Elts.push_back(Index); 1163b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner } 11648a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman} 11658a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 116668d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for instance messages. 1167bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1168a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1169db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 117049f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1171db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1172ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 117349f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 11745549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 117568d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[RECEIVER] = receiver; 117649f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 117749f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 117868d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 117968d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1180563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1181563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1182563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1183563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 118468d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for class messages. 118568d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// FIXME: clsName should be typed to ObjCInterfaceType 1186bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1187a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1188db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 118949f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1190db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1191ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 119249f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 11935549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 11944df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown); 119549f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 119649f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 119768d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 119868d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1199563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1200563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1201563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1202563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 12034df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek// constructor for class messages. 12044df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo, 12054df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek QualType retType, ObjCMethodDecl *mproto, 12064df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SourceLocation LBrac, SourceLocation RBrac, 12074df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek Expr **ArgExprs, unsigned nargs) 12084df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek: Expr(ObjCMessageExprClass, retType), SelName(selInfo), 12094df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekMethodProto(mproto) { 12104df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek NumArgs = nargs; 12114df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 12124df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown); 12134df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek if (NumArgs) { 12144df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek for (unsigned i = 0; i != NumArgs; ++i) 12154df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 12164df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 12174df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek LBracloc = LBrac; 12184df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek RBracloc = RBrac; 12194df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 12204df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 12214df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const { 12224df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek uintptr_t x = (uintptr_t) SubExprs[RECEIVER]; 12234df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek switch (x & Flags) { 12244df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek default: 12254df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek assert(false && "Invalid ObjCMessageExpr."); 12264df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsInstMeth: 12274df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, 0); 12284df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclUnknown: 12294df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, (IdentifierInfo*) (x & ~Flags)); 12304df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclKnown: { 12314df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags); 12324df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(D, D->getIdentifier()); 12334df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 12344df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 12354df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 12364df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 123727437caadea35f84d550cd29f024fcf3ea240eecChris Lattnerbool ChooseExpr::isConditionTrue(ASTContext &C) const { 123832442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar return getCond()->getIntegerConstantExprValue(C) != 0; 123927437caadea35f84d550cd29f024fcf3ea240eecChris Lattner} 124027437caadea35f84d550cd29f024fcf3ea240eecChris Lattner 12415a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlssonstatic int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) 12425a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson{ 12435a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 12445a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson QualType Ty = ME->getBase()->getType(); 12455a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12465a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson RecordDecl *RD = Ty->getAsRecordType()->getDecl(); 124798be4943e8dc4f3905629a7102668960873cf863Chris Lattner const ASTRecordLayout &RL = C.getASTRecordLayout(RD); 12485a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson FieldDecl *FD = ME->getMemberDecl(); 12495a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12505a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson // FIXME: This is linear time. 12515a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson unsigned i = 0, e = 0; 12525a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson for (i = 0, e = RD->getNumMembers(); i != e; i++) { 12535a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson if (RD->getMember(i) == FD) 12545a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson break; 12555a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } 12565a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12575a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase()); 12585a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) { 12595a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson const Expr *Base = ASE->getBase(); 12605a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 126198be4943e8dc4f3905629a7102668960873cf863Chris Lattner int64_t size = C.getTypeSize(ASE->getType()); 126232442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar size *= ASE->getIdx()->getIntegerConstantExprValue(C).getSExtValue(); 12635a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12645a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return size + evaluateOffsetOf(C, Base); 12655a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } else if (isa<CompoundLiteralExpr>(E)) 12665a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return 0; 12675a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12685a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson assert(0 && "Unknown offsetof subexpression!"); 12695a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return 0; 12705a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 12715a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12725a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlssonint64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const 12735a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson{ 12745a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson assert(Opc == OffsetOf && "Unary operator not offsetof!"); 12755a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 127698be4943e8dc4f3905629a7102668960873cf863Chris Lattner unsigned CharSize = C.Target.getCharWidth(); 12775549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize; 12785a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 12795a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12809048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbarvoid SizeOfAlignOfTypeExpr::Destroy(ASTContext& C) { 12819048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar // Override default behavior of traversing children. We do not want 12829048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar // to delete the type. 12839048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar} 12849048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar 128577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 1286ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek// ExprIterator. 1287ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek//===----------------------------------------------------------------------===// 1288ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek 1289ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 1290ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator*() const { return cast<Expr>(*I); } 1291ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator->() const { return cast<Expr>(*I); } 1292ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator[](size_t idx) const { 1293ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek return cast<Expr>(I[idx]); 1294ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek} 1295ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 1296ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 1297ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek 1298ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek//===----------------------------------------------------------------------===// 129977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// Child Iterators for iterating over subexpressions/substatements 130077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 130177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 130277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// DeclRefExpr 13039ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 13049ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 130577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 13067779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff// ObjCIvarRefExpr 13075549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; } 13085549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; } 13097779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff 1310e3e9add4fd788927df6f545570e7838db59c01d7Steve Naroff// ObjCPropertyRefExpr 13115549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; } 13125549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; } 1313ae7840776d6cd31b4d7a4a345b61bcbb3744df6cSteve Naroff 1314cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas Gregor// ObjCSuperExpr 1315cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas GregorStmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); } 1316cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas GregorStmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); } 1317cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas Gregor 1318d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner// PredefinedExpr 1319d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); } 1320d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); } 132177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 132277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// IntegerLiteral 13239ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 13249ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 132577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 132677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CharacterLiteral 13279ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator CharacterLiteral::child_begin() { return child_iterator(); } 13289ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 132977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 133077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// FloatingLiteral 13319ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 13329ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 133377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 13345d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner// ImaginaryLiteral 13355549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; } 13365549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; } 13375d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner 133877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// StringLiteral 13399ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 13409ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 134177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 134277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ParenExpr 13435549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_begin() { return &Val; } 13445549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_end() { return &Val+1; } 134577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 134677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// UnaryOperator 13475549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_begin() { return &Val; } 13485549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_end() { return &Val+1; } 134977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 135077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// SizeOfAlignOfTypeExpr 13519ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator SizeOfAlignOfTypeExpr::child_begin() { 1352699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek // If the type is a VLA type (and not a typedef), the size expression of the 1353699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek // VLA needs to be treated as an executable expression. 1354699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek if (VariableArrayType* T = dyn_cast<VariableArrayType>(Ty.getTypePtr())) 1355699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek return child_iterator(T); 1356699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek else 13578a213de1a86e5f347c6b591f52712c2fd6177cceTed Kremenek return child_iterator(); 13589ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 13599ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator SizeOfAlignOfTypeExpr::child_end() { 13608a213de1a86e5f347c6b591f52712c2fd6177cceTed Kremenek return child_iterator(); 13619ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 136277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 136377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ArraySubscriptExpr 13641237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_begin() { 13655549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 136677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 13671237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_end() { 13685549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 136977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 137077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 137177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CallExpr 13721237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_begin() { 13735549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 137477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 13751237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_end() { 13765549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumArgs+ARGS_START; 137777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 13781237c673c07f9d827129ba02720108816abde562Ted Kremenek 13791237c673c07f9d827129ba02720108816abde562Ted Kremenek// MemberExpr 13805549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_begin() { return &Base; } 13815549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_end() { return &Base+1; } 13821237c673c07f9d827129ba02720108816abde562Ted Kremenek 1383213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman// ExtVectorElementExpr 13845549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; } 13855549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; } 13861237c673c07f9d827129ba02720108816abde562Ted Kremenek 13871237c673c07f9d827129ba02720108816abde562Ted Kremenek// CompoundLiteralExpr 13885549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; } 13895549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; } 13901237c673c07f9d827129ba02720108816abde562Ted Kremenek 13911237c673c07f9d827129ba02720108816abde562Ted Kremenek// CastExpr 13925549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_begin() { return &Op; } 13935549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_end() { return &Op+1; } 13941237c673c07f9d827129ba02720108816abde562Ted Kremenek 13951237c673c07f9d827129ba02720108816abde562Ted Kremenek// BinaryOperator 13961237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_begin() { 13975549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 13981237c673c07f9d827129ba02720108816abde562Ted Kremenek} 13991237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_end() { 14005549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 14011237c673c07f9d827129ba02720108816abde562Ted Kremenek} 14021237c673c07f9d827129ba02720108816abde562Ted Kremenek 14031237c673c07f9d827129ba02720108816abde562Ted Kremenek// ConditionalOperator 14041237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_begin() { 14055549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 14061237c673c07f9d827129ba02720108816abde562Ted Kremenek} 14071237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_end() { 14085549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 14091237c673c07f9d827129ba02720108816abde562Ted Kremenek} 14101237c673c07f9d827129ba02720108816abde562Ted Kremenek 14111237c673c07f9d827129ba02720108816abde562Ted Kremenek// AddrLabelExpr 14129ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 14139ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 14141237c673c07f9d827129ba02720108816abde562Ted Kremenek 14151237c673c07f9d827129ba02720108816abde562Ted Kremenek// StmtExpr 14165549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_begin() { return &SubStmt; } 14175549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; } 14181237c673c07f9d827129ba02720108816abde562Ted Kremenek 14191237c673c07f9d827129ba02720108816abde562Ted Kremenek// TypesCompatibleExpr 14209ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_begin() { 14219ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14229ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 14239ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek 14249ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_end() { 14259ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14269ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 14271237c673c07f9d827129ba02720108816abde562Ted Kremenek 14281237c673c07f9d827129ba02720108816abde562Ted Kremenek// ChooseExpr 14295549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; } 14305549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; } 14311237c673c07f9d827129ba02720108816abde562Ted Kremenek 1432e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman// OverloadExpr 14335549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator OverloadExpr::child_begin() { return &SubExprs[0]; } 14345549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator OverloadExpr::child_end() { return &SubExprs[0]+NumExprs; } 1435e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman 1436d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman// ShuffleVectorExpr 1437d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_begin() { 14385549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 1439d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1440d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_end() { 14415549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumExprs; 1442d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1443d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 14447c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson// VAArgExpr 14455549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_begin() { return &Val; } 14465549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_end() { return &Val+1; } 14477c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 144866b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson// InitListExpr 144966b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_begin() { 14505549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] : 0; 145166b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 145266b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_end() { 14535549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0; 145466b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 145566b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson 14561237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCStringLiteral 14579ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_begin() { 14589ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14599ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 14609ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_end() { 14619ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14629ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 14631237c673c07f9d827129ba02720108816abde562Ted Kremenek 14641237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCEncodeExpr 14659ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 14669ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 14671237c673c07f9d827129ba02720108816abde562Ted Kremenek 1468b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian// ObjCSelectorExpr 14699ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_begin() { 14709ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14719ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 14729ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_end() { 14739ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14749ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1475b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 1476390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian// ObjCProtocolExpr 14779ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_begin() { 14789ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14799ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 14809ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_end() { 14819ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14829ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1483390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian 1484563477da25f824e37c535131695dc4dc9b68c465Steve Naroff// ObjCMessageExpr 1485ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted KremenekStmt::child_iterator ObjCMessageExpr::child_begin() { 14865549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START; 1487563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1488563477da25f824e37c535131695dc4dc9b68c465Steve NaroffStmt::child_iterator ObjCMessageExpr::child_end() { 14895549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+ARGS_START+getNumArgs(); 1490563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1491563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 14924eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff// Blocks 149356ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt::child_iterator BlockExpr::child_begin() { return child_iterator(); } 149456ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt::child_iterator BlockExpr::child_end() { return child_iterator(); } 14954eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff 14969da13f9ddb2567e36f4bbee7b3c32f54aeb76d5bTed KremenekStmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();} 14979da13f9ddb2567e36f4bbee7b3c32f54aeb76d5bTed KremenekStmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); } 1498