Expr.cpp revision 44e35f7b2b5da1eb338639e46bf0b5522e75c5f3
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 29a135fb43eb94524a6529768596a4533eed9aa70dAnders CarlssonIntegerLiteral* IntegerLiteral::Clone(ASTContext &C) const { 30a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson return new (C) IntegerLiteral(Value, getType(), Loc); 31a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson} 32a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson 33da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// getValueAsApproximateDouble - This returns the value as an inaccurate 34da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// double. Note that this may cause loss of precision, but is useful for 35da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// debugging dumps, etc. 36da8249e57f3badecf925571881fe57243935c6c1Chris Lattnerdouble FloatingLiteral::getValueAsApproximateDouble() const { 37da8249e57f3badecf925571881fe57243935c6c1Chris Lattner llvm::APFloat V = getValue(); 38ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen bool ignored; 39ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 40ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen &ignored); 41da8249e57f3badecf925571881fe57243935c6c1Chris Lattner return V.convertToDouble(); 42da8249e57f3badecf925571881fe57243935c6c1Chris Lattner} 43da8249e57f3badecf925571881fe57243935c6c1Chris Lattner 442085fd6cd22ec5c268175251db10d7c60caf7aaaChris LattnerStringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData, 452085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner unsigned ByteLength, bool Wide, 462085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner QualType Ty, 47a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson const SourceLocation *Loc, 48a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson unsigned NumStrs) { 492085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner // Allocate enough space for the StringLiteral plus an array of locations for 502085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner // any concatenated string tokens. 512085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner void *Mem = C.Allocate(sizeof(StringLiteral)+ 522085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner sizeof(SourceLocation)*(NumStrs-1), 532085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner llvm::alignof<StringLiteral>()); 542085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner StringLiteral *SL = new (Mem) StringLiteral(Ty); 552085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner 565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // OPTIMIZE: could allocate this appended to the StringLiteral. 572085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner char *AStrData = new (C, 1) char[ByteLength]; 582085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner memcpy(AStrData, StrData, ByteLength); 592085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->StrData = AStrData; 602085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->ByteLength = ByteLength; 612085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->IsWide = Wide; 622085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->TokLocs[0] = Loc[0]; 632085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->NumConcatenated = NumStrs; 645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 65726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner if (NumStrs != 1) 662085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1)); 672085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner return SL; 68726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner} 69726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner 70a135fb43eb94524a6529768596a4533eed9aa70dAnders CarlssonStringLiteral* StringLiteral::Clone(ASTContext &C) const { 71a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson return Create(C, StrData, ByteLength, IsWide, getType(), 72a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson TokLocs, NumConcatenated); 73a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson} 74726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner 756e94ef5696cfb005d3fc7bbac8dcf7690b64f0a5Ted Kremenekvoid StringLiteral::Destroy(ASTContext &C) { 768189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek C.Deallocate(const_cast<char*>(StrData)); 77353ffceafc6bcebd5592cb9d93ea3f9242e5370aTed Kremenek this->~StringLiteral(); 78353ffceafc6bcebd5592cb9d93ea3f9242e5370aTed Kremenek C.Deallocate(this); 795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "sizeof" or "[pre]++". 835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *UnaryOperator::getOpcodeStr(Opcode Op) { 845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown unary operator"); 865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostInc: return "++"; 875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostDec: return "--"; 885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreInc: return "++"; 895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreDec: return "--"; 905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddrOf: return "&"; 915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Deref: return "*"; 925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Plus: return "+"; 935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Minus: return "-"; 945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Not: return "~"; 955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LNot: return "!"; 965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Real: return "__real"; 975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Imag: return "__imag"; 985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Extension: return "__extension__"; 9973d0d4fac161ed12926e010dcf8b448a8de6a2ecChris Lattner case OffsetOf: return "__builtin_offsetof"; 1005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 103bc736fceca6f0bca31d16003a7587857190408fbDouglas GregorUnaryOperator::Opcode 104bc736fceca6f0bca31d16003a7587857190408fbDouglas GregorUnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) { 105bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor switch (OO) { 106bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor default: assert(false && "No unary operator for overloaded function"); 107b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_PlusPlus: return Postfix ? PostInc : PreInc; 108b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_MinusMinus: return Postfix ? PostDec : PreDec; 109b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Amp: return AddrOf; 110b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Star: return Deref; 111b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Plus: return Plus; 112b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Minus: return Minus; 113b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Tilde: return Not; 114b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Exclaim: return LNot; 115bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor } 116bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor} 117bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor 118bc736fceca6f0bca31d16003a7587857190408fbDouglas GregorOverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) { 119bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor switch (Opc) { 120bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case PostInc: case PreInc: return OO_PlusPlus; 121bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case PostDec: case PreDec: return OO_MinusMinus; 122bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case AddrOf: return OO_Amp; 123bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case Deref: return OO_Star; 124bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case Plus: return OO_Plus; 125bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case Minus: return OO_Minus; 126bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case Not: return OO_Tilde; 127bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case LNot: return OO_Exclaim; 128bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor default: return OO_None; 129bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor } 130bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor} 131bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor 132bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor 1335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Postfix Operators. 1355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 137668bf91d31265b6ea8c3eb854ba450857701f269Ted KremenekCallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args, 1388189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek unsigned numargs, QualType t, SourceLocation rparenloc) 139898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor : Expr(SC, t, 140898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 141d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 142898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor NumArgs(numargs) { 143668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 144668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek SubExprs = new (C) Stmt*[numargs+1]; 145b4609806e9232593ece09ce08b630836e825865cDouglas Gregor SubExprs[FN] = fn; 146b4609806e9232593ece09ce08b630836e825865cDouglas Gregor for (unsigned i = 0; i != numargs; ++i) 147b4609806e9232593ece09ce08b630836e825865cDouglas Gregor SubExprs[i+ARGS_START] = args[i]; 148668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 149b4609806e9232593ece09ce08b630836e825865cDouglas Gregor RParenLoc = rparenloc; 150b4609806e9232593ece09ce08b630836e825865cDouglas Gregor} 151e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman 152668bf91d31265b6ea8c3eb854ba450857701f269Ted KremenekCallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs, 153668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek QualType t, SourceLocation rparenloc) 154898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor : Expr(CallExprClass, t, 155898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 156d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 157898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor NumArgs(numargs) { 158668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 159668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek SubExprs = new (C) Stmt*[numargs+1]; 16077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[FN] = fn; 1615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != numargs; ++i) 16277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[i+ARGS_START] = args[i]; 163668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 1645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RParenLoc = rparenloc; 1655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 167668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenekvoid CallExpr::Destroy(ASTContext& C) { 168668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek DestroyChildren(C); 169668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek if (SubExprs) C.Deallocate(SubExprs); 170668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek this->~CallExpr(); 171668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek C.Deallocate(this); 172668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek} 173668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 174d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// setNumArgs - This changes the number of arguments present in this call. 175d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// Any orphaned expressions are deleted by this, and any new operands are set 176d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// to null. 1778189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenekvoid CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) { 178d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // No change, just return. 179d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs == getNumArgs()) return; 180d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 181d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // If shrinking # arguments, just delete the extras and forgot them. 182d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs < getNumArgs()) { 183d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 1848189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek getArg(i)->Destroy(C); 185d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 186d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner return; 187d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner } 188d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 189d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Otherwise, we are growing the # arguments. New an bigger argument array. 1905549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek Stmt **NewSubExprs = new Stmt*[NumArgs+1]; 191d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Copy over args. 192d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 193d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = SubExprs[i]; 194d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Null out new args. 195d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 196d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = 0; 197d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 1988189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek delete [] SubExprs; 199d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner SubExprs = NewSubExprs; 200d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 201d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner} 202d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 203cb888967400a03504c88acedd5248d6778a82f46Chris Lattner/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If 204cb888967400a03504c88acedd5248d6778a82f46Chris Lattner/// not, return 0. 2053c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregorunsigned CallExpr::isBuiltinCall(ASTContext &Context) const { 206c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // All simple function calls (e.g. func()) are implicitly cast to pointer to 207c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // function. As a result, we try and obtain the DeclRefExpr from the 208c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // ImplicitCastExpr. 209c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 210c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 211cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 212cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 213c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 214c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!DRE) 215cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 216cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 217bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 218bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson if (!FDecl) 219cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 220cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 2214fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor if (!FDecl->getIdentifier()) 2224fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor return 0; 2234fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor 2243c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor return FDecl->getBuiltinID(Context); 225cb888967400a03504c88acedd5248d6778a82f46Chris Lattner} 226bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson 227cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 2285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 2295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "<<=". 2305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *BinaryOperator::getOpcodeStr(Opcode Op) { 2315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 232baf534875ed0a55c6342636ff3f4602b8ac22b69Douglas Gregor case PtrMemD: return ".*"; 233baf534875ed0a55c6342636ff3f4602b8ac22b69Douglas Gregor case PtrMemI: return "->*"; 2345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Mul: return "*"; 2355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Div: return "/"; 2365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Rem: return "%"; 2375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Add: return "+"; 2385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Sub: return "-"; 2395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shl: return "<<"; 2405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shr: return ">>"; 2415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LT: return "<"; 2425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GT: return ">"; 2435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LE: return "<="; 2445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GE: return ">="; 2455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case EQ: return "=="; 2465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case NE: return "!="; 2475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case And: return "&"; 2485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Xor: return "^"; 2495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Or: return "|"; 2505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LAnd: return "&&"; 2515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LOr: return "||"; 2525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Assign: return "="; 2535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MulAssign: return "*="; 2545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DivAssign: return "/="; 2555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case RemAssign: return "%="; 2565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddAssign: return "+="; 2575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SubAssign: return "-="; 2585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShlAssign: return "<<="; 2595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShrAssign: return ">>="; 2605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AndAssign: return "&="; 2615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case XorAssign: return "^="; 2625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case OrAssign: return "|="; 2635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Comma: return ","; 2645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 265baf534875ed0a55c6342636ff3f4602b8ac22b69Douglas Gregor 266baf534875ed0a55c6342636ff3f4602b8ac22b69Douglas Gregor return ""; 2675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 269063daf6e196c51f162e0485478355d8e280eef5cDouglas GregorBinaryOperator::Opcode 270063daf6e196c51f162e0485478355d8e280eef5cDouglas GregorBinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) { 271063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor switch (OO) { 272b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner default: assert(false && "Not an overloadable binary operator"); 273063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Plus: return Add; 274063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Minus: return Sub; 275063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Star: return Mul; 276063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Slash: return Div; 277063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Percent: return Rem; 278063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Caret: return Xor; 279063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Amp: return And; 280063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Pipe: return Or; 281063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Equal: return Assign; 282063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Less: return LT; 283063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Greater: return GT; 284063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_PlusEqual: return AddAssign; 285063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_MinusEqual: return SubAssign; 286063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_StarEqual: return MulAssign; 287063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_SlashEqual: return DivAssign; 288063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_PercentEqual: return RemAssign; 289063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_CaretEqual: return XorAssign; 290063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_AmpEqual: return AndAssign; 291063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_PipeEqual: return OrAssign; 292063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_LessLess: return Shl; 293063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_GreaterGreater: return Shr; 294063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_LessLessEqual: return ShlAssign; 295063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_GreaterGreaterEqual: return ShrAssign; 296063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_EqualEqual: return EQ; 297063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_ExclaimEqual: return NE; 298063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_LessEqual: return LE; 299063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_GreaterEqual: return GE; 300063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_AmpAmp: return LAnd; 301063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_PipePipe: return LOr; 302063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Comma: return Comma; 303063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_ArrowStar: return PtrMemI; 304063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor } 305063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor} 306063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor 307063daf6e196c51f162e0485478355d8e280eef5cDouglas GregorOverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) { 308063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor static const OverloadedOperatorKind OverOps[] = { 309063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor /* .* Cannot be overloaded */OO_None, OO_ArrowStar, 310063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Star, OO_Slash, OO_Percent, 311063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Plus, OO_Minus, 312063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_LessLess, OO_GreaterGreater, 313063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual, 314063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_EqualEqual, OO_ExclaimEqual, 315063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Amp, 316063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Caret, 317063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Pipe, 318063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_AmpAmp, 319063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_PipePipe, 320063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Equal, OO_StarEqual, 321063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_SlashEqual, OO_PercentEqual, 322063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_PlusEqual, OO_MinusEqual, 323063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_LessLessEqual, OO_GreaterGreaterEqual, 324063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_AmpEqual, OO_CaretEqual, 325063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_PipeEqual, 326063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Comma 327063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor }; 328063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor return OverOps[Opc]; 329063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor} 330063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor 33166b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonInitListExpr::InitListExpr(SourceLocation lbraceloc, 332418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner Expr **initExprs, unsigned numInits, 3334c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor SourceLocation rbraceloc) 334c5ae899b4bbf65488445316c63168079177db0edSteve Naroff : Expr(InitListExprClass, QualType()), 3350bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0), 336a9c878086036de36482cc21e35a33cabe9699b0aDouglas Gregor UnionFieldInit(0), HadArrayRangeDesignator(false) { 337418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner 338418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits); 33966b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 3405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 341fa2192042f223b5122a9e17719930f77634fd31fDouglas Gregorvoid InitListExpr::reserveInits(unsigned NumInits) { 342fa2192042f223b5122a9e17719930f77634fd31fDouglas Gregor if (NumInits > InitExprs.size()) 343fa2192042f223b5122a9e17719930f77634fd31fDouglas Gregor InitExprs.reserve(NumInits); 344fa2192042f223b5122a9e17719930f77634fd31fDouglas Gregor} 345fa2192042f223b5122a9e17719930f77634fd31fDouglas Gregor 3464c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregorvoid InitListExpr::resizeInits(ASTContext &Context, unsigned NumInits) { 347d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner for (unsigned Idx = NumInits, LastIdx = InitExprs.size(); 348f592c929bd1f083abcc8199b24bb825fdd28df1cDaniel Dunbar Idx < LastIdx; ++Idx) 349068636800594844c53fba0bc871c579745757d0eDouglas Gregor InitExprs[Idx]->Destroy(Context); 3504c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.resize(NumInits, 0); 3514c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor} 3524c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 3534c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas GregorExpr *InitListExpr::updateInit(unsigned Init, Expr *expr) { 3544c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor if (Init >= InitExprs.size()) { 3554c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.insert(InitExprs.end(), Init - InitExprs.size() + 1, 0); 3564c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.back() = expr; 3574c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor return 0; 3584c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor } 3594c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 3604c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor Expr *Result = cast_or_null<Expr>(InitExprs[Init]); 3614c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs[Init] = expr; 3624c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor return Result; 3634c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor} 3644c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 365bfdcae678d44906293e21c0cddc6537f3ee8b5a4Steve Naroff/// getFunctionType - Return the underlying function type for this block. 3664eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff/// 3674eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroffconst FunctionType *BlockExpr::getFunctionType() const { 3684eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff return getType()->getAsBlockPointerType()-> 3694eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff getPointeeType()->getAsFunctionType(); 3704eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff} 3714eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff 37256ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffSourceLocation BlockExpr::getCaretLocation() const { 37356ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff return TheBlock->getCaretLocation(); 37456ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff} 37556ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroffconst Stmt *BlockExpr::getBody() const { return TheBlock->getBody(); } 37656ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt *BlockExpr::getBody() { return TheBlock->getBody(); } 37756ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff 37856ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff 3795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 3805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Generic Expression Routines 3815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 3825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 383026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// isUnusedResultAWarning - Return true if this immediate expression should 384026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// be warned about if the result is unused. If so, fill in Loc and Ranges 385026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// with location to warn on and the source range[s] to report with the 386026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// warning. 387026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattnerbool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1, 388026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner SourceRange &R2) const { 3895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 3905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 391026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = getExprLoc(); 392026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = getSourceRange(); 393026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 3945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: 395026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<ParenExpr>(this)->getSubExpr()-> 396026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner isUnusedResultAWarning(Loc, R1, R2); 3975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperatorClass: { 3985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const UnaryOperator *UO = cast<UnaryOperator>(this); 3995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (UO->getOpcode()) { 401026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner default: break; 4025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostInc: 4035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostDec: 4045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PreInc: 405026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner case UnaryOperator::PreDec: // ++/-- 406026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; // Not a warning. 4075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Deref: 4085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Dereferencing a volatile pointer is a side-effect. 409026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 410026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 411026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner break; 4125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Real: 4135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Imag: 4145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // accessing a piece of a volatile complex is a side-effect. 415026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (UO->getSubExpr()->getType().isVolatileQualified()) 416026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 417026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner break; 4185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 419026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 4205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 421026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = UO->getOperatorLoc(); 422026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = UO->getSubExpr()->getSourceRange(); 423026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 4245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 425e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner case BinaryOperatorClass: { 426026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const BinaryOperator *BO = cast<BinaryOperator>(this); 427026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // Consider comma to have side effects if the LHS or RHS does. 428026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (BO->getOpcode() == BinaryOperator::Comma) 429026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2) || 430026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2); 431e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner 432026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (BO->isAssignmentOp()) 433026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 434026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = BO->getOperatorLoc(); 435026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = BO->getLHS()->getSourceRange(); 436026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = BO->getRHS()->getSourceRange(); 437026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 438e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner } 439eb14fe839ec24c2ca14e5f094be147a34e3d3339Chris Lattner case CompoundAssignOperatorClass: 440026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 4415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 442ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian case ConditionalOperatorClass: { 443026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // The condition must be evaluated, but if either the LHS or RHS is a 444026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // warning, warn about them. 445ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 446befbcf4e02756f252d1263774ef2249f0921c1c9Mike Stump if (Exp->getLHS() && Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2)) 447026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 448026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2); 449ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian } 450ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian 4515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MemberExprClass: 452026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If the base pointer or element is to a volatile pointer/field, accessing 453026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // it is a side effect. 454026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 455026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 456026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<MemberExpr>(this)->getMemberLoc(); 457026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = SourceRange(Loc, Loc); 458026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = cast<MemberExpr>(this)->getBase()->getSourceRange(); 459026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 460026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 4615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: 4625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the base pointer or element is to a volatile pointer/field, accessing 463026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // it is a side effect. 464026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 465026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 466026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc(); 467026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange(); 468026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange(); 469026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 470211f6adf1301a1461015fb6cb08a05f0a35b65f3Eli Friedman 4715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case CallExprClass: 472026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner case CXXOperatorCallExprClass: { 473026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If this is a direct call, get the callee. 474026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const CallExpr *CE = cast<CallExpr>(this); 475026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const Expr *CalleeExpr = CE->getCallee()->IgnoreParenCasts(); 476026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (const DeclRefExpr *CalleeDRE = dyn_cast<DeclRefExpr>(CalleeExpr)) { 477026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If the callee has attribute pure, const, or warn_unused_result, warn 478026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // about it. void foo() { strlen("bar"); } should warn. 479026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CalleeDRE->getDecl())) 480026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (FD->getAttr<WarnUnusedResultAttr>() || 481026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) { 482026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = CE->getCallee()->getLocStart(); 483026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = CE->getCallee()->getSourceRange(); 484026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 485026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (unsigned NumArgs = CE->getNumArgs()) 486026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = SourceRange(CE->getArg(0)->getLocStart(), 487026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner CE->getArg(NumArgs-1)->getLocEnd()); 488026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 489026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 490026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 491026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 492026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 493a9c01021724b9b546d282b8609cbe559734812ecChris Lattner case ObjCMessageExprClass: 494026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 495611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner case StmtExprClass: { 496611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // Statement exprs don't logically have side effects themselves, but are 497611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // sometimes used in macros in ways that give them a type that is unused. 498611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // For example ({ blah; foo(); }) will end up with a type if foo has a type. 499611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // however, if the result of the stmt expr is dead, we don't want to emit a 500611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // warning. 501611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 502611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (!CS->body_empty()) 503611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 504026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return E->isUnusedResultAWarning(Loc, R1, R2); 505026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 506026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<StmtExpr>(this)->getLParenLoc(); 507026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = getSourceRange(); 508026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 509611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner } 5106eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 511026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If this is a cast to void, check the operand. Otherwise, the result of 512026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // the cast is unused. 513026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType()->isVoidType()) 514026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CastExpr>(this)->getSubExpr()->isUnusedResultAWarning(Loc, 515026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1, R2); 516026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<CStyleCastExpr>(this)->getLParenLoc(); 517026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange(); 518026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 519987a14bf5883ef6e5d07f1c83eb6d41a8212a78cArgyrios Kyrtzidis case CXXFunctionalCastExprClass: 5205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is a cast to void, check the operand. Otherwise, the result of 5215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the cast is unused. 5225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (getType()->isVoidType()) 523026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CastExpr>(this)->getSubExpr()->isUnusedResultAWarning(Loc, 524026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1, R2); 525026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc(); 526026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange(); 527026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 528026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 5294be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman case ImplicitCastExprClass: 5304be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman // Check the operand, since implicit casts are inserted by Sema 531026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<ImplicitCastExpr>(this) 532026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 5334be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman 53404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 535026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CXXDefaultArgExpr>(this) 536026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner ->getExpr()->isUnusedResultAWarning(Loc, R1, R2); 5374c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl 5384c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl case CXXNewExprClass: 5394c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl // FIXME: In theory, there might be new expressions that don't have side 5404c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl // effects (e.g. a placement new with an uninitialized POD). 5414c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl case CXXDeleteExprClass: 542026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 5434c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl } 5445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 546ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor/// DeclCanBeLvalue - Determine whether the given declaration can be 547ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor/// an lvalue. This is a helper routine for isLvalue. 548ba7e210a999275695f58be03ef402758cfec3635Douglas Gregorstatic bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) { 54972c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor // C++ [temp.param]p6: 55072c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor // A non-type non-reference template-parameter is not an lvalue. 55172c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor if (const NonTypeTemplateParmDecl *NTTParm 55272c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Decl)) 55372c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor return NTTParm->getType()->isReferenceType(); 55472c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor 55544b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) || 556ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor // C++ 3.10p2: An lvalue refers to an object or function. 557ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor (Ctx.getLangOptions().CPlusPlus && 558ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl))); 559ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor} 560ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor 5615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 5625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// incomplete type other than void. Nonarray expressions that can be lvalues: 5635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - name, where name must be a variable 5645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e[i] 5655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - (e), where e must be an lvalue 5665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e.name, where e must be an lvalue 5675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e->name 5685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - *e, the type of e cannot be a function type 5695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - string-constant 5707da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 57108ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling/// - reference type [C++ [expr]] 5725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 57328be73f74c9e241a23ea24fe5756623de6bf1084Chris LattnerExpr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const { 57498cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor // first, check the type (C99 6.3.2.1). Expressions with function 57598cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor // type in C are not lvalues, but they can be lvalues in C++. 57698cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor if (!Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 5775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_NotObjectType; 5785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 579acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff // Allow qualified void which is an incomplete type other than void (yuck). 58028be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers()) 581acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff return LV_IncompleteVoidType; 582acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff 5837c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl assert(!TR->isReferenceType() && "Expressions can't have reference type."); 58408ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling 5855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the type looks fine, now check the expression 5865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 587eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case StringLiteralClass: // C99 6.5.1p4 588eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case ObjCEncodeExprClass: // @encode behaves like its string in every way. 5897323a6297edad643c202594dcf3d9a174de96ca6Anders Carlsson return LV_Valid; 5905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 5915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // For vectors, make sure base is an lvalue (i.e. not a function call). 5925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 59328be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx); 5945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 5951a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case DeclRefExprClass: 5961a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case QualifiedDeclRefExprClass: { // C99 6.5.1p2 597ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl(); 598ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor if (DeclCanBeLvalue(RefdDecl, Ctx)) 5995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 6005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 6014111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner } 602dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff case BlockDeclRefExprClass: { 603dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 6044f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (isa<VarDecl>(BDR->getDecl())) 605dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff return LV_Valid; 606dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff break; 607dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff } 60886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor case MemberExprClass: { 6095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const MemberExpr *m = cast<MemberExpr>(this); 61086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4: 61186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor NamedDecl *Member = m->getMemberDecl(); 61286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // C++ [expr.ref]p4: 61386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // If E2 is declared to have type "reference to T", then E1.E2 61486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // is an lvalue. 61586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (ValueDecl *Value = dyn_cast<ValueDecl>(Member)) 61686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (Value->getType()->isReferenceType()) 61786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_Valid; 61886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 61986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a static data member [...] then E1.E2 is an lvalue. 6202d2e9cfdc1dbb6e4a22f8c0b1abcd30437e3795dDouglas Gregor if (isa<VarDecl>(Member) && Member->getDeclContext()->isRecord()) 62186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_Valid; 62286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 62386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a non-static data member [...]. If E1 is an 62486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // lvalue, then E1.E2 is an lvalue. 62586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (isa<FieldDecl>(Member)) 62686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 62786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 62886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If it refers to a static member function [...], then 62986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // E1.E2 is an lvalue. 63086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- Otherwise, if E1.E2 refers to a non-static member 63186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // function [...], then E1.E2 is not an lvalue. 63286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) 63386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return Method->isStatic()? LV_Valid : LV_MemberFunction; 63486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 63586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a member enumerator [...], the expression E1.E2 63686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // is not an lvalue. 63786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (isa<EnumConstantDecl>(Member)) 63886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_InvalidExpression; 63986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 64086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // Not an lvalue. 64186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_InvalidExpression; 64286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor } 64386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 64486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // C99 6.5.2.3p4 64528be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 646fdd75663fffeb2058a7847975e50837e61200593Anton Korobeynikov } 6477da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner case UnaryOperatorClass: 6485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 6497da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner return LV_Valid; // C99 6.5.3p4 6507da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner 6517da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 652baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag || 653baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension) 65428be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU. 65574253736184c0717a0649922551bf9d8b6815651Douglas Gregor 65674253736184c0717a0649922551bf9d8b6815651Douglas Gregor if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1 65774253736184c0717a0649922551bf9d8b6815651Douglas Gregor (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc || 65874253736184c0717a0649922551bf9d8b6815651Douglas Gregor cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec)) 65974253736184c0717a0649922551bf9d8b6815651Douglas Gregor return LV_Valid; 6605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 661eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case ImplicitCastExprClass: 662eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid 663eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor : LV_InvalidExpression; 6645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: // C99 6.5.1p5 66528be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx); 666eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case BinaryOperatorClass: 667eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case CompoundAssignOperatorClass: { 668eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor const BinaryOperator *BinOp = cast<BinaryOperator>(this); 669337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor 670337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1 671337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor BinOp->getOpcode() == BinaryOperator::Comma) 672337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor return BinOp->getRHS()->isLvalue(Ctx); 673337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor 674224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl // C++ [expr.mptr.oper]p6 675224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl if ((BinOp->getOpcode() == BinaryOperator::PtrMemD || 676224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl BinOp->getOpcode() == BinaryOperator::PtrMemI) && 677224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl !BinOp->getType()->isFunctionType()) 678224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl return BinOp->getLHS()->isLvalue(Ctx); 679224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl 680bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor if (!BinOp->isAssignmentOp()) 681eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor return LV_InvalidExpression; 682eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor 683bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor if (Ctx.getLangOptions().CPlusPlus) 684bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // C++ [expr.ass]p1: 685bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // The result of an assignment operation [...] is an lvalue. 686bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor return LV_Valid; 687bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor 688bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor 689bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // C99 6.5.16: 690bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // An assignment expression [...] is not an lvalue. 691bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor return LV_InvalidExpression; 692eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor } 693b4609806e9232593ece09ce08b630836e825865cDouglas Gregor case CallExprClass: 69488a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor case CXXOperatorCallExprClass: 69588a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor case CXXMemberCallExprClass: { 6967c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // C++0x [expr.call]p10 6979d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // A function call is an lvalue if and only if the result type 6987c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // is an lvalue reference. 69927c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor QualType CalleeType = cast<CallExpr>(this)->getCallee()->getType(); 7009d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor if (const PointerType *FnTypePtr = CalleeType->getAsPointerType()) 70188a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor CalleeType = FnTypePtr->getPointeeType(); 70288a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor if (const FunctionType *FnType = CalleeType->getAsFunctionType()) 7037c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (FnType->getResultType()->isLValueReferenceType()) 70488a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor return LV_Valid; 7057c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 7069d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor break; 7079d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor } 708e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff case CompoundLiteralExprClass: // C99 6.5.2.5p5 709e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff return LV_Valid; 710670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner case ChooseExprClass: 711670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner // __builtin_choose_expr is an lvalue if the selected operand is. 7127976932a1c256d447316ffac58e9821417725e34Eli Friedman return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)->isLvalue(Ctx); 713213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case ExtVectorElementExprClass: 714213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 715fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_DuplicateVectorComponents; 716fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_Valid; 717027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 718027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff return LV_Valid; 719799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff case ObjCPropertyRefExprClass: // FIXME: check if read-only property. 720799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff return LV_Valid; 7215daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian case ObjCKVCRefExprClass: // FIXME: check if read-only property. 722670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner return LV_Valid; 723d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 724796da18402f286b897782a298ae3b20c459c102eDouglas Gregor return LV_Valid; 7259d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case VAArgExprClass: 726adadd8db2aba32f689e7057d8b7ce004be30685bDaniel Dunbar return LV_NotObjectType; 72704421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 72828be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx); 72924b41fa8239c63b9eb570d3e83c4a82840656a65Argyrios Kyrtzidis case CXXConditionDeclExprClass: 73024b41fa8239c63b9eb570d3e83c4a82840656a65Argyrios Kyrtzidis return LV_Valid; 7316eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 7329d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXFunctionalCastExprClass: 7339d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXStaticCastExprClass: 7349d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXDynamicCastExprClass: 7359d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXReinterpretCastExprClass: 7369d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXConstCastExprClass: 7379d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // The result of an explicit cast is an lvalue if the type we are 7387c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // casting to is an lvalue reference type. See C++ [expr.cast]p1, 7399d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2, 7409d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1. 7417c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()-> 7427c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl isLValueReferenceType()) 7439d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor return LV_Valid; 7449d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor break; 745c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl case CXXTypeidExprClass: 746c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ... 747c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl return LV_Valid; 7485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 7495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 7505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 7515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_InvalidExpression; 7525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 7535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 7555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// does not have an incomplete type, does not have a const-qualified type, and 7565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// if it is a structure or union, does not have any member (including, 7575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// recursively, any member or element of all contained aggregates or unions) 7585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// with a const-qualified type. 75944e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel DunbarExpr::isModifiableLvalueResult 76044e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel DunbarExpr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const { 76128be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner isLvalueResult lvalResult = isLvalue(Ctx); 7625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (lvalResult) { 764ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor case LV_Valid: 765ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor // C++ 3.10p11: Functions cannot be modified, but pointers to 766ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor // functions can be modifiable. 767ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 768ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor return MLV_NotObjectType; 769ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor break; 770ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor 7715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_NotObjectType: return MLV_NotObjectType; 7725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 773fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 774ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner case LV_InvalidExpression: 775ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // If the top level is a C-style cast, and the subexpression is a valid 776ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // lvalue, then this is probably a use of the old-school "cast as lvalue" 777ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // GCC extension. We don't support it, but we want to produce good 778ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // diagnostics when it happens so that the user knows why. 77944e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(IgnoreParens())) { 78044e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) { 78144e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar if (Loc) 78244e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar *Loc = CE->getLParenLoc(); 783ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner return MLV_LValueCast; 78444e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar } 78544e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar } 786ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner return MLV_InvalidExpression; 78786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor case LV_MemberFunction: return MLV_MemberFunction; 7885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 78904831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman 79004831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman // The following is illegal: 79104831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman // void takeclosure(void (^C)(void)); 79204831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman // void func() { int x = 1; takeclosure(^{ x = 7; }); } 79304831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman // 7947fd0995e993438a3a1f5408d8549b3af0009ff30Chris Lattner if (isa<BlockDeclRefExpr>(this)) { 79504831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 79604831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl())) 79704831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman return MLV_NotBlockQualified; 79804831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman } 79904831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman 800c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType CT = Ctx.getCanonicalType(getType()); 801c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 802c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT.isConstQualified()) 8035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 804c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isArrayType()) 8055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ArrayType; 806c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isIncompleteType()) 8075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_IncompleteType; 8085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 809c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const RecordType *r = CT->getAsRecordType()) { 8105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (r->hasConstFields()) 8115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 8125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 813d1fa6449e9dbdd667466e9e1e971aa17c9793e8aFariborz Jahanian 814ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian // Assigning to an 'implicit' property? 8157fd0995e993438a3a1f5408d8549b3af0009ff30Chris Lattner else if (isa<ObjCKVCRefExpr>(this)) { 816ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian const ObjCKVCRefExpr* KVCExpr = cast<ObjCKVCRefExpr>(this); 817ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian if (KVCExpr->getSetterMethod() == 0) 818ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian return MLV_NoSetterProperty; 819ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian } 8205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_Valid; 8215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 8225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8232e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek/// hasGlobalStorage - Return true if this expression has static storage 8244cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// duration. This means that the address of this expression is a link-time 8254cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// constant. 8262e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenekbool Expr::hasGlobalStorage() const { 8271d09ecca892185ba067e47ba879f424de59950efChris Lattner switch (getStmtClass()) { 8281d09ecca892185ba067e47ba879f424de59950efChris Lattner default: 8291d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 8304cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ParenExprClass: 8312e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage(); 8324cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ImplicitCastExprClass: 8332e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage(); 834e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff case CompoundLiteralExprClass: 835e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff return cast<CompoundLiteralExpr>(this)->isFileScope(); 8361a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case DeclRefExprClass: 8371a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case QualifiedDeclRefExprClass: { 8381d09ecca892185ba067e47ba879f424de59950efChris Lattner const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 8391d09ecca892185ba067e47ba879f424de59950efChris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 8402e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return VD->hasGlobalStorage(); 84163f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon if (isa<FunctionDecl>(D)) 84263f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon return true; 8431d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 8441d09ecca892185ba067e47ba879f424de59950efChris Lattner } 845fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner case MemberExprClass: { 8461d09ecca892185ba067e47ba879f424de59950efChris Lattner const MemberExpr *M = cast<MemberExpr>(this); 8472e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return !M->isArrow() && M->getBase()->hasGlobalStorage(); 848fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner } 8494cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ArraySubscriptExprClass: 8502e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage(); 851d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 852fa28b30d5a1e93e5263be33e343532b900d2c643Chris Lattner return true; 85304421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 85404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage(); 8551d09ecca892185ba067e47ba879f424de59950efChris Lattner } 8561d09ecca892185ba067e47ba879f424de59950efChris Lattner} 8571d09ecca892185ba067e47ba879f424de59950efChris Lattner 85844baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian/// isOBJCGCCandidate - Check if an expression is objc gc'able. 85944baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian/// 86044baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanianbool Expr::isOBJCGCCandidate() const { 86144baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian switch (getStmtClass()) { 86244baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian default: 86344baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return false; 86444baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ObjCIvarRefExprClass: 86544baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return true; 866207c5210eb0ac7b632609f0c006eb97ef2738948Fariborz Jahanian case Expr::UnaryOperatorClass: 867207c5210eb0ac7b632609f0c006eb97ef2738948Fariborz Jahanian return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate(); 86844baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ParenExprClass: 86944baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate(); 87044baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ImplicitCastExprClass: 87144baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(); 87244baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case DeclRefExprClass: 87344baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case QualifiedDeclRefExprClass: { 87444baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 87544baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 87644baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return VD->hasGlobalStorage(); 87744baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return false; 87844baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian } 87944baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case MemberExprClass: { 88044baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian const MemberExpr *M = cast<MemberExpr>(this); 88144baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return !M->isArrow() && M->getBase()->isOBJCGCCandidate(); 88244baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian } 88344baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ArraySubscriptExprClass: 88444baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate(); 88544baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian } 88644baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian} 8874e99a5fc3b203397a91136c6e695e405fb8fc606Ted KremenekExpr* Expr::IgnoreParens() { 8884e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek Expr* E = this; 8894e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 8904e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek E = P->getSubExpr(); 8914e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 8924e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek return E; 8934e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek} 8944e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 89556f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 89656f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// or CastExprs or ImplicitCastExprs, returning their operand. 89756f349400c5932a196509c0480ff6f99a9a0b48fChris LattnerExpr *Expr::IgnoreParenCasts() { 89856f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner Expr *E = this; 89956f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner while (true) { 90056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 90156f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 90256f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else if (CastExpr *P = dyn_cast<CastExpr>(E)) 90356f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 90456f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else 90556f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner return E; 90656f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner } 90756f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner} 90856f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner 909ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the 910ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner/// value (including ptr->int casts of the same size). Strip off any 911ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner/// ParenExpr or CastExprs, returning their operand. 912ecdd84147c0765caa999ddc22dde25b42712bb4dChris LattnerExpr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) { 913ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner Expr *E = this; 914ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner while (true) { 915ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner if (ParenExpr *P = dyn_cast<ParenExpr>(E)) { 916ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner E = P->getSubExpr(); 917ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner continue; 918ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner } 919ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 920ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner if (CastExpr *P = dyn_cast<CastExpr>(E)) { 921ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner // We ignore integer <-> casts that are of the same width, ptr<->ptr and 922ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner // ptr<->int casts of the same width. We also ignore all identify casts. 923ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner Expr *SE = P->getSubExpr(); 924ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 925ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) { 926ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner E = SE; 927ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner continue; 928ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner } 929ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 930ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner if ((E->getType()->isPointerType() || E->getType()->isIntegralType()) && 931ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner (SE->getType()->isPointerType() || SE->getType()->isIntegralType()) && 932ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) { 933ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner E = SE; 934ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner continue; 935ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner } 936ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner } 937ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 938ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner return E; 939ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner } 940ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner} 941ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 942ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 943898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// hasAnyTypeDependentArguments - Determines if any of the expressions 944898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// in Exprs is type-dependent. 945898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorbool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) { 946898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor for (unsigned I = 0; I < NumExprs; ++I) 947898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (Exprs[I]->isTypeDependent()) 948898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return true; 949898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 950898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return false; 951898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 952898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 953898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// hasAnyValueDependentArguments - Determines if any of the expressions 954898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// in Exprs is value-dependent. 955898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorbool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) { 956898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor for (unsigned I = 0; I < NumExprs; ++I) 957898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (Exprs[I]->isValueDependent()) 958898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return true; 959898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 960898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return false; 961898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 962898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 963c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedmanbool Expr::isConstantInitializer(ASTContext &Ctx) const { 964c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // This function is attempting whether an expression is an initializer 965c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // which can be evaluated at compile-time. isEvaluatable handles most 966c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // of the cases, but it can't deal with some initializer-specific 967c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // expressions, and it can't deal with aggregates; we deal with those here, 968c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // and fall back to isEvaluatable for the other cases. 969c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman 9701f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This function assumes the variable being assigned to 9711f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // isn't a reference type! 9721f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman 973e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson switch (getStmtClass()) { 974c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman default: break; 975e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson case StringLiteralClass: 976eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case ObjCEncodeExprClass: 977e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson return true; 97859b5da6d853b4368b984700315adf7b37de05764Nate Begeman case CompoundLiteralExprClass: { 9791f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // This handles gcc's extension that allows global initializers like 9801f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // "struct x {int x;} x = (struct x) {};". 9811f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This accepts other cases it shouldn't! 98259b5da6d853b4368b984700315adf7b37de05764Nate Begeman const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer(); 983c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedman return Exp->isConstantInitializer(Ctx); 98459b5da6d853b4368b984700315adf7b37de05764Nate Begeman } 985e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson case InitListExprClass: { 9861f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This doesn't deal with fields with reference types correctly. 9871f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This incorrectly allows pointers cast to integers to be assigned 9881f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // to bitfields. 989e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson const InitListExpr *Exp = cast<InitListExpr>(this); 990e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson unsigned numInits = Exp->getNumInits(); 991e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson for (unsigned i = 0; i < numInits; i++) { 992c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedman if (!Exp->getInit(i)->isConstantInitializer(Ctx)) 993e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson return false; 994e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 995c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return true; 996e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 9973498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor case ImplicitValueInitExprClass: 9983498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return true; 999c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case ParenExprClass: { 1000c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 1001c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman } 1002c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case UnaryOperatorClass: { 1003c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman const UnaryOperator* Exp = cast<UnaryOperator>(this); 1004c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman if (Exp->getOpcode() == UnaryOperator::Extension) 1005c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return Exp->getSubExpr()->isConstantInitializer(Ctx); 1006c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman break; 1007c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman } 1008c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case CStyleCastExprClass: 1009c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // Handle casts with a destination that's a struct or union; this 1010c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // deals with both the gcc no-op struct cast extension and the 1011c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // cast-to-union extension. 1012c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman if (getType()->isRecordType()) 1013c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 1014c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman break; 1015e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 1016e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson 1017c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return isEvaluatable(Ctx); 101838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff} 101938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 10205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isIntegerConstantExpr - this recursive routine will test if an expression is 1021e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman/// an integer constant expression. 10225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 10245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// comma, etc 10255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 1026ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof 1027ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer 1028ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// cast+dereference. 10292d6744ff04c1690a1485178d550d2fab84a0270bDaniel Dunbar 1030e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// CheckICE - This function does the fundamental ICE checking: the returned 1031e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// ICEDiag contains a Val of 0, 1, or 2, and a possibly null SourceLocation. 1032e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// Note that to reduce code duplication, this helper does no evaluation 1033e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// itself; the caller checks whether the expression is evaluatable, and 1034e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// in the rare cases where CheckICE actually cares about the evaluated 1035e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// value, it calls into Evalute. 1036e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 1037e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// Meanings of Val: 1038e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 0: This expression is an ICE if it can be evaluated by Evaluate. 1039e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 1: This expression is not an ICE, but if it isn't evaluated, it's 1040e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// a legal subexpression for an ICE. This return value is used to handle 1041e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// the comma operator in C99 mode. 1042e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 2: This expression is not an ICE, and is not a legal subexpression for one. 1043e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 1044e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedmanstruct ICEDiag { 1045e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman unsigned Val; 1046e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman SourceLocation Loc; 1047e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 1048e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman public: 1049e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag(unsigned v, SourceLocation l) : Val(v), Loc(l) {} 1050e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag() : Val(0) {} 1051e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman}; 1052e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 1053e28d7195aad595154130ac8d03cc6c6513ece1bfEli FriedmanICEDiag NoDiag() { return ICEDiag(); } 1054e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 105560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedmanstatic ICEDiag CheckEvalInICE(const Expr* E, ASTContext &Ctx) { 105660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman Expr::EvalResult EVResult; 105760ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects || 105860ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman !EVResult.Val.isInt()) { 105960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(2, E->getLocStart()); 106060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 106160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return NoDiag(); 106260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman} 106360ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman 1064e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedmanstatic ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) { 1065c3082413e4207173b32c118e922d63149df6261fAnders Carlsson assert(!E->isValueDependent() && "Should not see value dependent exprs!"); 1066e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (!E->getType()->isIntegralType()) { 1067e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1068a6afa768aa7bd3102a2807aa720917e4a1771e4eEli Friedman } 1069e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 1070e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman switch (E->getStmtClass()) { 10715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 1072e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1073e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::ParenExprClass: 1074e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx); 1075e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::IntegerLiteralClass: 1076e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CharacterLiteralClass: 1077e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXBoolLiteralExprClass: 1078e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXZeroInitValueExprClass: 1079e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::TypesCompatibleExprClass: 1080e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::UnaryTypeTraitExprClass: 1081e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1082e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CallExprClass: 1083e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXOperatorCallExprClass: { 1084e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const CallExpr *CE = cast<CallExpr>(E); 108560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (CE->isBuiltinCall(Ctx)) 108660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return CheckEvalInICE(E, Ctx); 1087e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 108813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff } 1089e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::DeclRefExprClass: 1090e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::QualifiedDeclRefExprClass: 1091e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl())) 1092e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 10934a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (Ctx.getLangOptions().CPlusPlus && 1094e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman E->getType().getCVRQualifiers() == QualType::Const) { 10954a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // C++ 7.1.5.1p2 10964a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // A variable of non-volatile const-qualified integral or enumeration 10974a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // type initialized by an ICE can be used in ICEs. 10984a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (const VarDecl *Dcl = 1099e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) { 11004a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (const Expr *Init = Dcl->getInit()) 1101e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(Init, Ctx); 11024a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl } 11034a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl } 1104e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1105e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::UnaryOperatorClass: { 1106e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const UnaryOperator *Exp = cast<UnaryOperator>(E); 11075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 11085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 1109e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 11105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 1111e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case UnaryOperator::LNot: 11125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Plus: 11135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Minus: 11145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Not: 111560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman case UnaryOperator::Real: 111660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman case UnaryOperator::Imag: 1117e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(Exp->getSubExpr(), Ctx); 11185a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson case UnaryOperator::OffsetOf: 111960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // Note that per C99, offsetof must be an ICE. And AFAIK, using 112060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // Evaluate matches the proposed gcc behavior for cases like 112160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // "offsetof(struct s{int x[4];}, x[!.0])". This doesn't affect 112260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // compliance: we should warn earlier for offsetof expressions with 112360ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // array subscripts that aren't ICEs, and if the array subscripts 112460ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // are ICEs, the value of the offsetof must be an integer constant. 112560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return CheckEvalInICE(E, Ctx); 11265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 11275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1128e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::SizeOfAlignOfExprClass: { 1129e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(E); 1130e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (Exp->isSizeOf() && Exp->getTypeOfArgument()->isVariableArrayType()) 1131e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1132e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 11335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1134e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::BinaryOperatorClass: { 1135e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const BinaryOperator *Exp = cast<BinaryOperator>(E); 11365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 11375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 1138e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 11395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Mul: 11405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Div: 11415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Rem: 1142e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Add: 1143e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Sub: 11445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shl: 11455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shr: 1146e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LT: 1147e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::GT: 1148e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LE: 1149e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::GE: 1150e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::EQ: 1151e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::NE: 1152e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::And: 1153e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Xor: 1154e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Or: 1155e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Comma: { 1156e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 1157e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 115860ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (Exp->getOpcode() == BinaryOperator::Div || 115960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman Exp->getOpcode() == BinaryOperator::Rem) { 116060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // Evaluate gives an error for undefined Div/Rem, so make sure 116160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // we don't evaluate one. 116260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (LHSResult.Val != 2 && RHSResult.Val != 2) { 116360ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman llvm::APSInt REval = Exp->getRHS()->EvaluateAsInt(Ctx); 116460ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (REval == 0) 116560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(1, E->getLocStart()); 116660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (REval.isSigned() && REval.isAllOnesValue()) { 116760ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman llvm::APSInt LEval = Exp->getLHS()->EvaluateAsInt(Ctx); 116860ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (LEval.isMinSignedValue()) 116960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(1, E->getLocStart()); 117060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 117160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 117260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 117360ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (Exp->getOpcode() == BinaryOperator::Comma) { 117460ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (Ctx.getLangOptions().C99) { 117560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // C99 6.6p3 introduces a strange edge case: comma can be in an ICE 117660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // if it isn't evaluated. 117760ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (LHSResult.Val == 0 && RHSResult.Val == 0) 117860ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(1, E->getLocStart()); 117960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } else { 118060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // In both C89 and C++, commas in ICEs are illegal. 118160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(2, E->getLocStart()); 118260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 1183b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman } 1184e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (LHSResult.Val >= RHSResult.Val) 1185e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return LHSResult; 1186e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return RHSResult; 11875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1188e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LAnd: 1189e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LOr: { 1190e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 1191e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 1192e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (LHSResult.Val == 0 && RHSResult.Val == 1) { 1193e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // Rare case where the RHS has a comma "side-effect"; we need 1194e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // to actually check the condition to see whether the side 1195e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // with the comma is evaluated. 1196e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if ((Exp->getOpcode() == BinaryOperator::LAnd) != 119760ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman (Exp->getLHS()->EvaluateAsInt(Ctx) == 0)) 1198e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return RHSResult; 1199e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1200a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar } 120160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman 1202e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (LHSResult.Val >= RHSResult.Val) 1203e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return LHSResult; 1204e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return RHSResult; 12055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1206987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner } 12075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1208e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::ImplicitCastExprClass: 1209e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CStyleCastExprClass: 1210e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXFunctionalCastExprClass: { 1211e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr(); 1212e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (SubExpr->getType()->isIntegralType()) 1213e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(SubExpr, Ctx); 1214e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (isa<FloatingLiteral>(SubExpr->IgnoreParens())) 1215e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1216e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1217e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1218e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::ConditionalOperatorClass: { 1219e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const ConditionalOperator *Exp = cast<ConditionalOperator>(E); 122028daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner // If the condition (ignoring parens) is a __builtin_constant_p call, 122128daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner // then only the true side is actually considered in an integer constant 122242b83dde7c700b34f9435ad746984169888ae705Chris Lattner // expression, and it is fully evaluated. This is an important GNU 122342b83dde7c700b34f9435ad746984169888ae705Chris Lattner // extension. See GCC PR38377 for discussion. 1224e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (const CallExpr *CallCE = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts())) 12253c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) { 1226e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman Expr::EvalResult EVResult; 1227e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects || 1228e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman !EVResult.Val.isInt()) { 122960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(2, E->getLocStart()); 1230e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1231e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 123242b83dde7c700b34f9435ad746984169888ae705Chris Lattner } 1233e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx); 1234e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx); 1235e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx); 1236e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (CondResult.Val == 2) 1237e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CondResult; 1238e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (TrueResult.Val == 2) 1239e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return TrueResult; 1240e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (FalseResult.Val == 2) 1241e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return FalseResult; 1242e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (CondResult.Val == 1) 1243e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CondResult; 1244e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (TrueResult.Val == 0 && FalseResult.Val == 0) 1245e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1246e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // Rare case where the diagnostics depend on which side is evaluated 1247e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // Note that if we get here, CondResult is 0, and at least one of 1248e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // TrueResult and FalseResult is non-zero. 124960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (Exp->getCond()->EvaluateAsInt(Ctx) == 0) { 1250e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return FalseResult; 1251e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1252e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return TrueResult; 12535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1254e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXDefaultArgExprClass: 1255e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx); 125660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman case Expr::ChooseExprClass: { 12577976932a1c256d447316ffac58e9821417725e34Eli Friedman return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(Ctx), Ctx); 125860ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 12595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1260e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman} 12615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1262e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedmanbool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, 1263e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman SourceLocation *Loc, bool isEvaluated) const { 1264e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag d = CheckICE(this, Ctx); 1265e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (d.Val != 0) { 1266e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (Loc) *Loc = d.Loc; 1267e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return false; 1268e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1269e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman EvalResult EvalResult; 127060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (!Evaluate(EvalResult, Ctx)) 127160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman assert(0 && "ICE cannot be evaluated!"); 127260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman assert(!EvalResult.HasSideEffects && "ICE with side effects!"); 127360ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman assert(EvalResult.Val.isInt() && "ICE that isn't integer!"); 1274e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman Result = EvalResult.Val.getInt(); 12755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 12765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 12775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 12785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an 12795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// integer constant expression with the value zero, or if this is one that is 12805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// cast to void*. 1281efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlssonbool Expr::isNullPointerConstant(ASTContext &Ctx) const 1282efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlsson{ 12830777972d38a3125efed962b045704c30ae6965cfSebastian Redl // Strip off a cast to void*, if it exists. Except in C++. 12840835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 12856215dee86c0e715b9f2b0d401ab2a5fcf629f1afSebastian Redl if (!Ctx.getLangOptions().CPlusPlus) { 12860777972d38a3125efed962b045704c30ae6965cfSebastian Redl // Check that it is a cast to void*. 12870777972d38a3125efed962b045704c30ae6965cfSebastian Redl if (const PointerType *PT = CE->getType()->getAsPointerType()) { 12880777972d38a3125efed962b045704c30ae6965cfSebastian Redl QualType Pointee = PT->getPointeeType(); 12890777972d38a3125efed962b045704c30ae6965cfSebastian Redl if (Pointee.getCVRQualifiers() == 0 && 12900777972d38a3125efed962b045704c30ae6965cfSebastian Redl Pointee->isVoidType() && // to void* 12910777972d38a3125efed962b045704c30ae6965cfSebastian Redl CE->getSubExpr()->getType()->isIntegerType()) // from int. 1292d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return CE->getSubExpr()->isNullPointerConstant(Ctx); 12930777972d38a3125efed962b045704c30ae6965cfSebastian Redl } 12945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1295aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1296aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Ignore the ImplicitCastExpr type entirely. 1297d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return ICE->getSubExpr()->isNullPointerConstant(Ctx); 1298aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1299aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Accept ((void*)0) as a null pointer constant, as many other 1300aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // implementations do. 1301d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return PE->getSubExpr()->isNullPointerConstant(Ctx); 13028123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner } else if (const CXXDefaultArgExpr *DefaultArg 13038123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner = dyn_cast<CXXDefaultArgExpr>(this)) { 130404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner // See through default argument expressions 1305d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return DefaultArg->getExpr()->isNullPointerConstant(Ctx); 13062d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor } else if (isa<GNUNullExpr>(this)) { 13072d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor // The GNU __null extension is always a null pointer constant. 13082d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor return true; 1309aaffbf7c790a324ed114184db771aae2d2e9151cSteve Naroff } 13102d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor 1311aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // This expression must be an integer type. 1312aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff if (!getType()->isIntegerType()) 1313aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return false; 1314aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff 13155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If we have an integer constant expression, we need to *evaluate* it and 13165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // test for the value 0. 1317d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson // FIXME: We should probably return false if we're compiling in strict mode 1318d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson // and Diag is not null (this indicates that the value was foldable but not 1319d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson // an ICE. 1320d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson EvalResult Result; 1321efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlsson return Evaluate(Result, Ctx) && !Result.HasSideEffects && 1322d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson Result.Val.isInt() && Result.Val.getInt() == 0; 13235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 132431a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff 132527c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor/// isBitField - Return true if this expression is a bit-field. 132627c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregorbool Expr::isBitField() { 132727c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor Expr *E = this->IgnoreParenCasts(); 132827c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 132986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl())) 133086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return Field->isBitField(); 133127c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor return false; 133227c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor} 133327c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor 13342140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner/// isArrow - Return true if the base expression is a pointer to vector, 13352140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner/// return false if the base expression is a vector. 13362140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattnerbool ExtVectorElementExpr::isArrow() const { 13372140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner return getBase()->getType()->isPointerType(); 13382140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner} 13392140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner 1340213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanunsigned ExtVectorElementExpr::getNumElements() const { 13418a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (const VectorType *VT = getType()->getAsVectorType()) 13428a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return VT->getNumElements(); 13438a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return 1; 13444d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner} 13454d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner 13468a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// containsDuplicateElements - Return true if any element access is repeated. 1347213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanbool ExtVectorElementExpr::containsDuplicateElements() const { 1348fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *compStr = Accessor.getName(); 13497e3e9b152e06edf329ceb32190d3255f248d4d5fChris Lattner unsigned length = Accessor.getLength(); 1350190d6a25393995b42e32086949a68285ee423fb9Nate Begeman 1351190d6a25393995b42e32086949a68285ee423fb9Nate Begeman // Halving swizzles do not contain duplicate elements. 1352190d6a25393995b42e32086949a68285ee423fb9Nate Begeman if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") || 1353190d6a25393995b42e32086949a68285ee423fb9Nate Begeman !strcmp(compStr, "even") || !strcmp(compStr, "odd")) 1354190d6a25393995b42e32086949a68285ee423fb9Nate Begeman return false; 1355190d6a25393995b42e32086949a68285ee423fb9Nate Begeman 1356190d6a25393995b42e32086949a68285ee423fb9Nate Begeman // Advance past s-char prefix on hex swizzles. 1357190d6a25393995b42e32086949a68285ee423fb9Nate Begeman if (*compStr == 's') { 1358190d6a25393995b42e32086949a68285ee423fb9Nate Begeman compStr++; 1359190d6a25393995b42e32086949a68285ee423fb9Nate Begeman length--; 1360190d6a25393995b42e32086949a68285ee423fb9Nate Begeman } 1361fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff 13627e3e9b152e06edf329ceb32190d3255f248d4d5fChris Lattner for (unsigned i = 0; i != length-1; i++) { 1363fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *s = compStr+i; 1364fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff for (const char c = *s++; *s; s++) 1365fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff if (c == *s) 1366fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return true; 1367fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff } 1368fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return false; 1369fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff} 1370b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 13718a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 13723b8d116703db8018f855cbb4733ace426422623bNate Begemanvoid ExtVectorElementExpr::getEncodedElementAccess( 13733b8d116703db8018f855cbb4733ace426422623bNate Begeman llvm::SmallVectorImpl<unsigned> &Elts) const { 13747e3e9b152e06edf329ceb32190d3255f248d4d5fChris Lattner const char *compStr = Accessor.getName(); 1375353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman if (*compStr == 's') 1376353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman compStr++; 1377353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman 1378353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isHi = !strcmp(compStr, "hi"); 1379353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isLo = !strcmp(compStr, "lo"); 1380353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isEven = !strcmp(compStr, "even"); 1381353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isOdd = !strcmp(compStr, "odd"); 1382353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman 13838a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 13848a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman uint64_t Index; 13858a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 13868a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (isHi) 13878a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = e + i; 13888a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isLo) 13898a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = i; 13908a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isEven) 13918a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i; 13928a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isOdd) 13938a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i + 1; 13948a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else 13958a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = ExtVectorType::getAccessorIdx(compStr[i]); 1396b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 13973b8d116703db8018f855cbb4733ace426422623bNate Begeman Elts.push_back(Index); 1398b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner } 13998a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman} 14008a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 140168d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for instance messages. 1402bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1403a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1404db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 140549f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1406db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1407ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 140849f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 14095549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 141068d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[RECEIVER] = receiver; 141149f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 141249f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 141368d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 141468d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1415563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1416563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1417563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1418563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 141968d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for class messages. 142068d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// FIXME: clsName should be typed to ObjCInterfaceType 1421bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1422a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1423db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 142449f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1425db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1426ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 142749f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 14285549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 14294df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown); 143049f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 143149f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 143268d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 143368d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1434563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1435563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1436563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1437563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 14384df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek// constructor for class messages. 14394df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo, 14404df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek QualType retType, ObjCMethodDecl *mproto, 14414df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SourceLocation LBrac, SourceLocation RBrac, 14424df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek Expr **ArgExprs, unsigned nargs) 14434df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek: Expr(ObjCMessageExprClass, retType), SelName(selInfo), 14444df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekMethodProto(mproto) { 14454df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek NumArgs = nargs; 14464df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 14474df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown); 14484df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek if (NumArgs) { 14494df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek for (unsigned i = 0; i != NumArgs; ++i) 14504df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 14514df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 14524df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek LBracloc = LBrac; 14534df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek RBracloc = RBrac; 14544df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 14554df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 14564df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const { 14574df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek uintptr_t x = (uintptr_t) SubExprs[RECEIVER]; 14584df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek switch (x & Flags) { 14594df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek default: 14604df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek assert(false && "Invalid ObjCMessageExpr."); 14614df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsInstMeth: 14624df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, 0); 14634df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclUnknown: 14644df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, (IdentifierInfo*) (x & ~Flags)); 14654df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclKnown: { 14664df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags); 14674df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(D, D->getIdentifier()); 14684df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 14694df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 14704df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 14714df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 147227437caadea35f84d550cd29f024fcf3ea240eecChris Lattnerbool ChooseExpr::isConditionTrue(ASTContext &C) const { 147332442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar return getCond()->getIntegerConstantExprValue(C) != 0; 147427437caadea35f84d550cd29f024fcf3ea240eecChris Lattner} 147527437caadea35f84d550cd29f024fcf3ea240eecChris Lattner 14760518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redlvoid SizeOfAlignOfExpr::Destroy(ASTContext& C) { 14770518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // Override default behavior of traversing children. If this has a type 14780518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // operand and the type is a variable-length array, the child iteration 14790518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // will iterate over the size expression. However, this expression belongs 14800518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // to the type, not to this, so we don't want to delete it. 14810518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // We still want to delete this expression. 14828189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek if (isArgumentType()) { 14838189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek this->~SizeOfAlignOfExpr(); 14848189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek C.Deallocate(this); 14858189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek } 14860518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl else 14870518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl Expr::Destroy(C); 14889048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar} 14899048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar 149077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 149105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor// DesignatedInitExpr 149205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor//===----------------------------------------------------------------------===// 149305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 149405c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorIdentifierInfo *DesignatedInitExpr::Designator::getFieldName() { 149505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(Kind == FieldDesignator && "Only valid on a field designator"); 149605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (Field.NameOrField & 0x01) 149705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01); 149805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else 149905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return getField()->getIdentifier(); 150005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 150105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 150205c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr * 150305c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr::Create(ASTContext &C, Designator *Designators, 150405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor unsigned NumDesignators, 150505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Expr **IndexExprs, unsigned NumIndexExprs, 150605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor SourceLocation ColonOrEqualLoc, 150705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor bool UsesColonSyntax, Expr *Init) { 1508c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 1509c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff sizeof(Designator) * NumDesignators + 1510c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff sizeof(Stmt *) * (NumIndexExprs + 1), 8); 151105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor DesignatedInitExpr *DIE 151205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor = new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators, 151305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ColonOrEqualLoc, UsesColonSyntax, 151405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor NumIndexExprs + 1); 151505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 151605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor // Fill in the designators 151705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor unsigned ExpectedNumSubExprs = 0; 151805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor designators_iterator Desig = DIE->designators_begin(); 151905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor for (unsigned Idx = 0; Idx < NumDesignators; ++Idx, ++Desig) { 152005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor new (static_cast<void*>(Desig)) Designator(Designators[Idx]); 152105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (Designators[Idx].isArrayDesignator()) 152205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ++ExpectedNumSubExprs; 152305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else if (Designators[Idx].isArrayRangeDesignator()) 152405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ExpectedNumSubExprs += 2; 152505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor } 152605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(ExpectedNumSubExprs == NumIndexExprs && "Wrong number of indices!"); 152705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 152805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor // Fill in the subexpressions, including the initializer expression. 152905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor child_iterator Child = DIE->child_begin(); 153005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor *Child++ = Init; 153105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor for (unsigned Idx = 0; Idx < NumIndexExprs; ++Idx, ++Child) 153205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor *Child = IndexExprs[Idx]; 153305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 153405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return DIE; 153505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 153605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 153705c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorSourceRange DesignatedInitExpr::getSourceRange() const { 153805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor SourceLocation StartLoc; 1539d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner Designator &First = 1540d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner *const_cast<DesignatedInitExpr*>(this)->designators_begin(); 154105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (First.isFieldDesignator()) { 1542eeae8f072748affce25ab4064982626361293390Douglas Gregor if (GNUSyntax) 154305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc); 154405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else 154505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc); 154605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor } else 1547d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner StartLoc = 1548d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc); 154905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return SourceRange(StartLoc, getInit()->getSourceRange().getEnd()); 155005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 155105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 1552d603eaa682cecac2c10771a700cb83aa301653b4Chris LattnerDesignatedInitExpr::designators_iterator 1553d603eaa682cecac2c10771a700cb83aa301653b4Chris LattnerDesignatedInitExpr::designators_begin() { 155405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 155505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 155605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return static_cast<Designator*>(static_cast<void*>(Ptr)); 155705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 155805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 155905c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr::designators_iterator DesignatedInitExpr::designators_end() { 156005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return designators_begin() + NumDesignators; 156105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 156205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 156305c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayIndex(const Designator& D) { 156405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayDesignator && "Requires array designator"); 156505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 156605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 156705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 156805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 156905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 157005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 157105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 157205c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) { 157305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayRangeDesignator && 157405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor "Requires array range designator"); 157505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 157605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 157705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 157805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 157905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 158005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 158105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 158205c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) { 158305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayRangeDesignator && 158405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor "Requires array range designator"); 158505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 158605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 158705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 158805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 158905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2)); 159005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 159105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 159205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor//===----------------------------------------------------------------------===// 1593ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek// ExprIterator. 1594ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek//===----------------------------------------------------------------------===// 1595ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek 1596ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 1597ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator*() const { return cast<Expr>(*I); } 1598ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator->() const { return cast<Expr>(*I); } 1599ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator[](size_t idx) const { 1600ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek return cast<Expr>(I[idx]); 1601ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek} 1602ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 1603ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 1604ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek 1605ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek//===----------------------------------------------------------------------===// 160677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// Child Iterators for iterating over subexpressions/substatements 160777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 160877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 160977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// DeclRefExpr 16109ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 16119ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 161277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 16137779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff// ObjCIvarRefExpr 16145549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; } 16155549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; } 16167779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff 1617e3e9add4fd788927df6f545570e7838db59c01d7Steve Naroff// ObjCPropertyRefExpr 16185549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; } 16195549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; } 1620ae7840776d6cd31b4d7a4a345b61bcbb3744df6cSteve Naroff 16215daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian// ObjCKVCRefExpr 16225daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz JahanianStmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; } 16235daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz JahanianStmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; } 16245daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian 1625cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas Gregor// ObjCSuperExpr 1626cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas GregorStmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); } 1627cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas GregorStmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); } 1628cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas Gregor 1629d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner// PredefinedExpr 1630d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); } 1631d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); } 163277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 163377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// IntegerLiteral 16349ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 16359ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 163677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 163777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CharacterLiteral 1638d603eaa682cecac2c10771a700cb83aa301653b4Chris LattnerStmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();} 16399ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 164077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 164177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// FloatingLiteral 16429ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 16439ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 164477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 16455d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner// ImaginaryLiteral 16465549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; } 16475549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; } 16485d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner 164977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// StringLiteral 16509ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 16519ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 165277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 165377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ParenExpr 16545549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_begin() { return &Val; } 16555549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_end() { return &Val+1; } 165677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 165777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// UnaryOperator 16585549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_begin() { return &Val; } 16595549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_end() { return &Val+1; } 166077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 16610518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl// SizeOfAlignOfExpr 16620518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlStmt::child_iterator SizeOfAlignOfExpr::child_begin() { 16630518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // If this is of a type and the type is a VLA type (and not a typedef), the 16640518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // size expression of the VLA needs to be treated as an executable expression. 16650518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // Why isn't this weirdness documented better in StmtIterator? 16660518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (isArgumentType()) { 16670518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (VariableArrayType* T = dyn_cast<VariableArrayType>( 16680518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl getArgumentType().getTypePtr())) 16690518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(T); 16700518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(); 16710518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl } 1672d457589fc69dc7a9c80cd74d317c0b81a35a27c9Sebastian Redl return child_iterator(&Argument.Ex); 16739ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 16740518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlStmt::child_iterator SizeOfAlignOfExpr::child_end() { 16750518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (isArgumentType()) 16760518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(); 1677d457589fc69dc7a9c80cd74d317c0b81a35a27c9Sebastian Redl return child_iterator(&Argument.Ex + 1); 16789ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 167977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 168077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ArraySubscriptExpr 16811237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_begin() { 16825549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 168377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 16841237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_end() { 16855549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 168677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 168777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 168877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CallExpr 16891237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_begin() { 16905549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 169177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 16921237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_end() { 16935549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumArgs+ARGS_START; 169477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 16951237c673c07f9d827129ba02720108816abde562Ted Kremenek 16961237c673c07f9d827129ba02720108816abde562Ted Kremenek// MemberExpr 16975549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_begin() { return &Base; } 16985549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_end() { return &Base+1; } 16991237c673c07f9d827129ba02720108816abde562Ted Kremenek 1700213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman// ExtVectorElementExpr 17015549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; } 17025549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; } 17031237c673c07f9d827129ba02720108816abde562Ted Kremenek 17041237c673c07f9d827129ba02720108816abde562Ted Kremenek// CompoundLiteralExpr 17055549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; } 17065549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; } 17071237c673c07f9d827129ba02720108816abde562Ted Kremenek 17081237c673c07f9d827129ba02720108816abde562Ted Kremenek// CastExpr 17095549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_begin() { return &Op; } 17105549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_end() { return &Op+1; } 17111237c673c07f9d827129ba02720108816abde562Ted Kremenek 17121237c673c07f9d827129ba02720108816abde562Ted Kremenek// BinaryOperator 17131237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_begin() { 17145549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 17151237c673c07f9d827129ba02720108816abde562Ted Kremenek} 17161237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_end() { 17175549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 17181237c673c07f9d827129ba02720108816abde562Ted Kremenek} 17191237c673c07f9d827129ba02720108816abde562Ted Kremenek 17201237c673c07f9d827129ba02720108816abde562Ted Kremenek// ConditionalOperator 17211237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_begin() { 17225549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 17231237c673c07f9d827129ba02720108816abde562Ted Kremenek} 17241237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_end() { 17255549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 17261237c673c07f9d827129ba02720108816abde562Ted Kremenek} 17271237c673c07f9d827129ba02720108816abde562Ted Kremenek 17281237c673c07f9d827129ba02720108816abde562Ted Kremenek// AddrLabelExpr 17299ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 17309ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 17311237c673c07f9d827129ba02720108816abde562Ted Kremenek 17321237c673c07f9d827129ba02720108816abde562Ted Kremenek// StmtExpr 17335549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_begin() { return &SubStmt; } 17345549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; } 17351237c673c07f9d827129ba02720108816abde562Ted Kremenek 17361237c673c07f9d827129ba02720108816abde562Ted Kremenek// TypesCompatibleExpr 17379ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_begin() { 17389ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 17399ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 17409ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek 17419ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_end() { 17429ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 17439ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 17441237c673c07f9d827129ba02720108816abde562Ted Kremenek 17451237c673c07f9d827129ba02720108816abde562Ted Kremenek// ChooseExpr 17465549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; } 17475549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; } 17482d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor 17492d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor// GNUNullExpr 17502d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas GregorStmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); } 17512d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas GregorStmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); } 17521237c673c07f9d827129ba02720108816abde562Ted Kremenek 1753d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman// ShuffleVectorExpr 1754d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_begin() { 17555549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 1756d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1757d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_end() { 17585549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumExprs; 1759d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1760d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 17617c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson// VAArgExpr 17625549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_begin() { return &Val; } 17635549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_end() { return &Val+1; } 17647c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 176566b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson// InitListExpr 176666b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_begin() { 17675549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] : 0; 176866b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 176966b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_end() { 17705549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0; 177166b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 177266b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson 17733498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor// DesignatedInitExpr 177405c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorStmt::child_iterator DesignatedInitExpr::child_begin() { 177505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 177605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 177705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 177805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 177905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 178005c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorStmt::child_iterator DesignatedInitExpr::child_end() { 178105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return child_iterator(&*child_begin() + NumSubExprs); 178205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 178305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 17843498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor// ImplicitValueInitExpr 17853498bdb9e9cb300de74c7b51c92608e2902b2348Douglas GregorStmt::child_iterator ImplicitValueInitExpr::child_begin() { 17863498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return child_iterator(); 17873498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor} 17883498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor 17893498bdb9e9cb300de74c7b51c92608e2902b2348Douglas GregorStmt::child_iterator ImplicitValueInitExpr::child_end() { 17903498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return child_iterator(); 17913498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor} 17923498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor 17931237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCStringLiteral 17949ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_begin() { 1795c6c16af963eddc3e9b75b5d2614d069e1162fe27Chris Lattner return &String; 17969ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 17979ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_end() { 1798c6c16af963eddc3e9b75b5d2614d069e1162fe27Chris Lattner return &String+1; 17999ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 18001237c673c07f9d827129ba02720108816abde562Ted Kremenek 18011237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCEncodeExpr 18029ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 18039ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 18041237c673c07f9d827129ba02720108816abde562Ted Kremenek 1805b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian// ObjCSelectorExpr 18069ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_begin() { 18079ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18089ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 18099ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_end() { 18109ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18119ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1812b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 1813390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian// ObjCProtocolExpr 18149ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_begin() { 18159ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18169ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 18179ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_end() { 18189ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18199ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1820390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian 1821563477da25f824e37c535131695dc4dc9b68c465Steve Naroff// ObjCMessageExpr 1822ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted KremenekStmt::child_iterator ObjCMessageExpr::child_begin() { 18235549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START; 1824563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1825563477da25f824e37c535131695dc4dc9b68c465Steve NaroffStmt::child_iterator ObjCMessageExpr::child_end() { 18265549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+ARGS_START+getNumArgs(); 1827563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1828563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 18294eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff// Blocks 183056ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt::child_iterator BlockExpr::child_begin() { return child_iterator(); } 183156ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt::child_iterator BlockExpr::child_end() { return child_iterator(); } 18324eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff 18339da13f9ddb2567e36f4bbee7b3c32f54aeb76d5bTed KremenekStmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();} 18349da13f9ddb2567e36f4bbee7b3c32f54aeb76d5bTed KremenekStmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); } 1835