Expr.cpp revision a135975d4257ccc83f13b607b29d882bb00c80b6
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" 19aaba5e346dffdbad5d1c42765a89e4a7afb0da67Douglas Gregor#include "clang/AST/DeclTemplate.h" 20e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar#include "clang/AST/RecordLayout.h" 215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/StmtVisitor.h" 22da5a6b6d9fd52899499d5b7b46273ec844dcaa6eChris Lattner#include "clang/Basic/TargetInfo.h" 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Primary Expressions. 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 29da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// getValueAsApproximateDouble - This returns the value as an inaccurate 30da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// double. Note that this may cause loss of precision, but is useful for 31da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// debugging dumps, etc. 32da8249e57f3badecf925571881fe57243935c6c1Chris Lattnerdouble FloatingLiteral::getValueAsApproximateDouble() const { 33da8249e57f3badecf925571881fe57243935c6c1Chris Lattner llvm::APFloat V = getValue(); 34ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen bool ignored; 35ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 36ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen &ignored); 37da8249e57f3badecf925571881fe57243935c6c1Chris Lattner return V.convertToDouble(); 38da8249e57f3badecf925571881fe57243935c6c1Chris Lattner} 39da8249e57f3badecf925571881fe57243935c6c1Chris Lattner 40da8249e57f3badecf925571881fe57243935c6c1Chris Lattner 416e94ef5696cfb005d3fc7bbac8dcf7690b64f0a5Ted KremenekStringLiteral::StringLiteral(ASTContext& C, const char *strData, 426e94ef5696cfb005d3fc7bbac8dcf7690b64f0a5Ted Kremenek unsigned byteLength, bool Wide, QualType t, 436e94ef5696cfb005d3fc7bbac8dcf7690b64f0a5Ted Kremenek SourceLocation firstLoc, 445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation lastLoc) : 455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Expr(StringLiteralClass, t) { 465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // OPTIMIZE: could allocate this appended to the StringLiteral. 476e94ef5696cfb005d3fc7bbac8dcf7690b64f0a5Ted Kremenek char *AStrData = new (C, 1) char[byteLength]; 485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer memcpy(AStrData, strData, byteLength); 495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer StrData = AStrData; 505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ByteLength = byteLength; 515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer IsWide = Wide; 525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer firstTokLoc = firstLoc; 535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer lastTokLoc = lastLoc; 545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 566e94ef5696cfb005d3fc7bbac8dcf7690b64f0a5Ted Kremenekvoid StringLiteral::Destroy(ASTContext &C) { 578189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek C.Deallocate(const_cast<char*>(StrData)); 58353ffceafc6bcebd5592cb9d93ea3f9242e5370aTed Kremenek this->~StringLiteral(); 59353ffceafc6bcebd5592cb9d93ea3f9242e5370aTed Kremenek C.Deallocate(this); 605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool UnaryOperator::isPostfix(Opcode Op) { 635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostInc: 655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostDec: 665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 725a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenekbool UnaryOperator::isPrefix(Opcode Op) { 735a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek switch (Op) { 745a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek case PreInc: 755a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek case PreDec: 765a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek return true; 775a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek default: 785a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek return false; 795a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek } 805a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek} 815a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek 825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "sizeof" or "[pre]++". 845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *UnaryOperator::getOpcodeStr(Opcode Op) { 855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown unary operator"); 875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostInc: return "++"; 885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostDec: return "--"; 895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreInc: return "++"; 905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreDec: return "--"; 915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddrOf: return "&"; 925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Deref: return "*"; 935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Plus: return "+"; 945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Minus: return "-"; 955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Not: return "~"; 965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LNot: return "!"; 975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Real: return "__real"; 985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Imag: return "__imag"; 995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Extension: return "__extension__"; 10073d0d4fac161ed12926e010dcf8b448a8de6a2ecChris Lattner case OffsetOf: return "__builtin_offsetof"; 1015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Postfix Operators. 1065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 108668bf91d31265b6ea8c3eb854ba450857701f269Ted KremenekCallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args, 1098189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek unsigned numargs, QualType t, SourceLocation rparenloc) 110898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor : Expr(SC, t, 111898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 112d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 113898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor NumArgs(numargs) { 114668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 115668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek SubExprs = new (C) Stmt*[numargs+1]; 116b4609806e9232593ece09ce08b630836e825865cDouglas Gregor SubExprs[FN] = fn; 117b4609806e9232593ece09ce08b630836e825865cDouglas Gregor for (unsigned i = 0; i != numargs; ++i) 118b4609806e9232593ece09ce08b630836e825865cDouglas Gregor SubExprs[i+ARGS_START] = args[i]; 119668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 120b4609806e9232593ece09ce08b630836e825865cDouglas Gregor RParenLoc = rparenloc; 121b4609806e9232593ece09ce08b630836e825865cDouglas Gregor} 122e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman 123668bf91d31265b6ea8c3eb854ba450857701f269Ted KremenekCallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs, 124668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek QualType t, SourceLocation rparenloc) 125898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor : Expr(CallExprClass, t, 126898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 127d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 128898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor NumArgs(numargs) { 129668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 130668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek SubExprs = new (C) Stmt*[numargs+1]; 13177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[FN] = fn; 1325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != numargs; ++i) 13377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[i+ARGS_START] = args[i]; 134668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 1355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RParenLoc = rparenloc; 1365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 138668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenekvoid CallExpr::Destroy(ASTContext& C) { 139668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek DestroyChildren(C); 140668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek if (SubExprs) C.Deallocate(SubExprs); 141668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek this->~CallExpr(); 142668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek C.Deallocate(this); 143668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek} 144668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 145d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// setNumArgs - This changes the number of arguments present in this call. 146d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// Any orphaned expressions are deleted by this, and any new operands are set 147d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// to null. 1488189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenekvoid CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) { 149d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // No change, just return. 150d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs == getNumArgs()) return; 151d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 152d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // If shrinking # arguments, just delete the extras and forgot them. 153d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs < getNumArgs()) { 154d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 1558189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek getArg(i)->Destroy(C); 156d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 157d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner return; 158d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner } 159d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 160d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Otherwise, we are growing the # arguments. New an bigger argument array. 1615549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek Stmt **NewSubExprs = new Stmt*[NumArgs+1]; 162d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Copy over args. 163d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 164d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = SubExprs[i]; 165d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Null out new args. 166d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 167d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = 0; 168d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 1698189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek delete [] SubExprs; 170d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner SubExprs = NewSubExprs; 171d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 172d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner} 173d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 174cb888967400a03504c88acedd5248d6778a82f46Chris Lattner/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If 175cb888967400a03504c88acedd5248d6778a82f46Chris Lattner/// not, return 0. 1763c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregorunsigned CallExpr::isBuiltinCall(ASTContext &Context) const { 177c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // All simple function calls (e.g. func()) are implicitly cast to pointer to 178c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // function. As a result, we try and obtain the DeclRefExpr from the 179c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // ImplicitCastExpr. 180c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 181c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 182cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 183cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 184c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 185c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!DRE) 186cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 187cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 188bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 189bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson if (!FDecl) 190cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 191cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 1924fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor if (!FDecl->getIdentifier()) 1934fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor return 0; 1944fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor 1953c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor return FDecl->getBuiltinID(Context); 196cb888967400a03504c88acedd5248d6778a82f46Chris Lattner} 197bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson 198cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 1995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 2005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "<<=". 2015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *BinaryOperator::getOpcodeStr(Opcode Op) { 2025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 2035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown binary operator"); 2045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Mul: return "*"; 2055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Div: return "/"; 2065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Rem: return "%"; 2075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Add: return "+"; 2085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Sub: return "-"; 2095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shl: return "<<"; 2105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shr: return ">>"; 2115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LT: return "<"; 2125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GT: return ">"; 2135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LE: return "<="; 2145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GE: return ">="; 2155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case EQ: return "=="; 2165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case NE: return "!="; 2175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case And: return "&"; 2185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Xor: return "^"; 2195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Or: return "|"; 2205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LAnd: return "&&"; 2215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LOr: return "||"; 2225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Assign: return "="; 2235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MulAssign: return "*="; 2245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DivAssign: return "/="; 2255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case RemAssign: return "%="; 2265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddAssign: return "+="; 2275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SubAssign: return "-="; 2285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShlAssign: return "<<="; 2295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShrAssign: return ">>="; 2305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AndAssign: return "&="; 2315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case XorAssign: return "^="; 2325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case OrAssign: return "|="; 2335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Comma: return ","; 2345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 23766b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonInitListExpr::InitListExpr(SourceLocation lbraceloc, 238418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner Expr **initExprs, unsigned numInits, 2394c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor SourceLocation rbraceloc) 240c5ae899b4bbf65488445316c63168079177db0edSteve Naroff : Expr(InitListExprClass, QualType()), 2410bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0), 242a9c878086036de36482cc21e35a33cabe9699b0aDouglas Gregor UnionFieldInit(0), HadArrayRangeDesignator(false) { 243418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner 244418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits); 24566b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 2465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2474c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregorvoid InitListExpr::resizeInits(ASTContext &Context, unsigned NumInits) { 248d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner for (unsigned Idx = NumInits, LastIdx = InitExprs.size(); 249f592c929bd1f083abcc8199b24bb825fdd28df1cDaniel Dunbar Idx < LastIdx; ++Idx) 2504c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor delete InitExprs[Idx]; 2514c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.resize(NumInits, 0); 2524c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor} 2534c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 2544c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas GregorExpr *InitListExpr::updateInit(unsigned Init, Expr *expr) { 2554c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor if (Init >= InitExprs.size()) { 2564c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.insert(InitExprs.end(), Init - InitExprs.size() + 1, 0); 2574c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.back() = expr; 2584c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor return 0; 2594c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor } 2604c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 2614c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor Expr *Result = cast_or_null<Expr>(InitExprs[Init]); 2624c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs[Init] = expr; 2634c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor return Result; 2644c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor} 2654c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 266bfdcae678d44906293e21c0cddc6537f3ee8b5a4Steve Naroff/// getFunctionType - Return the underlying function type for this block. 2674eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff/// 2684eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroffconst FunctionType *BlockExpr::getFunctionType() const { 2694eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff return getType()->getAsBlockPointerType()-> 2704eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff getPointeeType()->getAsFunctionType(); 2714eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff} 2724eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff 27356ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffSourceLocation BlockExpr::getCaretLocation() const { 27456ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff return TheBlock->getCaretLocation(); 27556ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff} 27656ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroffconst Stmt *BlockExpr::getBody() const { return TheBlock->getBody(); } 27756ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt *BlockExpr::getBody() { return TheBlock->getBody(); } 27856ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff 27956ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff 2805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 2815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Generic Expression Routines 2825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 2835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 284026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// isUnusedResultAWarning - Return true if this immediate expression should 285026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// be warned about if the result is unused. If so, fill in Loc and Ranges 286026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// with location to warn on and the source range[s] to report with the 287026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// warning. 288026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattnerbool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1, 289026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner SourceRange &R2) const { 2905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 2915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 292026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = getExprLoc(); 293026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = getSourceRange(); 294026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 2955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: 296026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<ParenExpr>(this)->getSubExpr()-> 297026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner isUnusedResultAWarning(Loc, R1, R2); 2985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperatorClass: { 2995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const UnaryOperator *UO = cast<UnaryOperator>(this); 3005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (UO->getOpcode()) { 302026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner default: break; 3035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostInc: 3045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostDec: 3055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PreInc: 306026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner case UnaryOperator::PreDec: // ++/-- 307026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; // Not a warning. 3085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Deref: 3095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Dereferencing a volatile pointer is a side-effect. 310026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 311026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 312026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner break; 3135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Real: 3145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Imag: 3155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // accessing a piece of a volatile complex is a side-effect. 316026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (UO->getSubExpr()->getType().isVolatileQualified()) 317026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 318026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner break; 3195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 320026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 3215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 322026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = UO->getOperatorLoc(); 323026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = UO->getSubExpr()->getSourceRange(); 324026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 3255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 326e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner case BinaryOperatorClass: { 327026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const BinaryOperator *BO = cast<BinaryOperator>(this); 328026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // Consider comma to have side effects if the LHS or RHS does. 329026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (BO->getOpcode() == BinaryOperator::Comma) 330026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2) || 331026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2); 332e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner 333026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (BO->isAssignmentOp()) 334026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 335026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = BO->getOperatorLoc(); 336026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = BO->getLHS()->getSourceRange(); 337026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = BO->getRHS()->getSourceRange(); 338026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 339e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner } 340eb14fe839ec24c2ca14e5f094be147a34e3d3339Chris Lattner case CompoundAssignOperatorClass: 341026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 3425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 343ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian case ConditionalOperatorClass: { 344026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // The condition must be evaluated, but if either the LHS or RHS is a 345026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // warning, warn about them. 346ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 347026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2)) 348026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 349026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2); 350ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian } 351ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian 3525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MemberExprClass: 353026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If the base pointer or element is to a volatile pointer/field, accessing 354026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // it is a side effect. 355026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 356026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 357026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<MemberExpr>(this)->getMemberLoc(); 358026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = SourceRange(Loc, Loc); 359026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = cast<MemberExpr>(this)->getBase()->getSourceRange(); 360026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 361026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 3625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: 3635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the base pointer or element is to a volatile pointer/field, accessing 364026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // it is a side effect. 365026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 366026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 367026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc(); 368026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange(); 369026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange(); 370026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 371211f6adf1301a1461015fb6cb08a05f0a35b65f3Eli Friedman 3725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case CallExprClass: 373026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner case CXXOperatorCallExprClass: { 374026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If this is a direct call, get the callee. 375026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const CallExpr *CE = cast<CallExpr>(this); 376026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const Expr *CalleeExpr = CE->getCallee()->IgnoreParenCasts(); 377026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (const DeclRefExpr *CalleeDRE = dyn_cast<DeclRefExpr>(CalleeExpr)) { 378026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If the callee has attribute pure, const, or warn_unused_result, warn 379026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // about it. void foo() { strlen("bar"); } should warn. 380026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CalleeDRE->getDecl())) 381026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (FD->getAttr<WarnUnusedResultAttr>() || 382026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) { 383026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = CE->getCallee()->getLocStart(); 384026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = CE->getCallee()->getSourceRange(); 385026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 386026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (unsigned NumArgs = CE->getNumArgs()) 387026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = SourceRange(CE->getArg(0)->getLocStart(), 388026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner CE->getArg(NumArgs-1)->getLocEnd()); 389026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 390026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 391026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 392026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 393026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 394a9c01021724b9b546d282b8609cbe559734812ecChris Lattner case ObjCMessageExprClass: 395026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 396611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner case StmtExprClass: { 397611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // Statement exprs don't logically have side effects themselves, but are 398611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // sometimes used in macros in ways that give them a type that is unused. 399611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // For example ({ blah; foo(); }) will end up with a type if foo has a type. 400611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // however, if the result of the stmt expr is dead, we don't want to emit a 401611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // warning. 402611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 403611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (!CS->body_empty()) 404611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 405026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return E->isUnusedResultAWarning(Loc, R1, R2); 406026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 407026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<StmtExpr>(this)->getLParenLoc(); 408026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = getSourceRange(); 409026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 410611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner } 4116eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 412026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If this is a cast to void, check the operand. Otherwise, the result of 413026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // the cast is unused. 414026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType()->isVoidType()) 415026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CastExpr>(this)->getSubExpr()->isUnusedResultAWarning(Loc, 416026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1, R2); 417026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<CStyleCastExpr>(this)->getLParenLoc(); 418026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange(); 419026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 420987a14bf5883ef6e5d07f1c83eb6d41a8212a78cArgyrios Kyrtzidis case CXXFunctionalCastExprClass: 4215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is a cast to void, check the operand. Otherwise, the result of 4225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the cast is unused. 4235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (getType()->isVoidType()) 424026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CastExpr>(this)->getSubExpr()->isUnusedResultAWarning(Loc, 425026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1, R2); 426026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc(); 427026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange(); 428026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 429026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 4304be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman case ImplicitCastExprClass: 4314be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman // Check the operand, since implicit casts are inserted by Sema 432026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<ImplicitCastExpr>(this) 433026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 4344be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman 43504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 436026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CXXDefaultArgExpr>(this) 437026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner ->getExpr()->isUnusedResultAWarning(Loc, R1, R2); 4384c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl 4394c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl case CXXNewExprClass: 4404c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl // FIXME: In theory, there might be new expressions that don't have side 4414c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl // effects (e.g. a placement new with an uninitialized POD). 4424c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl case CXXDeleteExprClass: 443026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 4444c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl } 4455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 447ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor/// DeclCanBeLvalue - Determine whether the given declaration can be 448ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor/// an lvalue. This is a helper routine for isLvalue. 449ba7e210a999275695f58be03ef402758cfec3635Douglas Gregorstatic bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) { 45072c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor // C++ [temp.param]p6: 45172c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor // A non-type non-reference template-parameter is not an lvalue. 45272c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor if (const NonTypeTemplateParmDecl *NTTParm 45372c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Decl)) 45472c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor return NTTParm->getType()->isReferenceType(); 45572c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor 45644b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) || 457ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor // C++ 3.10p2: An lvalue refers to an object or function. 458ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor (Ctx.getLangOptions().CPlusPlus && 459ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl))); 460ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor} 461ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor 4625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 4635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// incomplete type other than void. Nonarray expressions that can be lvalues: 4645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - name, where name must be a variable 4655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e[i] 4665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - (e), where e must be an lvalue 4675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e.name, where e must be an lvalue 4685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e->name 4695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - *e, the type of e cannot be a function type 4705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - string-constant 4717da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 47208ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling/// - reference type [C++ [expr]] 4735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 47428be73f74c9e241a23ea24fe5756623de6bf1084Chris LattnerExpr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const { 47598cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor // first, check the type (C99 6.3.2.1). Expressions with function 47698cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor // type in C are not lvalues, but they can be lvalues in C++. 47798cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor if (!Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 4785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_NotObjectType; 4795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 480acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff // Allow qualified void which is an incomplete type other than void (yuck). 48128be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers()) 482acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff return LV_IncompleteVoidType; 483acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff 48498cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor /// FIXME: Expressions can't have reference type, so the following 48598cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor /// isn't needed. 486cb4f9a6d0be445d84af35ba81323be6127816f9eChris Lattner if (TR->isReferenceType()) // C++ [expr] 48708ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling return LV_Valid; 48808ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling 4895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the type looks fine, now check the expression 4905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 4915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case StringLiteralClass: // C99 6.5.1p4 4927323a6297edad643c202594dcf3d9a174de96ca6Anders Carlsson return LV_Valid; 4935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 4945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // For vectors, make sure base is an lvalue (i.e. not a function call). 4955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 49628be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx); 4975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 4981a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case DeclRefExprClass: 4991a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case QualifiedDeclRefExprClass: { // C99 6.5.1p2 500ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl(); 501ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor if (DeclCanBeLvalue(RefdDecl, Ctx)) 5025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 5035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 5044111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner } 505dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff case BlockDeclRefExprClass: { 506dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 5074f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (isa<VarDecl>(BDR->getDecl())) 508dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff return LV_Valid; 509dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff break; 510dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff } 51186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor case MemberExprClass: { 5125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const MemberExpr *m = cast<MemberExpr>(this); 51386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4: 51486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor NamedDecl *Member = m->getMemberDecl(); 51586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // C++ [expr.ref]p4: 51686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // If E2 is declared to have type "reference to T", then E1.E2 51786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // is an lvalue. 51886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (ValueDecl *Value = dyn_cast<ValueDecl>(Member)) 51986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (Value->getType()->isReferenceType()) 52086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_Valid; 52186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 52286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a static data member [...] then E1.E2 is an lvalue. 52386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (isa<CXXClassVarDecl>(Member)) 52486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_Valid; 52586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 52686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a non-static data member [...]. If E1 is an 52786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // lvalue, then E1.E2 is an lvalue. 52886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (isa<FieldDecl>(Member)) 52986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 53086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 53186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If it refers to a static member function [...], then 53286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // E1.E2 is an lvalue. 53386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- Otherwise, if E1.E2 refers to a non-static member 53486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // function [...], then E1.E2 is not an lvalue. 53586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) 53686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return Method->isStatic()? LV_Valid : LV_MemberFunction; 53786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 53886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a member enumerator [...], the expression E1.E2 53986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // is not an lvalue. 54086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (isa<EnumConstantDecl>(Member)) 54186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_InvalidExpression; 54286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 54386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // Not an lvalue. 54486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_InvalidExpression; 54586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor } 54686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 54786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // C99 6.5.2.3p4 54828be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 549fdd75663fffeb2058a7847975e50837e61200593Anton Korobeynikov } 5507da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner case UnaryOperatorClass: 5515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 5527da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner return LV_Valid; // C99 6.5.3p4 5537da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner 5547da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 555baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag || 556baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension) 55728be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU. 55874253736184c0717a0649922551bf9d8b6815651Douglas Gregor 55974253736184c0717a0649922551bf9d8b6815651Douglas Gregor if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1 56074253736184c0717a0649922551bf9d8b6815651Douglas Gregor (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc || 56174253736184c0717a0649922551bf9d8b6815651Douglas Gregor cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec)) 56274253736184c0717a0649922551bf9d8b6815651Douglas Gregor return LV_Valid; 5635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 564eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case ImplicitCastExprClass: 565eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid 566eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor : LV_InvalidExpression; 5675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: // C99 6.5.1p5 56828be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx); 569eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case BinaryOperatorClass: 570eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case CompoundAssignOperatorClass: { 571eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor const BinaryOperator *BinOp = cast<BinaryOperator>(this); 572337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor 573337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1 574337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor BinOp->getOpcode() == BinaryOperator::Comma) 575337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor return BinOp->getRHS()->isLvalue(Ctx); 576337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor 577224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl // C++ [expr.mptr.oper]p6 578224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl if ((BinOp->getOpcode() == BinaryOperator::PtrMemD || 579224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl BinOp->getOpcode() == BinaryOperator::PtrMemI) && 580224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl !BinOp->getType()->isFunctionType()) 581224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl return BinOp->getLHS()->isLvalue(Ctx); 582224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl 583bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor if (!BinOp->isAssignmentOp()) 584eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor return LV_InvalidExpression; 585eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor 586bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor if (Ctx.getLangOptions().CPlusPlus) 587bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // C++ [expr.ass]p1: 588bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // The result of an assignment operation [...] is an lvalue. 589bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor return LV_Valid; 590bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor 591bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor 592bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // C99 6.5.16: 593bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // An assignment expression [...] is not an lvalue. 594bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor return LV_InvalidExpression; 595eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor } 59659b5da6d853b4368b984700315adf7b37de05764Nate Begeman // FIXME: OverloadExprClass 597b4609806e9232593ece09ce08b630836e825865cDouglas Gregor case CallExprClass: 59888a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor case CXXOperatorCallExprClass: 59988a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor case CXXMemberCallExprClass: { 6009d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.call]p10: 6019d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // A function call is an lvalue if and only if the result type 6029d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // is a reference. 60327c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor QualType CalleeType = cast<CallExpr>(this)->getCallee()->getType(); 6049d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor if (const PointerType *FnTypePtr = CalleeType->getAsPointerType()) 60588a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor CalleeType = FnTypePtr->getPointeeType(); 60688a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor if (const FunctionType *FnType = CalleeType->getAsFunctionType()) 60788a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor if (FnType->getResultType()->isReferenceType()) 60888a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor return LV_Valid; 6099d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor 6109d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor break; 6119d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor } 612e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff case CompoundLiteralExprClass: // C99 6.5.2.5p5 613e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff return LV_Valid; 614670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner case ChooseExprClass: 615670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner // __builtin_choose_expr is an lvalue if the selected operand is. 616670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner if (cast<ChooseExpr>(this)->isConditionTrue(Ctx)) 617670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner return cast<ChooseExpr>(this)->getLHS()->isLvalue(Ctx); 618670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner else 619670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner return cast<ChooseExpr>(this)->getRHS()->isLvalue(Ctx); 620670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner 621213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case ExtVectorElementExprClass: 622213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 623fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_DuplicateVectorComponents; 624fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_Valid; 625027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 626027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff return LV_Valid; 627799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff case ObjCPropertyRefExprClass: // FIXME: check if read-only property. 628799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff return LV_Valid; 6295daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian case ObjCKVCRefExprClass: // FIXME: check if read-only property. 630670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner return LV_Valid; 631d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 632796da18402f286b897782a298ae3b20c459c102eDouglas Gregor return LV_Valid; 6339d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case VAArgExprClass: 634adadd8db2aba32f689e7057d8b7ce004be30685bDaniel Dunbar return LV_NotObjectType; 63504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 63628be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx); 63724b41fa8239c63b9eb570d3e83c4a82840656a65Argyrios Kyrtzidis case CXXConditionDeclExprClass: 63824b41fa8239c63b9eb570d3e83c4a82840656a65Argyrios Kyrtzidis return LV_Valid; 6396eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 6409d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXFunctionalCastExprClass: 6419d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXStaticCastExprClass: 6429d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXDynamicCastExprClass: 6439d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXReinterpretCastExprClass: 6449d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXConstCastExprClass: 6459d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // The result of an explicit cast is an lvalue if the type we are 6469d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // casting to is a reference type. See C++ [expr.cast]p1, 6479d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2, 6489d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1. 6499d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()->isReferenceType()) 6509d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor return LV_Valid; 6519d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor break; 652c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl case CXXTypeidExprClass: 653c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ... 654c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl return LV_Valid; 6555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 6565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 6575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 6585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_InvalidExpression; 6595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 6625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// does not have an incomplete type, does not have a const-qualified type, and 6635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// if it is a structure or union, does not have any member (including, 6645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// recursively, any member or element of all contained aggregates or unions) 6655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// with a const-qualified type. 66628be73f74c9e241a23ea24fe5756623de6bf1084Chris LattnerExpr::isModifiableLvalueResult Expr::isModifiableLvalue(ASTContext &Ctx) const { 66728be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner isLvalueResult lvalResult = isLvalue(Ctx); 6685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (lvalResult) { 670ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor case LV_Valid: 671ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor // C++ 3.10p11: Functions cannot be modified, but pointers to 672ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor // functions can be modifiable. 673ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 674ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor return MLV_NotObjectType; 675ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor break; 676ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor 6775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_NotObjectType: return MLV_NotObjectType; 6785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 679fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 680ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner case LV_InvalidExpression: 681ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // If the top level is a C-style cast, and the subexpression is a valid 682ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // lvalue, then this is probably a use of the old-school "cast as lvalue" 683ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // GCC extension. We don't support it, but we want to produce good 684ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // diagnostics when it happens so that the user knows why. 685ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(this)) 686ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) 687ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner return MLV_LValueCast; 688ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner return MLV_InvalidExpression; 68986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor case LV_MemberFunction: return MLV_MemberFunction; 6905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 691c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 692c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType CT = Ctx.getCanonicalType(getType()); 693c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 694c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT.isConstQualified()) 6955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 696c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isArrayType()) 6975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ArrayType; 698c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isIncompleteType()) 6995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_IncompleteType; 7005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 701c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const RecordType *r = CT->getAsRecordType()) { 7025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (r->hasConstFields()) 7035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 7045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 7054f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // The following is illegal: 7064f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // void takeclosure(void (^C)(void)); 7074f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // void func() { int x = 1; takeclosure(^{ x = 7 }); } 7084f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // 7094f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (getStmtClass() == BlockDeclRefExprClass) { 7104f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 7114f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl())) 7124f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff return MLV_NotBlockQualified; 7134f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff } 714d1fa6449e9dbdd667466e9e1e971aa17c9793e8aFariborz Jahanian 715ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian // Assigning to an 'implicit' property? 7166669db9d80d77d10f101aa9f8e488bbd2d98f76cFariborz Jahanian else if (getStmtClass() == ObjCKVCRefExprClass) { 717ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian const ObjCKVCRefExpr* KVCExpr = cast<ObjCKVCRefExpr>(this); 718ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian if (KVCExpr->getSetterMethod() == 0) 719ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian return MLV_NoSetterProperty; 720ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian } 7215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_Valid; 7225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 7235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7242e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek/// hasGlobalStorage - Return true if this expression has static storage 7254cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// duration. This means that the address of this expression is a link-time 7264cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// constant. 7272e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenekbool Expr::hasGlobalStorage() const { 7281d09ecca892185ba067e47ba879f424de59950efChris Lattner switch (getStmtClass()) { 7291d09ecca892185ba067e47ba879f424de59950efChris Lattner default: 7301d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 7314cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ParenExprClass: 7322e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage(); 7334cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ImplicitCastExprClass: 7342e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage(); 735e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff case CompoundLiteralExprClass: 736e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff return cast<CompoundLiteralExpr>(this)->isFileScope(); 7371a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case DeclRefExprClass: 7381a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case QualifiedDeclRefExprClass: { 7391d09ecca892185ba067e47ba879f424de59950efChris Lattner const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 7401d09ecca892185ba067e47ba879f424de59950efChris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 7412e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return VD->hasGlobalStorage(); 74263f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon if (isa<FunctionDecl>(D)) 74363f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon return true; 7441d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 7451d09ecca892185ba067e47ba879f424de59950efChris Lattner } 746fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner case MemberExprClass: { 7471d09ecca892185ba067e47ba879f424de59950efChris Lattner const MemberExpr *M = cast<MemberExpr>(this); 7482e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return !M->isArrow() && M->getBase()->hasGlobalStorage(); 749fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner } 7504cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ArraySubscriptExprClass: 7512e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage(); 752d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 753fa28b30d5a1e93e5263be33e343532b900d2c643Chris Lattner return true; 75404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 75504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage(); 7561d09ecca892185ba067e47ba879f424de59950efChris Lattner } 7571d09ecca892185ba067e47ba879f424de59950efChris Lattner} 7581d09ecca892185ba067e47ba879f424de59950efChris Lattner 7594e99a5fc3b203397a91136c6e695e405fb8fc606Ted KremenekExpr* Expr::IgnoreParens() { 7604e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek Expr* E = this; 7614e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 7624e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek E = P->getSubExpr(); 7634e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 7644e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek return E; 7654e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek} 7664e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 76756f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 76856f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// or CastExprs or ImplicitCastExprs, returning their operand. 76956f349400c5932a196509c0480ff6f99a9a0b48fChris LattnerExpr *Expr::IgnoreParenCasts() { 77056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner Expr *E = this; 77156f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner while (true) { 77256f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 77356f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 77456f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else if (CastExpr *P = dyn_cast<CastExpr>(E)) 77556f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 77656f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else 77756f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner return E; 77856f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner } 77956f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner} 78056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner 781898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// hasAnyTypeDependentArguments - Determines if any of the expressions 782898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// in Exprs is type-dependent. 783898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorbool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) { 784898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor for (unsigned I = 0; I < NumExprs; ++I) 785898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (Exprs[I]->isTypeDependent()) 786898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return true; 787898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 788898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return false; 789898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 790898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 791898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// hasAnyValueDependentArguments - Determines if any of the expressions 792898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// in Exprs is value-dependent. 793898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorbool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) { 794898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor for (unsigned I = 0; I < NumExprs; ++I) 795898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (Exprs[I]->isValueDependent()) 796898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return true; 797898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 798898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return false; 799898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 800898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 801c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedmanbool Expr::isConstantInitializer(ASTContext &Ctx) const { 802c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // This function is attempting whether an expression is an initializer 803c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // which can be evaluated at compile-time. isEvaluatable handles most 804c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // of the cases, but it can't deal with some initializer-specific 805c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // expressions, and it can't deal with aggregates; we deal with those here, 806c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // and fall back to isEvaluatable for the other cases. 807c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman 808e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson switch (getStmtClass()) { 809c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman default: break; 810e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson case StringLiteralClass: 811e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson return true; 81259b5da6d853b4368b984700315adf7b37de05764Nate Begeman case CompoundLiteralExprClass: { 81359b5da6d853b4368b984700315adf7b37de05764Nate Begeman const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer(); 814c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedman return Exp->isConstantInitializer(Ctx); 81559b5da6d853b4368b984700315adf7b37de05764Nate Begeman } 816e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson case InitListExprClass: { 817e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson const InitListExpr *Exp = cast<InitListExpr>(this); 818e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson unsigned numInits = Exp->getNumInits(); 819e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson for (unsigned i = 0; i < numInits; i++) { 820c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedman if (!Exp->getInit(i)->isConstantInitializer(Ctx)) 821e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson return false; 822e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 823c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return true; 824e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 8253498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor case ImplicitValueInitExprClass: 8263498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return true; 827c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case ParenExprClass: { 828c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 829c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman } 830c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case UnaryOperatorClass: { 831c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman const UnaryOperator* Exp = cast<UnaryOperator>(this); 832c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman if (Exp->getOpcode() == UnaryOperator::Extension) 833c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return Exp->getSubExpr()->isConstantInitializer(Ctx); 834c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman break; 835c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman } 836c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case CStyleCastExprClass: 837c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // Handle casts with a destination that's a struct or union; this 838c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // deals with both the gcc no-op struct cast extension and the 839c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // cast-to-union extension. 840c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman if (getType()->isRecordType()) 841c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 842c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman break; 84332a311e276cd4bcafddd38db679aff9804e66bd4Eli Friedman case DesignatedInitExprClass: 8444e716e07d90a18ac83dd94d157ec676530bc78f9Sebastian Redl return cast<DesignatedInitExpr>(this)-> 8454e716e07d90a18ac83dd94d157ec676530bc78f9Sebastian Redl getInit()->isConstantInitializer(Ctx); 846e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 847e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson 848c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return isEvaluatable(Ctx); 84938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff} 85038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 8515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isIntegerConstantExpr - this recursive routine will test if an expression is 8525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// an integer constant expression. Note: With the introduction of VLA's in 8535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// C99 the result of the sizeof operator is no longer always a constant 8545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// expression. The generalization of the wording to include any subexpression 8555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// that is not evaluated (C99 6.6p3) means that nonconstant subexpressions 8565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// can appear as operands to other operators (e.g. &&, ||, ?:). For instance, 8575f6b632391e24b08ead3e62ba2e2765e770382edNuno Lopes/// "0 || f()" can be treated as a constant expression. In C90 this expression, 8585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// occurring in a context requiring a constant, would have been a constraint 8595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// violation. FIXME: This routine currently implements C90 semantics. 8605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// To properly implement C99 semantics this routine will need to evaluate 8615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// expressions involving operators previously mentioned. 8625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 8645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// comma, etc 8655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 8665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FIXME: This should ext-warn on overflow during evaluation! ISO C does not 867ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner/// permit this. This includes things like (int)1e1000 868ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// 869ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof 870ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer 871ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// cast+dereference. 872590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattnerbool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, 873590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner SourceLocation *Loc, bool isEvaluated) const { 874a6afa768aa7bd3102a2807aa720917e4a1771e4eEli Friedman // Pretest for integral type; some parts of the code crash for types that 875a6afa768aa7bd3102a2807aa720917e4a1771e4eEli Friedman // can't be sized. 876a6afa768aa7bd3102a2807aa720917e4a1771e4eEli Friedman if (!getType()->isIntegralType()) { 877a6afa768aa7bd3102a2807aa720917e4a1771e4eEli Friedman if (Loc) *Loc = getLocStart(); 878a6afa768aa7bd3102a2807aa720917e4a1771e4eEli Friedman return false; 879a6afa768aa7bd3102a2807aa720917e4a1771e4eEli Friedman } 8805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 8815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 8825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 8835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 8845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: 8855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return cast<ParenExpr>(this)->getSubExpr()-> 886590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 8875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case IntegerLiteralClass: 8885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = cast<IntegerLiteral>(this)->getValue(); 889a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result.setIsUnsigned(getType()->isUnsignedIntegerType()); 8905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8912eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner case CharacterLiteralClass: { 8922eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner const CharacterLiteral *CL = cast<CharacterLiteral>(this); 893a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(CL->getValue(), getType()); 8945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8952eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner } 896b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson case CXXBoolLiteralExprClass: { 897b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson const CXXBoolLiteralExpr *BL = cast<CXXBoolLiteralExpr>(this); 898a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(BL->getValue(), getType()); 899b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson break; 900b88d45ea7eb835d36c4a4b3ea84b1260b120dd0aAnders Carlsson } 9017267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis case CXXZeroInitValueExprClass: 902a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(0, getType()); 9037267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis break; 9047b658aa315784fa489a32daeacfe400512ce468dSteve Naroff case TypesCompatibleExprClass: { 9057b658aa315784fa489a32daeacfe400512ce468dSteve Naroff const TypesCompatibleExpr *TCE = cast<TypesCompatibleExpr>(this); 906ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar // Per gcc docs "this built-in function ignores top level 907ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar // qualifiers". We need to use the canonical version to properly 908ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar // be able to strip CRV qualifiers from the type. 909ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar QualType T0 = Ctx.getCanonicalType(TCE->getArgType1()); 910ac620decb68aad1a2cf6c0c191b56d78981d9aaaDaniel Dunbar QualType T1 = Ctx.getCanonicalType(TCE->getArgType2()); 911a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(Ctx.typesAreCompatible(T0.getUnqualifiedType(), 912a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar T1.getUnqualifiedType()), 913a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar getType()); 914389cecc83f33e93c8ba6bf2e8269b8690404416fSteve Naroff break; 9157b658aa315784fa489a32daeacfe400512ce468dSteve Naroff } 916b4609806e9232593ece09ce08b630836e825865cDouglas Gregor case CallExprClass: 917b4609806e9232593ece09ce08b630836e825865cDouglas Gregor case CXXOperatorCallExprClass: { 91813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff const CallExpr *CE = cast<CallExpr>(this); 919a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner 920a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner // If this is a call to a builtin function, constant fold it otherwise 921a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner // reject it. 9223c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CE->isBuiltinCall(Ctx)) { 9231c0cfd4599e816cfd7a8f348286bf0ad79652ffcAnders Carlsson EvalResult EvalResult; 9241c0cfd4599e816cfd7a8f348286bf0ad79652ffcAnders Carlsson if (CE->Evaluate(EvalResult, Ctx)) { 9251c0cfd4599e816cfd7a8f348286bf0ad79652ffcAnders Carlsson assert(!EvalResult.HasSideEffects && 9261c0cfd4599e816cfd7a8f348286bf0ad79652ffcAnders Carlsson "Foldable builtin call should not have side effects!"); 9271c0cfd4599e816cfd7a8f348286bf0ad79652ffcAnders Carlsson Result = EvalResult.Val.getInt(); 928a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner break; // It is a constant, expand it. 929a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner } 930a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner } 931a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner 93213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (Loc) *Loc = getLocStart(); 93313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return false; 93413b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff } 9355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclRefExprClass: 9361a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case QualifiedDeclRefExprClass: 9375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const EnumConstantDecl *D = 9385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer dyn_cast<EnumConstantDecl>(cast<DeclRefExpr>(this)->getDecl())) { 9395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = D->getInitVal(); 9405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9424a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (Ctx.getLangOptions().CPlusPlus && 9434a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl getType().getCVRQualifiers() == QualType::Const) { 9444a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // C++ 7.1.5.1p2 9454a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // A variable of non-volatile const-qualified integral or enumeration 9464a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // type initialized by an ICE can be used in ICEs. 9474a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (const VarDecl *Dcl = 9484a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl dyn_cast<VarDecl>(cast<DeclRefExpr>(this)->getDecl())) { 9494a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (const Expr *Init = Dcl->getInit()) 9504a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl return Init->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 9514a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl } 9524a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl } 9535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 9545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperatorClass: { 9565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const UnaryOperator *Exp = cast<UnaryOperator>(this); 9575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9580518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // Get the operand value. If this is offsetof, do not evalute the 9595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // operand. This affects C99 6.6p3. 9600518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (!Exp->isOffsetOfOp() && !Exp->getSubExpr()-> 9610518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 9625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 9655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 9665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // See C99 6.6p3. 9675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 9685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = Exp->getOperatorLoc(); 9695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 97176e773a443be9f006610f46529e07d4c8d857680Chris Lattner return true; // FIXME: this is wrong. 9725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::LNot: { 973a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(Result == 0, getType()); 9745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Plus: 9775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Minus: 9795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = -Result; 9805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Not: 9825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = ~Result; 9835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9845a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson case UnaryOperator::OffsetOf: 985a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(Exp->evaluateOffsetOf(Ctx), getType()); 986a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar break; 9875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9900518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl case SizeOfAlignOfExprClass: { 9910518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(this); 992a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 9930518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType ArgTy = Exp->getTypeOfArgument(); 994a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // sizeof(void) and __alignof__(void) = 1 as a gcc extension. 9950518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (ArgTy->isVoidType()) { 996a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(1, getType()); 997a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner break; 998a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner } 999a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 1000a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // alignof always evaluates to a constant, sizeof does if arg is not VLA. 10010518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (Exp->isSizeOf() && !ArgTy->isConstantSizeType()) { 100265383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner if (Loc) *Loc = Exp->getOperatorLoc(); 10035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 100465383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner } 10055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 100676e773a443be9f006610f46529e07d4c8d857680Chris Lattner // Get information about the size or align. 10070518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (ArgTy->isFunctionType()) { 1008efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner // GCC extension: sizeof(function) = 1. 1009a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(Exp->isSizeOf() ? 1 : 4, getType()); 10106a24acbb3dbb3bea9426716bee6ad6023ad15f3fAnders Carlsson } else { 101198be4943e8dc4f3905629a7102668960873cf863Chris Lattner unsigned CharSize = Ctx.Target.getCharWidth(); 10126a24acbb3dbb3bea9426716bee6ad6023ad15f3fAnders Carlsson if (Exp->isSizeOf()) 1013a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(Ctx.getTypeSize(ArgTy)/CharSize, getType()); 10146a24acbb3dbb3bea9426716bee6ad6023ad15f3fAnders Carlsson else 1015a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(Ctx.getTypeAlign(ArgTy)/CharSize, getType()); 1016060e470e53b73167114284eb0b8c3e25bb3dad99Ted Kremenek } 10175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 10185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperatorClass: { 10205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const BinaryOperator *Exp = cast<BinaryOperator>(this); 1021e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar llvm::APSInt LHS, RHS; 1022e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar 1023e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar // Initialize result to have correct signedness and width. 1024a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(0, getType()); 1025b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman 10265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // The LHS of a constant expr is always evaluated and needed. 1027e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar if (!Exp->getLHS()->isIntegerConstantExpr(LHS, Ctx, Loc, isEvaluated)) 10285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // The short-circuiting &&/|| operators don't necessarily evaluate their 10315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // RHS. Make sure to pass isEvaluated down correctly. 10325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Exp->isLogicalOp()) { 10335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer bool RHSEval; 10345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Exp->getOpcode() == BinaryOperator::LAnd) 1035e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar RHSEval = LHS != 0; 10365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else { 10375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(Exp->getOpcode() == BinaryOperator::LOr &&"Unexpected logical"); 1038e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar RHSEval = LHS == 0; 10395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1041590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, 10425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer isEvaluated & RHSEval)) 10435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 1045590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, isEvaluated)) 10465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 10505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 10515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 10525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Mul: 1054e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS * RHS; 10555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 10565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Div: 10575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (RHS == 0) { 10585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!isEvaluated) break; 10595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 10605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1062e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS / RHS; 10635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 10645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Rem: 10655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (RHS == 0) { 10665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!isEvaluated) break; 10675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 10685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1070e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS % RHS; 10715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 1072e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::Add: Result = LHS + RHS; break; 1073e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::Sub: Result = LHS - RHS; break; 10745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shl: 1075e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS << 1076e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1)); 1077e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar break; 10785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shr: 1079e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS >> 1080e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1)); 10815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 1082e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::LT: Result = LHS < RHS; break; 1083e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::GT: Result = LHS > RHS; break; 1084e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::LE: Result = LHS <= RHS; break; 1085e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::GE: Result = LHS >= RHS; break; 1086e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::EQ: Result = LHS == RHS; break; 1087e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::NE: Result = LHS != RHS; break; 1088e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::And: Result = LHS & RHS; break; 1089e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::Xor: Result = LHS ^ RHS; break; 1090e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar case BinaryOperator::Or: Result = LHS | RHS; break; 10915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::LAnd: 1092e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS != 0 && RHS != 0; 10935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 10945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::LOr: 1095e1226d24d23510e422160eb2413d9bb90de9b144Daniel Dunbar Result = LHS != 0 || RHS != 0; 10965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 1097b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman 1098b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman case BinaryOperator::Comma: 1099b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman // C99 6.6p3: "shall not contain assignment, ..., or comma operators, 1100b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman // *except* when they are contained within a subexpression that is not 1101b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman // evaluated". Note that Assignment can never happen due to constraints 1102b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman // on the LHS subexpr, so we don't need to check it here. 1103b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman if (isEvaluated) { 1104b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman if (Loc) *Loc = getLocStart(); 1105b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman return false; 1106b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman } 1107b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman 1108b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman // The result of the constant expr is the RHS. 1109b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman Result = RHS; 1110b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman return true; 11115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1112a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar 11135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(!Exp->isAssignmentOp() && "LHS can't be a constant expr!"); 11145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 11155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 111626dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner case ImplicitCastExprClass: 11176eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 1118987a14bf5883ef6e5d07f1c83eb6d41a8212a78cArgyrios Kyrtzidis case CXXFunctionalCastExprClass: { 11190835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis const Expr *SubExpr = cast<CastExpr>(this)->getSubExpr(); 11200835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis SourceLocation CastLoc = getLocStart(); 112126dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner 11225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.6p6: shall only convert arithmetic types to integer types. 112326dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (!SubExpr->getType()->isArithmeticType() || 112426dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner !getType()->isIntegerType()) { 112526dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (Loc) *Loc = SubExpr->getLocStart(); 11265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 11275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1128987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner 112998be4943e8dc4f3905629a7102668960873cf863Chris Lattner uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType())); 1130987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner 11315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Handle simple integer->integer casts. 113226dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (SubExpr->getType()->isIntegerType()) { 113326dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (!SubExpr->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 11345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 113526dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner 113626dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner // Figure out if this is a truncate, extend or noop cast. 113726dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner // If the input is signed, do a sign extend, noop, or truncate. 1138c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner if (getType()->isBooleanType()) { 1139c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner // Conversion to bool compares against zero. 1140a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(Result != 0, getType()); 1141a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar } else if (SubExpr->getType()->isSignedIntegerType()) { 114226dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner Result.sextOrTrunc(DestWidth); 1143a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result.setIsUnsigned(getType()->isUnsignedIntegerType()); 1144a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar } else { // If the input is unsigned, do a zero extend, noop, 1145a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar // or truncate. 114626dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner Result.zextOrTrunc(DestWidth); 1147a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result.setIsUnsigned(getType()->isUnsignedIntegerType()); 1148a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar } 11495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 11505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 11515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 11525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Allow floating constants that are the immediate operands of casts or that 11535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // are parenthesized. 1154a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar const Expr *Operand = SubExpr->IgnoreParens(); 1155987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner 1156987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner // If this isn't a floating literal, we can't handle it. 1157987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(Operand); 1158987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner if (!FL) { 1159987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner if (Loc) *Loc = Operand->getLocStart(); 1160987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner return false; 1161987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner } 1162c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner 1163c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner // If the destination is boolean, compare against zero. 1164c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner if (getType()->isBooleanType()) { 1165a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(!FL->getValue().isZero(), getType()); 1166c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner break; 1167c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner } 11685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1169987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner // Determine whether we are converting to unsigned or signed. 1170987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner bool DestSigned = getType()->isSignedIntegerType(); 1171ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner 1172ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner // TODO: Warn on overflow, but probably not here: isIntegerConstantExpr can 1173ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner // be called multiple times per AST. 1174ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen uint64_t Space[4]; 1175ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen bool ignored; 1176ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner (void)FL->getValue().convertToInteger(Space, DestWidth, DestSigned, 1177ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen llvm::APFloat::rmTowardZero, 1178ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen &ignored); 1179987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner Result = llvm::APInt(DestWidth, 4, Space); 1180a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result.setIsUnsigned(getType()->isUnsignedIntegerType()); 1181987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner break; 11825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 11835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ConditionalOperatorClass: { 11845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 11855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 118628daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner const Expr *Cond = Exp->getCond(); 118728daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner 118828daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner if (!Cond->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 11895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 11905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 11915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const Expr *TrueExp = Exp->getLHS(); 11925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const Expr *FalseExp = Exp->getRHS(); 11935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Result == 0) std::swap(TrueExp, FalseExp); 11945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 119528daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner // If the condition (ignoring parens) is a __builtin_constant_p call, 119628daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner // then only the true side is actually considered in an integer constant 119742b83dde7c700b34f9435ad746984169888ae705Chris Lattner // expression, and it is fully evaluated. This is an important GNU 119842b83dde7c700b34f9435ad746984169888ae705Chris Lattner // extension. See GCC PR38377 for discussion. 119928daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner if (const CallExpr *CallCE = dyn_cast<CallExpr>(Cond->IgnoreParenCasts())) 12003c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) { 120142b83dde7c700b34f9435ad746984169888ae705Chris Lattner EvalResult EVResult; 120242b83dde7c700b34f9435ad746984169888ae705Chris Lattner if (!Evaluate(EVResult, Ctx) || EVResult.HasSideEffects) 120342b83dde7c700b34f9435ad746984169888ae705Chris Lattner return false; 120442b83dde7c700b34f9435ad746984169888ae705Chris Lattner assert(EVResult.Val.isInt() && "FP conditional expr not expected"); 120542b83dde7c700b34f9435ad746984169888ae705Chris Lattner Result = EVResult.Val.getInt(); 120642b83dde7c700b34f9435ad746984169888ae705Chris Lattner if (Loc) *Loc = EVResult.DiagLoc; 120742b83dde7c700b34f9435ad746984169888ae705Chris Lattner return true; 120842b83dde7c700b34f9435ad746984169888ae705Chris Lattner } 120928daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner 12105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Evaluate the false one first, discard the result. 12113907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (FalseExp && !FalseExp->isIntegerConstantExpr(Result, Ctx, Loc, false)) 12125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 12135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Evalute the true one, capture the result. 12143907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (TrueExp && 12153907323dd6665c0c4e383435cb145233f4533406Anders Carlsson !TrueExp->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 12165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 12175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 12185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 121904421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 122004421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this) 122104421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner ->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 122264b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl 122364b45f7e0d3167f040841ac2920aead7f080730dSebastian Redl case UnaryTypeTraitExprClass: 1224a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar Result = Ctx.MakeIntValue(cast<UnaryTypeTraitExpr>(this)->EvaluateTrait(), 1225a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar getType()); 1226a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar break; 12275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 12285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 12305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 12315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an 12335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// integer constant expression with the value zero, or if this is one that is 12345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// cast to void*. 1235efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlssonbool Expr::isNullPointerConstant(ASTContext &Ctx) const 1236efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlsson{ 12370777972d38a3125efed962b045704c30ae6965cfSebastian Redl // Strip off a cast to void*, if it exists. Except in C++. 12380835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 12396215dee86c0e715b9f2b0d401ab2a5fcf629f1afSebastian Redl if (!Ctx.getLangOptions().CPlusPlus) { 12400777972d38a3125efed962b045704c30ae6965cfSebastian Redl // Check that it is a cast to void*. 12410777972d38a3125efed962b045704c30ae6965cfSebastian Redl if (const PointerType *PT = CE->getType()->getAsPointerType()) { 12420777972d38a3125efed962b045704c30ae6965cfSebastian Redl QualType Pointee = PT->getPointeeType(); 12430777972d38a3125efed962b045704c30ae6965cfSebastian Redl if (Pointee.getCVRQualifiers() == 0 && 12440777972d38a3125efed962b045704c30ae6965cfSebastian Redl Pointee->isVoidType() && // to void* 12450777972d38a3125efed962b045704c30ae6965cfSebastian Redl CE->getSubExpr()->getType()->isIntegerType()) // from int. 1246d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return CE->getSubExpr()->isNullPointerConstant(Ctx); 12470777972d38a3125efed962b045704c30ae6965cfSebastian Redl } 12485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1249aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1250aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Ignore the ImplicitCastExpr type entirely. 1251d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return ICE->getSubExpr()->isNullPointerConstant(Ctx); 1252aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1253aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Accept ((void*)0) as a null pointer constant, as many other 1254aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // implementations do. 1255d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return PE->getSubExpr()->isNullPointerConstant(Ctx); 12568123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner } else if (const CXXDefaultArgExpr *DefaultArg 12578123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner = dyn_cast<CXXDefaultArgExpr>(this)) { 125804421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner // See through default argument expressions 1259d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return DefaultArg->getExpr()->isNullPointerConstant(Ctx); 12602d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor } else if (isa<GNUNullExpr>(this)) { 12612d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor // The GNU __null extension is always a null pointer constant. 12622d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor return true; 1263aaffbf7c790a324ed114184db771aae2d2e9151cSteve Naroff } 12642d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor 1265aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // This expression must be an integer type. 1266aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff if (!getType()->isIntegerType()) 1267aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return false; 1268aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff 12695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If we have an integer constant expression, we need to *evaluate* it and 12705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // test for the value 0. 1271d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson // FIXME: We should probably return false if we're compiling in strict mode 1272d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson // and Diag is not null (this indicates that the value was foldable but not 1273d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson // an ICE. 1274d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson EvalResult Result; 1275efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlsson return Evaluate(Result, Ctx) && !Result.HasSideEffects && 1276d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson Result.Val.isInt() && Result.Val.getInt() == 0; 12775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 127831a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff 127927c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor/// isBitField - Return true if this expression is a bit-field. 128027c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregorbool Expr::isBitField() { 128127c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor Expr *E = this->IgnoreParenCasts(); 128227c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 128386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl())) 128486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return Field->isBitField(); 128527c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor return false; 128627c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor} 128727c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor 12882140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner/// isArrow - Return true if the base expression is a pointer to vector, 12892140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner/// return false if the base expression is a vector. 12902140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattnerbool ExtVectorElementExpr::isArrow() const { 12912140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner return getBase()->getType()->isPointerType(); 12922140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner} 12932140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner 1294213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanunsigned ExtVectorElementExpr::getNumElements() const { 12958a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (const VectorType *VT = getType()->getAsVectorType()) 12968a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return VT->getNumElements(); 12978a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return 1; 12984d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner} 12994d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner 13008a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// containsDuplicateElements - Return true if any element access is repeated. 1301213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanbool ExtVectorElementExpr::containsDuplicateElements() const { 1302fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *compStr = Accessor.getName(); 13037e3e9b152e06edf329ceb32190d3255f248d4d5fChris Lattner unsigned length = Accessor.getLength(); 1304190d6a25393995b42e32086949a68285ee423fb9Nate Begeman 1305190d6a25393995b42e32086949a68285ee423fb9Nate Begeman // Halving swizzles do not contain duplicate elements. 1306190d6a25393995b42e32086949a68285ee423fb9Nate Begeman if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") || 1307190d6a25393995b42e32086949a68285ee423fb9Nate Begeman !strcmp(compStr, "even") || !strcmp(compStr, "odd")) 1308190d6a25393995b42e32086949a68285ee423fb9Nate Begeman return false; 1309190d6a25393995b42e32086949a68285ee423fb9Nate Begeman 1310190d6a25393995b42e32086949a68285ee423fb9Nate Begeman // Advance past s-char prefix on hex swizzles. 1311190d6a25393995b42e32086949a68285ee423fb9Nate Begeman if (*compStr == 's') { 1312190d6a25393995b42e32086949a68285ee423fb9Nate Begeman compStr++; 1313190d6a25393995b42e32086949a68285ee423fb9Nate Begeman length--; 1314190d6a25393995b42e32086949a68285ee423fb9Nate Begeman } 1315fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff 13167e3e9b152e06edf329ceb32190d3255f248d4d5fChris Lattner for (unsigned i = 0; i != length-1; i++) { 1317fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *s = compStr+i; 1318fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff for (const char c = *s++; *s; s++) 1319fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff if (c == *s) 1320fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return true; 1321fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff } 1322fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return false; 1323fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff} 1324b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 13258a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 13263b8d116703db8018f855cbb4733ace426422623bNate Begemanvoid ExtVectorElementExpr::getEncodedElementAccess( 13273b8d116703db8018f855cbb4733ace426422623bNate Begeman llvm::SmallVectorImpl<unsigned> &Elts) const { 13287e3e9b152e06edf329ceb32190d3255f248d4d5fChris Lattner const char *compStr = Accessor.getName(); 1329353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman if (*compStr == 's') 1330353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman compStr++; 1331353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman 1332353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isHi = !strcmp(compStr, "hi"); 1333353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isLo = !strcmp(compStr, "lo"); 1334353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isEven = !strcmp(compStr, "even"); 1335353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isOdd = !strcmp(compStr, "odd"); 1336353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman 13378a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 13388a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman uint64_t Index; 13398a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 13408a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (isHi) 13418a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = e + i; 13428a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isLo) 13438a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = i; 13448a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isEven) 13458a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i; 13468a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isOdd) 13478a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i + 1; 13488a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else 13498a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = ExtVectorType::getAccessorIdx(compStr[i]); 1350b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 13513b8d116703db8018f855cbb4733ace426422623bNate Begeman Elts.push_back(Index); 1352b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner } 13538a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman} 13548a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 135568d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for instance messages. 1356bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1357a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1358db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 135949f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1360db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1361ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 136249f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 13635549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 136468d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[RECEIVER] = receiver; 136549f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 136649f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 136768d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 136868d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1369563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1370563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1371563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1372563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 137368d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for class messages. 137468d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// FIXME: clsName should be typed to ObjCInterfaceType 1375bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1376a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1377db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 137849f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1379db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1380ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 138149f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 13825549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 13834df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown); 138449f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 138549f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 138668d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 138768d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1388563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1389563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1390563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1391563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 13924df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek// constructor for class messages. 13934df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo, 13944df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek QualType retType, ObjCMethodDecl *mproto, 13954df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SourceLocation LBrac, SourceLocation RBrac, 13964df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek Expr **ArgExprs, unsigned nargs) 13974df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek: Expr(ObjCMessageExprClass, retType), SelName(selInfo), 13984df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekMethodProto(mproto) { 13994df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek NumArgs = nargs; 14004df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 14014df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown); 14024df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek if (NumArgs) { 14034df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek for (unsigned i = 0; i != NumArgs; ++i) 14044df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 14054df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 14064df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek LBracloc = LBrac; 14074df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek RBracloc = RBrac; 14084df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 14094df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 14104df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const { 14114df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek uintptr_t x = (uintptr_t) SubExprs[RECEIVER]; 14124df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek switch (x & Flags) { 14134df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek default: 14144df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek assert(false && "Invalid ObjCMessageExpr."); 14154df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsInstMeth: 14164df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, 0); 14174df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclUnknown: 14184df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, (IdentifierInfo*) (x & ~Flags)); 14194df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclKnown: { 14204df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags); 14214df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(D, D->getIdentifier()); 14224df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 14234df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 14244df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 14254df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 142627437caadea35f84d550cd29f024fcf3ea240eecChris Lattnerbool ChooseExpr::isConditionTrue(ASTContext &C) const { 142732442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar return getCond()->getIntegerConstantExprValue(C) != 0; 142827437caadea35f84d550cd29f024fcf3ea240eecChris Lattner} 142927437caadea35f84d550cd29f024fcf3ea240eecChris Lattner 1430670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattnerstatic int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) { 14315a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 14325a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson QualType Ty = ME->getBase()->getType(); 14335a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 14345a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson RecordDecl *RD = Ty->getAsRecordType()->getDecl(); 143598be4943e8dc4f3905629a7102668960873cf863Chris Lattner const ASTRecordLayout &RL = C.getASTRecordLayout(RD); 143686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) { 143786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // FIXME: This is linear time. And the fact that we're indexing 143886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // into the layout by position in the record means that we're 143986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // either stuck numbering the fields in the AST or we have to keep 144086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // the linear search (yuck and yuck). 144186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor unsigned i = 0; 144286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor for (RecordDecl::field_iterator Field = RD->field_begin(), 144386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor FieldEnd = RD->field_end(); 144486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor Field != FieldEnd; (void)++Field, ++i) { 144586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (*Field == FD) 144686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor break; 144786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor } 144886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 144986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase()); 14505a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } 14515a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) { 14525a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson const Expr *Base = ASE->getBase(); 14535a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 145498be4943e8dc4f3905629a7102668960873cf863Chris Lattner int64_t size = C.getTypeSize(ASE->getType()); 145532442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar size *= ASE->getIdx()->getIntegerConstantExprValue(C).getSExtValue(); 14565a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 14575a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return size + evaluateOffsetOf(C, Base); 14585a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } else if (isa<CompoundLiteralExpr>(E)) 14595a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return 0; 14605a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 14615a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson assert(0 && "Unknown offsetof subexpression!"); 14625a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return 0; 14635a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 14645a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 14655a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlssonint64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const 14665a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson{ 14675a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson assert(Opc == OffsetOf && "Unary operator not offsetof!"); 14685a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 146998be4943e8dc4f3905629a7102668960873cf863Chris Lattner unsigned CharSize = C.Target.getCharWidth(); 14705549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize; 14715a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 14725a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 14730518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redlvoid SizeOfAlignOfExpr::Destroy(ASTContext& C) { 14740518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // Override default behavior of traversing children. If this has a type 14750518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // operand and the type is a variable-length array, the child iteration 14760518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // will iterate over the size expression. However, this expression belongs 14770518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // to the type, not to this, so we don't want to delete it. 14780518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // We still want to delete this expression. 14798189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek if (isArgumentType()) { 14808189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek this->~SizeOfAlignOfExpr(); 14818189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek C.Deallocate(this); 14828189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek } 14830518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl else 14840518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl Expr::Destroy(C); 14859048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar} 14869048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar 1487fb7413f12636cefa9ebec9abf95804f82c305b11Ted Kremenekvoid OverloadExpr::Destroy(ASTContext& C) { 1488fb7413f12636cefa9ebec9abf95804f82c305b11Ted Kremenek DestroyChildren(C); 1489fb7413f12636cefa9ebec9abf95804f82c305b11Ted Kremenek C.Deallocate(SubExprs); 1490fb7413f12636cefa9ebec9abf95804f82c305b11Ted Kremenek this->~OverloadExpr(); 1491fb7413f12636cefa9ebec9abf95804f82c305b11Ted Kremenek C.Deallocate(this); 1492fb7413f12636cefa9ebec9abf95804f82c305b11Ted Kremenek} 1493fb7413f12636cefa9ebec9abf95804f82c305b11Ted Kremenek 149477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 149505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor// DesignatedInitExpr 149605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor//===----------------------------------------------------------------------===// 149705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 149805c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorIdentifierInfo *DesignatedInitExpr::Designator::getFieldName() { 149905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(Kind == FieldDesignator && "Only valid on a field designator"); 150005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (Field.NameOrField & 0x01) 150105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01); 150205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else 150305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return getField()->getIdentifier(); 150405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 150505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 150605c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr * 150705c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr::Create(ASTContext &C, Designator *Designators, 150805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor unsigned NumDesignators, 150905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Expr **IndexExprs, unsigned NumIndexExprs, 151005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor SourceLocation ColonOrEqualLoc, 151105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor bool UsesColonSyntax, Expr *Init) { 1512c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 1513c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff sizeof(Designator) * NumDesignators + 1514c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff sizeof(Stmt *) * (NumIndexExprs + 1), 8); 151505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor DesignatedInitExpr *DIE 151605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor = new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators, 151705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ColonOrEqualLoc, UsesColonSyntax, 151805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor NumIndexExprs + 1); 151905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 152005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor // Fill in the designators 152105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor unsigned ExpectedNumSubExprs = 0; 152205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor designators_iterator Desig = DIE->designators_begin(); 152305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor for (unsigned Idx = 0; Idx < NumDesignators; ++Idx, ++Desig) { 152405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor new (static_cast<void*>(Desig)) Designator(Designators[Idx]); 152505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (Designators[Idx].isArrayDesignator()) 152605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ++ExpectedNumSubExprs; 152705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else if (Designators[Idx].isArrayRangeDesignator()) 152805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ExpectedNumSubExprs += 2; 152905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor } 153005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(ExpectedNumSubExprs == NumIndexExprs && "Wrong number of indices!"); 153105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 153205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor // Fill in the subexpressions, including the initializer expression. 153305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor child_iterator Child = DIE->child_begin(); 153405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor *Child++ = Init; 153505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor for (unsigned Idx = 0; Idx < NumIndexExprs; ++Idx, ++Child) 153605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor *Child = IndexExprs[Idx]; 153705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 153805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return DIE; 153905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 154005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 154105c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorSourceRange DesignatedInitExpr::getSourceRange() const { 154205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor SourceLocation StartLoc; 1543d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner Designator &First = 1544d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner *const_cast<DesignatedInitExpr*>(this)->designators_begin(); 154505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (First.isFieldDesignator()) { 154605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (UsesColonSyntax) 154705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc); 154805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else 154905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc); 155005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor } else 1551d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner StartLoc = 1552d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc); 155305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return SourceRange(StartLoc, getInit()->getSourceRange().getEnd()); 155405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 155505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 1556d603eaa682cecac2c10771a700cb83aa301653b4Chris LattnerDesignatedInitExpr::designators_iterator 1557d603eaa682cecac2c10771a700cb83aa301653b4Chris LattnerDesignatedInitExpr::designators_begin() { 155805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 155905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 156005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return static_cast<Designator*>(static_cast<void*>(Ptr)); 156105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 156205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 156305c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr::designators_iterator DesignatedInitExpr::designators_end() { 156405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return designators_begin() + NumDesignators; 156505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 156605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 156705c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayIndex(const Designator& D) { 156805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayDesignator && "Requires array designator"); 156905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 157005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 157105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 157205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 157305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 157405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 157505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 157605c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) { 157705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayRangeDesignator && 157805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor "Requires array range designator"); 157905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 158005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 158105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 158205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 158305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 158405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 158505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 158605c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) { 158705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayRangeDesignator && 158805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor "Requires array range designator"); 158905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 159005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 159105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 159205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 159305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2)); 159405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 159505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 159605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor//===----------------------------------------------------------------------===// 1597ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek// ExprIterator. 1598ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek//===----------------------------------------------------------------------===// 1599ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek 1600ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 1601ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator*() const { return cast<Expr>(*I); } 1602ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator->() const { return cast<Expr>(*I); } 1603ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator[](size_t idx) const { 1604ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek return cast<Expr>(I[idx]); 1605ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek} 1606ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 1607ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 1608ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek 1609ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek//===----------------------------------------------------------------------===// 161077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// Child Iterators for iterating over subexpressions/substatements 161177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 161277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 161377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// DeclRefExpr 16149ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 16159ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 161677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 16177779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff// ObjCIvarRefExpr 16185549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; } 16195549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; } 16207779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff 1621e3e9add4fd788927df6f545570e7838db59c01d7Steve Naroff// ObjCPropertyRefExpr 16225549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; } 16235549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; } 1624ae7840776d6cd31b4d7a4a345b61bcbb3744df6cSteve Naroff 16255daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian// ObjCKVCRefExpr 16265daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz JahanianStmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; } 16275daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz JahanianStmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; } 16285daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian 1629cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas Gregor// ObjCSuperExpr 1630cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas GregorStmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); } 1631cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas GregorStmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); } 1632cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas Gregor 1633d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner// PredefinedExpr 1634d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); } 1635d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); } 163677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 163777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// IntegerLiteral 16389ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 16399ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 164077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 164177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CharacterLiteral 1642d603eaa682cecac2c10771a700cb83aa301653b4Chris LattnerStmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();} 16439ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 164477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 164577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// FloatingLiteral 16469ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 16479ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 164877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 16495d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner// ImaginaryLiteral 16505549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; } 16515549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; } 16525d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner 165377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// StringLiteral 16549ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 16559ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 165677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 165777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ParenExpr 16585549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_begin() { return &Val; } 16595549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_end() { return &Val+1; } 166077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 166177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// UnaryOperator 16625549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_begin() { return &Val; } 16635549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_end() { return &Val+1; } 166477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 16650518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl// SizeOfAlignOfExpr 16660518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlStmt::child_iterator SizeOfAlignOfExpr::child_begin() { 16670518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // If this is of a type and the type is a VLA type (and not a typedef), the 16680518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // size expression of the VLA needs to be treated as an executable expression. 16690518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // Why isn't this weirdness documented better in StmtIterator? 16700518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (isArgumentType()) { 16710518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (VariableArrayType* T = dyn_cast<VariableArrayType>( 16720518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl getArgumentType().getTypePtr())) 16730518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(T); 16740518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(); 16750518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl } 1676d457589fc69dc7a9c80cd74d317c0b81a35a27c9Sebastian Redl return child_iterator(&Argument.Ex); 16779ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 16780518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlStmt::child_iterator SizeOfAlignOfExpr::child_end() { 16790518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (isArgumentType()) 16800518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(); 1681d457589fc69dc7a9c80cd74d317c0b81a35a27c9Sebastian Redl return child_iterator(&Argument.Ex + 1); 16829ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 168377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 168477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ArraySubscriptExpr 16851237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_begin() { 16865549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 168777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 16881237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_end() { 16895549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 169077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 169177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 169277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CallExpr 16931237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_begin() { 16945549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 169577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 16961237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_end() { 16975549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumArgs+ARGS_START; 169877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 16991237c673c07f9d827129ba02720108816abde562Ted Kremenek 17001237c673c07f9d827129ba02720108816abde562Ted Kremenek// MemberExpr 17015549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_begin() { return &Base; } 17025549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_end() { return &Base+1; } 17031237c673c07f9d827129ba02720108816abde562Ted Kremenek 1704213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman// ExtVectorElementExpr 17055549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; } 17065549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; } 17071237c673c07f9d827129ba02720108816abde562Ted Kremenek 17081237c673c07f9d827129ba02720108816abde562Ted Kremenek// CompoundLiteralExpr 17095549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; } 17105549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; } 17111237c673c07f9d827129ba02720108816abde562Ted Kremenek 17121237c673c07f9d827129ba02720108816abde562Ted Kremenek// CastExpr 17135549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_begin() { return &Op; } 17145549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_end() { return &Op+1; } 17151237c673c07f9d827129ba02720108816abde562Ted Kremenek 17161237c673c07f9d827129ba02720108816abde562Ted Kremenek// BinaryOperator 17171237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_begin() { 17185549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 17191237c673c07f9d827129ba02720108816abde562Ted Kremenek} 17201237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_end() { 17215549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 17221237c673c07f9d827129ba02720108816abde562Ted Kremenek} 17231237c673c07f9d827129ba02720108816abde562Ted Kremenek 17241237c673c07f9d827129ba02720108816abde562Ted Kremenek// ConditionalOperator 17251237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_begin() { 17265549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 17271237c673c07f9d827129ba02720108816abde562Ted Kremenek} 17281237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_end() { 17295549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 17301237c673c07f9d827129ba02720108816abde562Ted Kremenek} 17311237c673c07f9d827129ba02720108816abde562Ted Kremenek 17321237c673c07f9d827129ba02720108816abde562Ted Kremenek// AddrLabelExpr 17339ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 17349ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 17351237c673c07f9d827129ba02720108816abde562Ted Kremenek 17361237c673c07f9d827129ba02720108816abde562Ted Kremenek// StmtExpr 17375549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_begin() { return &SubStmt; } 17385549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; } 17391237c673c07f9d827129ba02720108816abde562Ted Kremenek 17401237c673c07f9d827129ba02720108816abde562Ted Kremenek// TypesCompatibleExpr 17419ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_begin() { 17429ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 17439ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 17449ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek 17459ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_end() { 17469ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 17479ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 17481237c673c07f9d827129ba02720108816abde562Ted Kremenek 17491237c673c07f9d827129ba02720108816abde562Ted Kremenek// ChooseExpr 17505549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; } 17515549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; } 17522d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor 17532d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor// GNUNullExpr 17542d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas GregorStmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); } 17552d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas GregorStmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); } 17561237c673c07f9d827129ba02720108816abde562Ted Kremenek 1757e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman// OverloadExpr 17585549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator OverloadExpr::child_begin() { return &SubExprs[0]; } 17595549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator OverloadExpr::child_end() { return &SubExprs[0]+NumExprs; } 1760e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman 1761d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman// ShuffleVectorExpr 1762d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_begin() { 17635549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 1764d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1765d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_end() { 17665549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumExprs; 1767d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1768d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 17697c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson// VAArgExpr 17705549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_begin() { return &Val; } 17715549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_end() { return &Val+1; } 17727c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 177366b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson// InitListExpr 177466b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_begin() { 17755549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] : 0; 177666b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 177766b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_end() { 17785549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0; 177966b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 178066b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson 17813498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor// DesignatedInitExpr 178205c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorStmt::child_iterator DesignatedInitExpr::child_begin() { 178305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 178405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 178505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 178605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 178705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 178805c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorStmt::child_iterator DesignatedInitExpr::child_end() { 178905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return child_iterator(&*child_begin() + NumSubExprs); 179005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 179105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 17923498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor// ImplicitValueInitExpr 17933498bdb9e9cb300de74c7b51c92608e2902b2348Douglas GregorStmt::child_iterator ImplicitValueInitExpr::child_begin() { 17943498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return child_iterator(); 17953498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor} 17963498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor 17973498bdb9e9cb300de74c7b51c92608e2902b2348Douglas GregorStmt::child_iterator ImplicitValueInitExpr::child_end() { 17983498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return child_iterator(); 17993498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor} 18003498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor 18011237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCStringLiteral 18029ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_begin() { 18039ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18049ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 18059ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_end() { 18069ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18079ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 18081237c673c07f9d827129ba02720108816abde562Ted Kremenek 18091237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCEncodeExpr 18109ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 18119ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 18121237c673c07f9d827129ba02720108816abde562Ted Kremenek 1813b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian// ObjCSelectorExpr 18149ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_begin() { 18159ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18169ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 18179ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_end() { 18189ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18199ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1820b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 1821390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian// ObjCProtocolExpr 18229ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_begin() { 18239ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18249ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 18259ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_end() { 18269ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18279ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1828390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian 1829563477da25f824e37c535131695dc4dc9b68c465Steve Naroff// ObjCMessageExpr 1830ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted KremenekStmt::child_iterator ObjCMessageExpr::child_begin() { 18315549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START; 1832563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1833563477da25f824e37c535131695dc4dc9b68c465Steve NaroffStmt::child_iterator ObjCMessageExpr::child_end() { 18345549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+ARGS_START+getNumArgs(); 1835563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1836563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 18374eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff// Blocks 183856ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt::child_iterator BlockExpr::child_begin() { return child_iterator(); } 183956ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt::child_iterator BlockExpr::child_end() { return child_iterator(); } 18404eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff 18419da13f9ddb2567e36f4bbee7b3c32f54aeb76d5bTed KremenekStmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();} 18429da13f9ddb2567e36f4bbee7b3c32f54aeb76d5bTed KremenekStmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); } 1843