Expr.cpp revision e28d7195aad595154130ac8d03cc6c6513ece1bf
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- Expr.cpp - Expression AST Node Implementation --------------------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This file implements the Expr class and subclasses. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 14c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/Expr.h" 15a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner#include "clang/AST/APValue.h" 162eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner#include "clang/AST/ASTContext.h" 17a4d55d89c8076b402bb168e3edeef0c2cd2a78c3Chris Lattner#include "clang/AST/DeclObjC.h" 1898cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor#include "clang/AST/DeclCXX.h" 19aaba5e346dffdbad5d1c42765a89e4a7afb0da67Douglas Gregor#include "clang/AST/DeclTemplate.h" 20e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar#include "clang/AST/RecordLayout.h" 215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/StmtVisitor.h" 22da5a6b6d9fd52899499d5b7b46273ec844dcaa6eChris Lattner#include "clang/Basic/TargetInfo.h" 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Primary Expressions. 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 29da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// getValueAsApproximateDouble - This returns the value as an inaccurate 30da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// double. Note that this may cause loss of precision, but is useful for 31da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// debugging dumps, etc. 32da8249e57f3badecf925571881fe57243935c6c1Chris Lattnerdouble FloatingLiteral::getValueAsApproximateDouble() const { 33da8249e57f3badecf925571881fe57243935c6c1Chris Lattner llvm::APFloat V = getValue(); 34ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen bool ignored; 35ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 36ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen &ignored); 37da8249e57f3badecf925571881fe57243935c6c1Chris Lattner return V.convertToDouble(); 38da8249e57f3badecf925571881fe57243935c6c1Chris Lattner} 39da8249e57f3badecf925571881fe57243935c6c1Chris Lattner 402085fd6cd22ec5c268175251db10d7c60caf7aaaChris LattnerStringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData, 412085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner unsigned ByteLength, bool Wide, 422085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner QualType Ty, 432085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SourceLocation *Loc, unsigned NumStrs) { 442085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner // Allocate enough space for the StringLiteral plus an array of locations for 452085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner // any concatenated string tokens. 462085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner void *Mem = C.Allocate(sizeof(StringLiteral)+ 472085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner sizeof(SourceLocation)*(NumStrs-1), 482085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner llvm::alignof<StringLiteral>()); 492085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner StringLiteral *SL = new (Mem) StringLiteral(Ty); 502085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner 515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // OPTIMIZE: could allocate this appended to the StringLiteral. 522085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner char *AStrData = new (C, 1) char[ByteLength]; 532085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner memcpy(AStrData, StrData, ByteLength); 542085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->StrData = AStrData; 552085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->ByteLength = ByteLength; 562085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->IsWide = Wide; 572085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->TokLocs[0] = Loc[0]; 582085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->NumConcatenated = NumStrs; 595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 60726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner if (NumStrs != 1) 612085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1)); 622085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner return SL; 63726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner} 64726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner 65726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner 666e94ef5696cfb005d3fc7bbac8dcf7690b64f0a5Ted Kremenekvoid StringLiteral::Destroy(ASTContext &C) { 678189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek C.Deallocate(const_cast<char*>(StrData)); 68353ffceafc6bcebd5592cb9d93ea3f9242e5370aTed Kremenek this->~StringLiteral(); 69353ffceafc6bcebd5592cb9d93ea3f9242e5370aTed Kremenek C.Deallocate(this); 705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "sizeof" or "[pre]++". 745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *UnaryOperator::getOpcodeStr(Opcode Op) { 755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown unary operator"); 775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostInc: return "++"; 785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostDec: return "--"; 795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreInc: return "++"; 805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreDec: return "--"; 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddrOf: return "&"; 825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Deref: return "*"; 835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Plus: return "+"; 845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Minus: return "-"; 855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Not: return "~"; 865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LNot: return "!"; 875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Real: return "__real"; 885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Imag: return "__imag"; 895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Extension: return "__extension__"; 9073d0d4fac161ed12926e010dcf8b448a8de6a2ecChris Lattner case OffsetOf: return "__builtin_offsetof"; 915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Postfix Operators. 965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 98668bf91d31265b6ea8c3eb854ba450857701f269Ted KremenekCallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args, 998189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek unsigned numargs, QualType t, SourceLocation rparenloc) 100898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor : Expr(SC, t, 101898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 102d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 103898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor NumArgs(numargs) { 104668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 105668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek SubExprs = new (C) Stmt*[numargs+1]; 106b4609806e9232593ece09ce08b630836e825865cDouglas Gregor SubExprs[FN] = fn; 107b4609806e9232593ece09ce08b630836e825865cDouglas Gregor for (unsigned i = 0; i != numargs; ++i) 108b4609806e9232593ece09ce08b630836e825865cDouglas Gregor SubExprs[i+ARGS_START] = args[i]; 109668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 110b4609806e9232593ece09ce08b630836e825865cDouglas Gregor RParenLoc = rparenloc; 111b4609806e9232593ece09ce08b630836e825865cDouglas Gregor} 112e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman 113668bf91d31265b6ea8c3eb854ba450857701f269Ted KremenekCallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs, 114668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek QualType t, SourceLocation rparenloc) 115898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor : Expr(CallExprClass, t, 116898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 117d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 118898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor NumArgs(numargs) { 119668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 120668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek SubExprs = new (C) Stmt*[numargs+1]; 12177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[FN] = fn; 1225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != numargs; ++i) 12377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[i+ARGS_START] = args[i]; 124668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 1255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RParenLoc = rparenloc; 1265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 128668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenekvoid CallExpr::Destroy(ASTContext& C) { 129668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek DestroyChildren(C); 130668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek if (SubExprs) C.Deallocate(SubExprs); 131668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek this->~CallExpr(); 132668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek C.Deallocate(this); 133668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek} 134668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 135d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// setNumArgs - This changes the number of arguments present in this call. 136d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// Any orphaned expressions are deleted by this, and any new operands are set 137d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// to null. 1388189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenekvoid CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) { 139d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // No change, just return. 140d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs == getNumArgs()) return; 141d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 142d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // If shrinking # arguments, just delete the extras and forgot them. 143d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs < getNumArgs()) { 144d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 1458189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek getArg(i)->Destroy(C); 146d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 147d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner return; 148d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner } 149d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 150d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Otherwise, we are growing the # arguments. New an bigger argument array. 1515549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek Stmt **NewSubExprs = new Stmt*[NumArgs+1]; 152d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Copy over args. 153d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 154d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = SubExprs[i]; 155d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Null out new args. 156d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 157d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = 0; 158d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 1598189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek delete [] SubExprs; 160d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner SubExprs = NewSubExprs; 161d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 162d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner} 163d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 164cb888967400a03504c88acedd5248d6778a82f46Chris Lattner/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If 165cb888967400a03504c88acedd5248d6778a82f46Chris Lattner/// not, return 0. 1663c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregorunsigned CallExpr::isBuiltinCall(ASTContext &Context) const { 167c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // All simple function calls (e.g. func()) are implicitly cast to pointer to 168c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // function. As a result, we try and obtain the DeclRefExpr from the 169c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // ImplicitCastExpr. 170c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 171c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 172cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 173cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 174c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 175c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!DRE) 176cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 177cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 178bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 179bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson if (!FDecl) 180cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 181cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 1824fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor if (!FDecl->getIdentifier()) 1834fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor return 0; 1844fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor 1853c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor return FDecl->getBuiltinID(Context); 186cb888967400a03504c88acedd5248d6778a82f46Chris Lattner} 187bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson 188cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 1895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 1905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "<<=". 1915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *BinaryOperator::getOpcodeStr(Opcode Op) { 1925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 1935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown binary operator"); 1945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Mul: return "*"; 1955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Div: return "/"; 1965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Rem: return "%"; 1975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Add: return "+"; 1985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Sub: return "-"; 1995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shl: return "<<"; 2005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shr: return ">>"; 2015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LT: return "<"; 2025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GT: return ">"; 2035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LE: return "<="; 2045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GE: return ">="; 2055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case EQ: return "=="; 2065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case NE: return "!="; 2075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case And: return "&"; 2085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Xor: return "^"; 2095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Or: return "|"; 2105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LAnd: return "&&"; 2115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LOr: return "||"; 2125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Assign: return "="; 2135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MulAssign: return "*="; 2145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DivAssign: return "/="; 2155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case RemAssign: return "%="; 2165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddAssign: return "+="; 2175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SubAssign: return "-="; 2185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShlAssign: return "<<="; 2195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShrAssign: return ">>="; 2205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AndAssign: return "&="; 2215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case XorAssign: return "^="; 2225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case OrAssign: return "|="; 2235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Comma: return ","; 2245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 22766b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonInitListExpr::InitListExpr(SourceLocation lbraceloc, 228418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner Expr **initExprs, unsigned numInits, 2294c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor SourceLocation rbraceloc) 230c5ae899b4bbf65488445316c63168079177db0edSteve Naroff : Expr(InitListExprClass, QualType()), 2310bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0), 232a9c878086036de36482cc21e35a33cabe9699b0aDouglas Gregor UnionFieldInit(0), HadArrayRangeDesignator(false) { 233418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner 234418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits); 23566b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 2365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2374c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregorvoid InitListExpr::resizeInits(ASTContext &Context, unsigned NumInits) { 238d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner for (unsigned Idx = NumInits, LastIdx = InitExprs.size(); 239f592c929bd1f083abcc8199b24bb825fdd28df1cDaniel Dunbar Idx < LastIdx; ++Idx) 2404c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor delete InitExprs[Idx]; 2414c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.resize(NumInits, 0); 2424c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor} 2434c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 2444c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas GregorExpr *InitListExpr::updateInit(unsigned Init, Expr *expr) { 2454c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor if (Init >= InitExprs.size()) { 2464c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.insert(InitExprs.end(), Init - InitExprs.size() + 1, 0); 2474c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.back() = expr; 2484c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor return 0; 2494c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor } 2504c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 2514c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor Expr *Result = cast_or_null<Expr>(InitExprs[Init]); 2524c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs[Init] = expr; 2534c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor return Result; 2544c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor} 2554c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 256bfdcae678d44906293e21c0cddc6537f3ee8b5a4Steve Naroff/// getFunctionType - Return the underlying function type for this block. 2574eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff/// 2584eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroffconst FunctionType *BlockExpr::getFunctionType() const { 2594eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff return getType()->getAsBlockPointerType()-> 2604eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff getPointeeType()->getAsFunctionType(); 2614eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff} 2624eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff 26356ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffSourceLocation BlockExpr::getCaretLocation() const { 26456ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff return TheBlock->getCaretLocation(); 26556ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff} 26656ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroffconst Stmt *BlockExpr::getBody() const { return TheBlock->getBody(); } 26756ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt *BlockExpr::getBody() { return TheBlock->getBody(); } 26856ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff 26956ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff 2705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 2715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Generic Expression Routines 2725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 2735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 274026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// isUnusedResultAWarning - Return true if this immediate expression should 275026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// be warned about if the result is unused. If so, fill in Loc and Ranges 276026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// with location to warn on and the source range[s] to report with the 277026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// warning. 278026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattnerbool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1, 279026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner SourceRange &R2) const { 2805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 2815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 282026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = getExprLoc(); 283026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = getSourceRange(); 284026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 2855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: 286026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<ParenExpr>(this)->getSubExpr()-> 287026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner isUnusedResultAWarning(Loc, R1, R2); 2885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperatorClass: { 2895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const UnaryOperator *UO = cast<UnaryOperator>(this); 2905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (UO->getOpcode()) { 292026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner default: break; 2935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostInc: 2945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostDec: 2955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PreInc: 296026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner case UnaryOperator::PreDec: // ++/-- 297026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; // Not a warning. 2985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Deref: 2995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Dereferencing a volatile pointer is a side-effect. 300026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 301026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 302026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner break; 3035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Real: 3045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Imag: 3055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // accessing a piece of a volatile complex is a side-effect. 306026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (UO->getSubExpr()->getType().isVolatileQualified()) 307026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 308026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner break; 3095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 310026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 3115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 312026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = UO->getOperatorLoc(); 313026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = UO->getSubExpr()->getSourceRange(); 314026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 3155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 316e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner case BinaryOperatorClass: { 317026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const BinaryOperator *BO = cast<BinaryOperator>(this); 318026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // Consider comma to have side effects if the LHS or RHS does. 319026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (BO->getOpcode() == BinaryOperator::Comma) 320026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2) || 321026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2); 322e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner 323026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (BO->isAssignmentOp()) 324026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 325026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = BO->getOperatorLoc(); 326026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = BO->getLHS()->getSourceRange(); 327026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = BO->getRHS()->getSourceRange(); 328026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 329e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner } 330eb14fe839ec24c2ca14e5f094be147a34e3d3339Chris Lattner case CompoundAssignOperatorClass: 331026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 3325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 333ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian case ConditionalOperatorClass: { 334026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // The condition must be evaluated, but if either the LHS or RHS is a 335026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // warning, warn about them. 336ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 337026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2)) 338026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 339026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2); 340ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian } 341ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian 3425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MemberExprClass: 343026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If the base pointer or element is to a volatile pointer/field, accessing 344026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // it is a side effect. 345026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 346026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 347026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<MemberExpr>(this)->getMemberLoc(); 348026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = SourceRange(Loc, Loc); 349026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = cast<MemberExpr>(this)->getBase()->getSourceRange(); 350026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 351026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 3525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: 3535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the base pointer or element is to a volatile pointer/field, accessing 354026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // it is a side effect. 355026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 356026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 357026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc(); 358026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange(); 359026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange(); 360026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 361211f6adf1301a1461015fb6cb08a05f0a35b65f3Eli Friedman 3625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case CallExprClass: 363026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner case CXXOperatorCallExprClass: { 364026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If this is a direct call, get the callee. 365026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const CallExpr *CE = cast<CallExpr>(this); 366026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const Expr *CalleeExpr = CE->getCallee()->IgnoreParenCasts(); 367026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (const DeclRefExpr *CalleeDRE = dyn_cast<DeclRefExpr>(CalleeExpr)) { 368026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If the callee has attribute pure, const, or warn_unused_result, warn 369026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // about it. void foo() { strlen("bar"); } should warn. 370026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CalleeDRE->getDecl())) 371026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (FD->getAttr<WarnUnusedResultAttr>() || 372026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) { 373026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = CE->getCallee()->getLocStart(); 374026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = CE->getCallee()->getSourceRange(); 375026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 376026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (unsigned NumArgs = CE->getNumArgs()) 377026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = SourceRange(CE->getArg(0)->getLocStart(), 378026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner CE->getArg(NumArgs-1)->getLocEnd()); 379026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 380026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 381026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 382026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 383026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 384a9c01021724b9b546d282b8609cbe559734812ecChris Lattner case ObjCMessageExprClass: 385026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 386611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner case StmtExprClass: { 387611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // Statement exprs don't logically have side effects themselves, but are 388611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // sometimes used in macros in ways that give them a type that is unused. 389611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // For example ({ blah; foo(); }) will end up with a type if foo has a type. 390611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // however, if the result of the stmt expr is dead, we don't want to emit a 391611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // warning. 392611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 393611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (!CS->body_empty()) 394611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 395026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return E->isUnusedResultAWarning(Loc, R1, R2); 396026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 397026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<StmtExpr>(this)->getLParenLoc(); 398026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = getSourceRange(); 399026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 400611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner } 4016eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 402026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If this is a cast to void, check the operand. Otherwise, the result of 403026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // the cast is unused. 404026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType()->isVoidType()) 405026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CastExpr>(this)->getSubExpr()->isUnusedResultAWarning(Loc, 406026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1, R2); 407026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<CStyleCastExpr>(this)->getLParenLoc(); 408026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange(); 409026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 410987a14bf5883ef6e5d07f1c83eb6d41a8212a78cArgyrios Kyrtzidis case CXXFunctionalCastExprClass: 4115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is a cast to void, check the operand. Otherwise, the result of 4125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the cast is unused. 4135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (getType()->isVoidType()) 414026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CastExpr>(this)->getSubExpr()->isUnusedResultAWarning(Loc, 415026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1, R2); 416026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc(); 417026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange(); 418026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 419026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 4204be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman case ImplicitCastExprClass: 4214be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman // Check the operand, since implicit casts are inserted by Sema 422026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<ImplicitCastExpr>(this) 423026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 4244be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman 42504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 426026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CXXDefaultArgExpr>(this) 427026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner ->getExpr()->isUnusedResultAWarning(Loc, R1, R2); 4284c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl 4294c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl case CXXNewExprClass: 4304c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl // FIXME: In theory, there might be new expressions that don't have side 4314c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl // effects (e.g. a placement new with an uninitialized POD). 4324c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl case CXXDeleteExprClass: 433026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 4344c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl } 4355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 437ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor/// DeclCanBeLvalue - Determine whether the given declaration can be 438ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor/// an lvalue. This is a helper routine for isLvalue. 439ba7e210a999275695f58be03ef402758cfec3635Douglas Gregorstatic bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) { 44072c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor // C++ [temp.param]p6: 44172c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor // A non-type non-reference template-parameter is not an lvalue. 44272c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor if (const NonTypeTemplateParmDecl *NTTParm 44372c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Decl)) 44472c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor return NTTParm->getType()->isReferenceType(); 44572c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor 44644b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) || 447ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor // C++ 3.10p2: An lvalue refers to an object or function. 448ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor (Ctx.getLangOptions().CPlusPlus && 449ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl))); 450ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor} 451ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor 4525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 4535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// incomplete type other than void. Nonarray expressions that can be lvalues: 4545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - name, where name must be a variable 4555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e[i] 4565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - (e), where e must be an lvalue 4575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e.name, where e must be an lvalue 4585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e->name 4595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - *e, the type of e cannot be a function type 4605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - string-constant 4617da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 46208ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling/// - reference type [C++ [expr]] 4635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 46428be73f74c9e241a23ea24fe5756623de6bf1084Chris LattnerExpr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const { 46598cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor // first, check the type (C99 6.3.2.1). Expressions with function 46698cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor // type in C are not lvalues, but they can be lvalues in C++. 46798cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor if (!Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 4685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_NotObjectType; 4695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 470acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff // Allow qualified void which is an incomplete type other than void (yuck). 47128be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers()) 472acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff return LV_IncompleteVoidType; 473acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff 47498cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor /// FIXME: Expressions can't have reference type, so the following 47598cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor /// isn't needed. 476cb4f9a6d0be445d84af35ba81323be6127816f9eChris Lattner if (TR->isReferenceType()) // C++ [expr] 47708ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling return LV_Valid; 47808ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling 4795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the type looks fine, now check the expression 4805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 481eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case StringLiteralClass: // C99 6.5.1p4 482eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case ObjCEncodeExprClass: // @encode behaves like its string in every way. 4837323a6297edad643c202594dcf3d9a174de96ca6Anders Carlsson return LV_Valid; 4845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 4855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // For vectors, make sure base is an lvalue (i.e. not a function call). 4865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 48728be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx); 4885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 4891a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case DeclRefExprClass: 4901a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case QualifiedDeclRefExprClass: { // C99 6.5.1p2 491ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl(); 492ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor if (DeclCanBeLvalue(RefdDecl, Ctx)) 4935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 4945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 4954111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner } 496dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff case BlockDeclRefExprClass: { 497dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 4984f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (isa<VarDecl>(BDR->getDecl())) 499dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff return LV_Valid; 500dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff break; 501dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff } 50286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor case MemberExprClass: { 5035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const MemberExpr *m = cast<MemberExpr>(this); 50486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4: 50586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor NamedDecl *Member = m->getMemberDecl(); 50686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // C++ [expr.ref]p4: 50786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // If E2 is declared to have type "reference to T", then E1.E2 50886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // is an lvalue. 50986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (ValueDecl *Value = dyn_cast<ValueDecl>(Member)) 51086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (Value->getType()->isReferenceType()) 51186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_Valid; 51286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 51386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a static data member [...] then E1.E2 is an lvalue. 51486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (isa<CXXClassVarDecl>(Member)) 51586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_Valid; 51686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 51786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a non-static data member [...]. If E1 is an 51886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // lvalue, then E1.E2 is an lvalue. 51986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (isa<FieldDecl>(Member)) 52086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 52186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 52286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If it refers to a static member function [...], then 52386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // E1.E2 is an lvalue. 52486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- Otherwise, if E1.E2 refers to a non-static member 52586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // function [...], then E1.E2 is not an lvalue. 52686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) 52786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return Method->isStatic()? LV_Valid : LV_MemberFunction; 52886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 52986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a member enumerator [...], the expression E1.E2 53086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // is not an lvalue. 53186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (isa<EnumConstantDecl>(Member)) 53286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_InvalidExpression; 53386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 53486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // Not an lvalue. 53586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_InvalidExpression; 53686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor } 53786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 53886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // C99 6.5.2.3p4 53928be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 540fdd75663fffeb2058a7847975e50837e61200593Anton Korobeynikov } 5417da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner case UnaryOperatorClass: 5425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 5437da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner return LV_Valid; // C99 6.5.3p4 5447da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner 5457da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 546baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag || 547baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension) 54828be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU. 54974253736184c0717a0649922551bf9d8b6815651Douglas Gregor 55074253736184c0717a0649922551bf9d8b6815651Douglas Gregor if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1 55174253736184c0717a0649922551bf9d8b6815651Douglas Gregor (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc || 55274253736184c0717a0649922551bf9d8b6815651Douglas Gregor cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec)) 55374253736184c0717a0649922551bf9d8b6815651Douglas Gregor return LV_Valid; 5545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 555eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case ImplicitCastExprClass: 556eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid 557eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor : LV_InvalidExpression; 5585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: // C99 6.5.1p5 55928be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx); 560eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case BinaryOperatorClass: 561eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case CompoundAssignOperatorClass: { 562eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor const BinaryOperator *BinOp = cast<BinaryOperator>(this); 563337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor 564337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1 565337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor BinOp->getOpcode() == BinaryOperator::Comma) 566337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor return BinOp->getRHS()->isLvalue(Ctx); 567337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor 568224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl // C++ [expr.mptr.oper]p6 569224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl if ((BinOp->getOpcode() == BinaryOperator::PtrMemD || 570224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl BinOp->getOpcode() == BinaryOperator::PtrMemI) && 571224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl !BinOp->getType()->isFunctionType()) 572224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl return BinOp->getLHS()->isLvalue(Ctx); 573224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl 574bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor if (!BinOp->isAssignmentOp()) 575eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor return LV_InvalidExpression; 576eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor 577bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor if (Ctx.getLangOptions().CPlusPlus) 578bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // C++ [expr.ass]p1: 579bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // The result of an assignment operation [...] is an lvalue. 580bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor return LV_Valid; 581bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor 582bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor 583bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // C99 6.5.16: 584bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // An assignment expression [...] is not an lvalue. 585bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor return LV_InvalidExpression; 586eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor } 587b4609806e9232593ece09ce08b630836e825865cDouglas Gregor case CallExprClass: 58888a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor case CXXOperatorCallExprClass: 58988a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor case CXXMemberCallExprClass: { 5909d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.call]p10: 5919d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // A function call is an lvalue if and only if the result type 5929d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // is a reference. 59327c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor QualType CalleeType = cast<CallExpr>(this)->getCallee()->getType(); 5949d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor if (const PointerType *FnTypePtr = CalleeType->getAsPointerType()) 59588a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor CalleeType = FnTypePtr->getPointeeType(); 59688a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor if (const FunctionType *FnType = CalleeType->getAsFunctionType()) 59788a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor if (FnType->getResultType()->isReferenceType()) 59888a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor return LV_Valid; 5999d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor 6009d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor break; 6019d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor } 602e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff case CompoundLiteralExprClass: // C99 6.5.2.5p5 603e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff return LV_Valid; 604670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner case ChooseExprClass: 605670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner // __builtin_choose_expr is an lvalue if the selected operand is. 606670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner if (cast<ChooseExpr>(this)->isConditionTrue(Ctx)) 607670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner return cast<ChooseExpr>(this)->getLHS()->isLvalue(Ctx); 608670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner else 609670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner return cast<ChooseExpr>(this)->getRHS()->isLvalue(Ctx); 610670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner 611213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case ExtVectorElementExprClass: 612213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 613fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_DuplicateVectorComponents; 614fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_Valid; 615027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 616027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff return LV_Valid; 617799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff case ObjCPropertyRefExprClass: // FIXME: check if read-only property. 618799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff return LV_Valid; 6195daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian case ObjCKVCRefExprClass: // FIXME: check if read-only property. 620670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner return LV_Valid; 621d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 622796da18402f286b897782a298ae3b20c459c102eDouglas Gregor return LV_Valid; 6239d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case VAArgExprClass: 624adadd8db2aba32f689e7057d8b7ce004be30685bDaniel Dunbar return LV_NotObjectType; 62504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 62628be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx); 62724b41fa8239c63b9eb570d3e83c4a82840656a65Argyrios Kyrtzidis case CXXConditionDeclExprClass: 62824b41fa8239c63b9eb570d3e83c4a82840656a65Argyrios Kyrtzidis return LV_Valid; 6296eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 6309d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXFunctionalCastExprClass: 6319d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXStaticCastExprClass: 6329d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXDynamicCastExprClass: 6339d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXReinterpretCastExprClass: 6349d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXConstCastExprClass: 6359d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // The result of an explicit cast is an lvalue if the type we are 6369d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // casting to is a reference type. See C++ [expr.cast]p1, 6379d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2, 6389d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1. 6399d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()->isReferenceType()) 6409d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor return LV_Valid; 6419d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor break; 642c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl case CXXTypeidExprClass: 643c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ... 644c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl return LV_Valid; 6455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 6465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 6475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 6485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_InvalidExpression; 6495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 6525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// does not have an incomplete type, does not have a const-qualified type, and 6535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// if it is a structure or union, does not have any member (including, 6545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// recursively, any member or element of all contained aggregates or unions) 6555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// with a const-qualified type. 65628be73f74c9e241a23ea24fe5756623de6bf1084Chris LattnerExpr::isModifiableLvalueResult Expr::isModifiableLvalue(ASTContext &Ctx) const { 65728be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner isLvalueResult lvalResult = isLvalue(Ctx); 6585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (lvalResult) { 660ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor case LV_Valid: 661ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor // C++ 3.10p11: Functions cannot be modified, but pointers to 662ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor // functions can be modifiable. 663ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 664ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor return MLV_NotObjectType; 665ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor break; 666ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor 6675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_NotObjectType: return MLV_NotObjectType; 6685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 669fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 670ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner case LV_InvalidExpression: 671ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // If the top level is a C-style cast, and the subexpression is a valid 672ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // lvalue, then this is probably a use of the old-school "cast as lvalue" 673ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // GCC extension. We don't support it, but we want to produce good 674ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // diagnostics when it happens so that the user knows why. 675ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(this)) 676ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) 677ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner return MLV_LValueCast; 678ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner return MLV_InvalidExpression; 67986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor case LV_MemberFunction: return MLV_MemberFunction; 6805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 681c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 682c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType CT = Ctx.getCanonicalType(getType()); 683c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 684c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT.isConstQualified()) 6855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 686c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isArrayType()) 6875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ArrayType; 688c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isIncompleteType()) 6895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_IncompleteType; 6905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 691c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const RecordType *r = CT->getAsRecordType()) { 6925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (r->hasConstFields()) 6935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 6945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 6954f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // The following is illegal: 6964f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // void takeclosure(void (^C)(void)); 6974f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // void func() { int x = 1; takeclosure(^{ x = 7 }); } 6984f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff // 6994f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (getStmtClass() == BlockDeclRefExprClass) { 7004f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 7014f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl())) 7024f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff return MLV_NotBlockQualified; 7034f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff } 704d1fa6449e9dbdd667466e9e1e971aa17c9793e8aFariborz Jahanian 705ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian // Assigning to an 'implicit' property? 7066669db9d80d77d10f101aa9f8e488bbd2d98f76cFariborz Jahanian else if (getStmtClass() == ObjCKVCRefExprClass) { 707ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian const ObjCKVCRefExpr* KVCExpr = cast<ObjCKVCRefExpr>(this); 708ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian if (KVCExpr->getSetterMethod() == 0) 709ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian return MLV_NoSetterProperty; 710ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian } 7115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_Valid; 7125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 7135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7142e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek/// hasGlobalStorage - Return true if this expression has static storage 7154cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// duration. This means that the address of this expression is a link-time 7164cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// constant. 7172e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenekbool Expr::hasGlobalStorage() const { 7181d09ecca892185ba067e47ba879f424de59950efChris Lattner switch (getStmtClass()) { 7191d09ecca892185ba067e47ba879f424de59950efChris Lattner default: 7201d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 7214cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ParenExprClass: 7222e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage(); 7234cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ImplicitCastExprClass: 7242e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage(); 725e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff case CompoundLiteralExprClass: 726e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff return cast<CompoundLiteralExpr>(this)->isFileScope(); 7271a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case DeclRefExprClass: 7281a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case QualifiedDeclRefExprClass: { 7291d09ecca892185ba067e47ba879f424de59950efChris Lattner const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 7301d09ecca892185ba067e47ba879f424de59950efChris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 7312e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return VD->hasGlobalStorage(); 73263f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon if (isa<FunctionDecl>(D)) 73363f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon return true; 7341d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 7351d09ecca892185ba067e47ba879f424de59950efChris Lattner } 736fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner case MemberExprClass: { 7371d09ecca892185ba067e47ba879f424de59950efChris Lattner const MemberExpr *M = cast<MemberExpr>(this); 7382e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return !M->isArrow() && M->getBase()->hasGlobalStorage(); 739fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner } 7404cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ArraySubscriptExprClass: 7412e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage(); 742d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 743fa28b30d5a1e93e5263be33e343532b900d2c643Chris Lattner return true; 74404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 74504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage(); 7461d09ecca892185ba067e47ba879f424de59950efChris Lattner } 7471d09ecca892185ba067e47ba879f424de59950efChris Lattner} 7481d09ecca892185ba067e47ba879f424de59950efChris Lattner 74944baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian/// isOBJCGCCandidate - Check if an expression is objc gc'able. 75044baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian/// 75144baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanianbool Expr::isOBJCGCCandidate() const { 75244baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian switch (getStmtClass()) { 75344baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian default: 75444baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return false; 75544baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ObjCIvarRefExprClass: 75644baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return true; 757207c5210eb0ac7b632609f0c006eb97ef2738948Fariborz Jahanian case Expr::UnaryOperatorClass: 758207c5210eb0ac7b632609f0c006eb97ef2738948Fariborz Jahanian return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate(); 75944baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ParenExprClass: 76044baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate(); 76144baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ImplicitCastExprClass: 76244baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(); 76344baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case DeclRefExprClass: 76444baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case QualifiedDeclRefExprClass: { 76544baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 76644baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 76744baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return VD->hasGlobalStorage(); 76844baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return false; 76944baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian } 77044baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case MemberExprClass: { 77144baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian const MemberExpr *M = cast<MemberExpr>(this); 77244baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return !M->isArrow() && M->getBase()->isOBJCGCCandidate(); 77344baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian } 77444baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ArraySubscriptExprClass: 77544baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate(); 77644baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian } 77744baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian} 7784e99a5fc3b203397a91136c6e695e405fb8fc606Ted KremenekExpr* Expr::IgnoreParens() { 7794e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek Expr* E = this; 7804e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 7814e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek E = P->getSubExpr(); 7824e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 7834e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek return E; 7844e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek} 7854e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 78656f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 78756f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// or CastExprs or ImplicitCastExprs, returning their operand. 78856f349400c5932a196509c0480ff6f99a9a0b48fChris LattnerExpr *Expr::IgnoreParenCasts() { 78956f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner Expr *E = this; 79056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner while (true) { 79156f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 79256f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 79356f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else if (CastExpr *P = dyn_cast<CastExpr>(E)) 79456f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 79556f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else 79656f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner return E; 79756f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner } 79856f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner} 79956f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner 800898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// hasAnyTypeDependentArguments - Determines if any of the expressions 801898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// in Exprs is type-dependent. 802898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorbool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) { 803898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor for (unsigned I = 0; I < NumExprs; ++I) 804898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (Exprs[I]->isTypeDependent()) 805898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return true; 806898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 807898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return false; 808898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 809898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 810898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// hasAnyValueDependentArguments - Determines if any of the expressions 811898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// in Exprs is value-dependent. 812898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorbool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) { 813898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor for (unsigned I = 0; I < NumExprs; ++I) 814898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (Exprs[I]->isValueDependent()) 815898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return true; 816898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 817898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return false; 818898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 819898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 820c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedmanbool Expr::isConstantInitializer(ASTContext &Ctx) const { 821c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // This function is attempting whether an expression is an initializer 822c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // which can be evaluated at compile-time. isEvaluatable handles most 823c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // of the cases, but it can't deal with some initializer-specific 824c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // expressions, and it can't deal with aggregates; we deal with those here, 825c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // and fall back to isEvaluatable for the other cases. 826c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman 8271f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This function assumes the variable being assigned to 8281f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // isn't a reference type! 8291f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman 830e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson switch (getStmtClass()) { 831c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman default: break; 832e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson case StringLiteralClass: 833eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case ObjCEncodeExprClass: 834e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson return true; 83559b5da6d853b4368b984700315adf7b37de05764Nate Begeman case CompoundLiteralExprClass: { 8361f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // This handles gcc's extension that allows global initializers like 8371f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // "struct x {int x;} x = (struct x) {};". 8381f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This accepts other cases it shouldn't! 83959b5da6d853b4368b984700315adf7b37de05764Nate Begeman const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer(); 840c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedman return Exp->isConstantInitializer(Ctx); 84159b5da6d853b4368b984700315adf7b37de05764Nate Begeman } 842e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson case InitListExprClass: { 8431f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This doesn't deal with fields with reference types correctly. 8441f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This incorrectly allows pointers cast to integers to be assigned 8451f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // to bitfields. 846e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson const InitListExpr *Exp = cast<InitListExpr>(this); 847e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson unsigned numInits = Exp->getNumInits(); 848e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson for (unsigned i = 0; i < numInits; i++) { 849c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedman if (!Exp->getInit(i)->isConstantInitializer(Ctx)) 850e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson return false; 851e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 852c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return true; 853e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 8543498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor case ImplicitValueInitExprClass: 8553498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return true; 856c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case ParenExprClass: { 857c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 858c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman } 859c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case UnaryOperatorClass: { 860c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman const UnaryOperator* Exp = cast<UnaryOperator>(this); 861c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman if (Exp->getOpcode() == UnaryOperator::Extension) 862c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return Exp->getSubExpr()->isConstantInitializer(Ctx); 863c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman break; 864c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman } 865c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case CStyleCastExprClass: 866c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // Handle casts with a destination that's a struct or union; this 867c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // deals with both the gcc no-op struct cast extension and the 868c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // cast-to-union extension. 869c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman if (getType()->isRecordType()) 870c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 871c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman break; 872e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 873e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson 874c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return isEvaluatable(Ctx); 87538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff} 87638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 8775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isIntegerConstantExpr - this recursive routine will test if an expression is 878e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman/// an integer constant expression. 8795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 8815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// comma, etc 8825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 883ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof 884ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer 885ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// cast+dereference. 8862d6744ff04c1690a1485178d550d2fab84a0270bDaniel Dunbar 887e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// CheckICE - This function does the fundamental ICE checking: the returned 888e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// ICEDiag contains a Val of 0, 1, or 2, and a possibly null SourceLocation. 889e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// Note that to reduce code duplication, this helper does no evaluation 890e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// itself; the caller checks whether the expression is evaluatable, and 891e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// in the rare cases where CheckICE actually cares about the evaluated 892e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// value, it calls into Evalute. 893e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 894e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// Meanings of Val: 895e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 0: This expression is an ICE if it can be evaluated by Evaluate. 896e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 1: This expression is not an ICE, but if it isn't evaluated, it's 897e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// a legal subexpression for an ICE. This return value is used to handle 898e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// the comma operator in C99 mode. 899e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 2: This expression is not an ICE, and is not a legal subexpression for one. 900e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 901e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedmanstruct ICEDiag { 902e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman unsigned Val; 903e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman SourceLocation Loc; 904e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 905e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman public: 906e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag(unsigned v, SourceLocation l) : Val(v), Loc(l) {} 907e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag() : Val(0) {} 908e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman}; 909e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 910e28d7195aad595154130ac8d03cc6c6513ece1bfEli FriedmanICEDiag NoDiag() { return ICEDiag(); } 911e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 912e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedmanstatic ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) { 913e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (!E->getType()->isIntegralType()) { 914e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 915a6afa768aa7bd3102a2807aa720917e4a1771e4eEli Friedman } 916e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 917e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman switch (E->getStmtClass()) { 9185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 919e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 920e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::ParenExprClass: 921e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx); 922e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::IntegerLiteralClass: 923e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CharacterLiteralClass: 924e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXBoolLiteralExprClass: 925e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXZeroInitValueExprClass: 926e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::TypesCompatibleExprClass: 927e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::UnaryTypeTraitExprClass: 928e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 929e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CallExprClass: 930e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXOperatorCallExprClass: { 931e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const CallExpr *CE = cast<CallExpr>(E); 932e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (CE->isBuiltinCall(Ctx) && CE->isEvaluatable(Ctx)) 933e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 934e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 93513b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff } 936e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::DeclRefExprClass: 937e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::QualifiedDeclRefExprClass: 938e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl())) 939e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 9404a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (Ctx.getLangOptions().CPlusPlus && 941e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman E->getType().getCVRQualifiers() == QualType::Const) { 9424a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // C++ 7.1.5.1p2 9434a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // A variable of non-volatile const-qualified integral or enumeration 9444a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // type initialized by an ICE can be used in ICEs. 9454a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (const VarDecl *Dcl = 946e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) { 9474a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (const Expr *Init = Dcl->getInit()) 948e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(Init, Ctx); 9494a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl } 9504a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl } 951e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 952e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::UnaryOperatorClass: { 953e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const UnaryOperator *Exp = cast<UnaryOperator>(E); 9545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 9555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 956e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 9575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 958e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case UnaryOperator::LNot: 9595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Plus: 9605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Minus: 9615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Not: 962e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(Exp->getSubExpr(), Ctx); 9635a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson case UnaryOperator::OffsetOf: 964e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // Note that per C99, a non-constant offsetof is illegal. 965e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // FIXME: Do we need to check whether this is evaluatable? 966e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 9675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 969e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::SizeOfAlignOfExprClass: { 970e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(E); 971e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (Exp->isSizeOf() && Exp->getTypeOfArgument()->isVariableArrayType()) 972e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 973e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 9745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 975e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::BinaryOperatorClass: { 976e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const BinaryOperator *Exp = cast<BinaryOperator>(E); 9775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 9785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 979e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 9805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Mul: 9815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Div: 9825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Rem: 983e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Add: 984e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Sub: 9855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shl: 9865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shr: 987e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LT: 988e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::GT: 989e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LE: 990e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::GE: 991e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::EQ: 992e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::NE: 993e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::And: 994e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Xor: 995e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Or: 996e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Comma: { 997e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 998e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 999e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (Exp->getOpcode() == BinaryOperator::Comma && 1000e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman Ctx.getLangOptions().C99) { 1001e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // C99 6.6p3 introduces a strange edge case: comma can be in an ICE 1002e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // if it isn't evaluated. 1003e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (LHSResult.Val == 0 && RHSResult.Val == 0) 1004e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(1, E->getLocStart()); 1005b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman } 1006e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (LHSResult.Val >= RHSResult.Val) 1007e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return LHSResult; 1008e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return RHSResult; 10095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1010e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LAnd: 1011e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LOr: { 1012e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 1013e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 1014e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (LHSResult.Val == 0 && RHSResult.Val == 1) { 1015e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // Rare case where the RHS has a comma "side-effect"; we need 1016e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // to actually check the condition to see whether the side 1017e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // with the comma is evaluated. 1018e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman Expr::EvalResult Result; 1019e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (!Exp->getLHS()->Evaluate(Result, Ctx)) 1020e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(1, E->getLocStart()); 1021e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if ((Exp->getOpcode() == BinaryOperator::LAnd) != 1022e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman (Result.Val.getInt() == 0)) 1023e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return RHSResult; 1024e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1025a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar } 1026e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 1027e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (LHSResult.Val >= RHSResult.Val) 1028e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return LHSResult; 1029e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return RHSResult; 10305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1031987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner } 10325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1033e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::ImplicitCastExprClass: 1034e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CStyleCastExprClass: 1035e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXFunctionalCastExprClass: { 1036e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr(); 1037e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (SubExpr->getType()->isIntegralType()) 1038e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(SubExpr, Ctx); 1039e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (isa<FloatingLiteral>(SubExpr->IgnoreParens())) 1040e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1041e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1042e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1043e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::ConditionalOperatorClass: { 1044e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const ConditionalOperator *Exp = cast<ConditionalOperator>(E); 104528daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner // If the condition (ignoring parens) is a __builtin_constant_p call, 104628daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner // then only the true side is actually considered in an integer constant 104742b83dde7c700b34f9435ad746984169888ae705Chris Lattner // expression, and it is fully evaluated. This is an important GNU 104842b83dde7c700b34f9435ad746984169888ae705Chris Lattner // extension. See GCC PR38377 for discussion. 1049e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (const CallExpr *CallCE = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts())) 10503c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) { 1051e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman Expr::EvalResult EVResult; 1052e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects || 1053e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman !EVResult.Val.isInt()) { 1054e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag(2, E->getLocStart()); 1055e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1056e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 105742b83dde7c700b34f9435ad746984169888ae705Chris Lattner } 1058e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx); 1059e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx); 1060e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx); 1061e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (CondResult.Val == 2) 1062e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CondResult; 1063e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (TrueResult.Val == 2) 1064e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return TrueResult; 1065e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (FalseResult.Val == 2) 1066e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return FalseResult; 1067e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (CondResult.Val == 1) 1068e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CondResult; 1069e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (TrueResult.Val == 0 && FalseResult.Val == 0) 1070e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1071e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // Rare case where the diagnostics depend on which side is evaluated 1072e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // Note that if we get here, CondResult is 0, and at least one of 1073e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // TrueResult and FalseResult is non-zero. 1074e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman Expr::EvalResult Result; 1075e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (!Exp->getCond()->Evaluate(Result, Ctx)) 1076e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(1, E->getLocStart()); 1077e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (Result.Val.getInt() == 0) { 1078e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return FalseResult; 1079e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1080e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return TrueResult; 10815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1082e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXDefaultArgExprClass: 1083e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx); 10845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1085e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman} 10865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1087e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedmanbool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, 1088e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman SourceLocation *Loc, bool isEvaluated) const { 1089e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag d = CheckICE(this, Ctx); 1090e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (d.Val != 0) { 1091e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (Loc) *Loc = d.Loc; 1092e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return false; 1093e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1094e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman EvalResult EvalResult; 1095e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (!Evaluate(EvalResult, Ctx) || EvalResult.HasSideEffects || 1096e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman !EvalResult.Val.isInt()) { 1097e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (Loc) *Loc = EvalResult.DiagLoc; 1098e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return false; 1099e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1100e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman Result = EvalResult.Val.getInt(); 11015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 11025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 11035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 11045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an 11055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// integer constant expression with the value zero, or if this is one that is 11065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// cast to void*. 1107efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlssonbool Expr::isNullPointerConstant(ASTContext &Ctx) const 1108efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlsson{ 11090777972d38a3125efed962b045704c30ae6965cfSebastian Redl // Strip off a cast to void*, if it exists. Except in C++. 11100835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 11116215dee86c0e715b9f2b0d401ab2a5fcf629f1afSebastian Redl if (!Ctx.getLangOptions().CPlusPlus) { 11120777972d38a3125efed962b045704c30ae6965cfSebastian Redl // Check that it is a cast to void*. 11130777972d38a3125efed962b045704c30ae6965cfSebastian Redl if (const PointerType *PT = CE->getType()->getAsPointerType()) { 11140777972d38a3125efed962b045704c30ae6965cfSebastian Redl QualType Pointee = PT->getPointeeType(); 11150777972d38a3125efed962b045704c30ae6965cfSebastian Redl if (Pointee.getCVRQualifiers() == 0 && 11160777972d38a3125efed962b045704c30ae6965cfSebastian Redl Pointee->isVoidType() && // to void* 11170777972d38a3125efed962b045704c30ae6965cfSebastian Redl CE->getSubExpr()->getType()->isIntegerType()) // from int. 1118d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return CE->getSubExpr()->isNullPointerConstant(Ctx); 11190777972d38a3125efed962b045704c30ae6965cfSebastian Redl } 11205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1121aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1122aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Ignore the ImplicitCastExpr type entirely. 1123d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return ICE->getSubExpr()->isNullPointerConstant(Ctx); 1124aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1125aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Accept ((void*)0) as a null pointer constant, as many other 1126aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // implementations do. 1127d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return PE->getSubExpr()->isNullPointerConstant(Ctx); 11288123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner } else if (const CXXDefaultArgExpr *DefaultArg 11298123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner = dyn_cast<CXXDefaultArgExpr>(this)) { 113004421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner // See through default argument expressions 1131d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return DefaultArg->getExpr()->isNullPointerConstant(Ctx); 11322d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor } else if (isa<GNUNullExpr>(this)) { 11332d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor // The GNU __null extension is always a null pointer constant. 11342d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor return true; 1135aaffbf7c790a324ed114184db771aae2d2e9151cSteve Naroff } 11362d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor 1137aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // This expression must be an integer type. 1138aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff if (!getType()->isIntegerType()) 1139aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return false; 1140aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff 11415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If we have an integer constant expression, we need to *evaluate* it and 11425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // test for the value 0. 1143d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson // FIXME: We should probably return false if we're compiling in strict mode 1144d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson // and Diag is not null (this indicates that the value was foldable but not 1145d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson // an ICE. 1146d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson EvalResult Result; 1147efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlsson return Evaluate(Result, Ctx) && !Result.HasSideEffects && 1148d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson Result.Val.isInt() && Result.Val.getInt() == 0; 11495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 115031a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff 115127c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor/// isBitField - Return true if this expression is a bit-field. 115227c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregorbool Expr::isBitField() { 115327c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor Expr *E = this->IgnoreParenCasts(); 115427c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 115586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl())) 115686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return Field->isBitField(); 115727c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor return false; 115827c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor} 115927c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor 11602140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner/// isArrow - Return true if the base expression is a pointer to vector, 11612140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner/// return false if the base expression is a vector. 11622140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattnerbool ExtVectorElementExpr::isArrow() const { 11632140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner return getBase()->getType()->isPointerType(); 11642140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner} 11652140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner 1166213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanunsigned ExtVectorElementExpr::getNumElements() const { 11678a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (const VectorType *VT = getType()->getAsVectorType()) 11688a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return VT->getNumElements(); 11698a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return 1; 11704d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner} 11714d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner 11728a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// containsDuplicateElements - Return true if any element access is repeated. 1173213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanbool ExtVectorElementExpr::containsDuplicateElements() const { 1174fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *compStr = Accessor.getName(); 11757e3e9b152e06edf329ceb32190d3255f248d4d5fChris Lattner unsigned length = Accessor.getLength(); 1176190d6a25393995b42e32086949a68285ee423fb9Nate Begeman 1177190d6a25393995b42e32086949a68285ee423fb9Nate Begeman // Halving swizzles do not contain duplicate elements. 1178190d6a25393995b42e32086949a68285ee423fb9Nate Begeman if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") || 1179190d6a25393995b42e32086949a68285ee423fb9Nate Begeman !strcmp(compStr, "even") || !strcmp(compStr, "odd")) 1180190d6a25393995b42e32086949a68285ee423fb9Nate Begeman return false; 1181190d6a25393995b42e32086949a68285ee423fb9Nate Begeman 1182190d6a25393995b42e32086949a68285ee423fb9Nate Begeman // Advance past s-char prefix on hex swizzles. 1183190d6a25393995b42e32086949a68285ee423fb9Nate Begeman if (*compStr == 's') { 1184190d6a25393995b42e32086949a68285ee423fb9Nate Begeman compStr++; 1185190d6a25393995b42e32086949a68285ee423fb9Nate Begeman length--; 1186190d6a25393995b42e32086949a68285ee423fb9Nate Begeman } 1187fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff 11887e3e9b152e06edf329ceb32190d3255f248d4d5fChris Lattner for (unsigned i = 0; i != length-1; i++) { 1189fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *s = compStr+i; 1190fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff for (const char c = *s++; *s; s++) 1191fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff if (c == *s) 1192fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return true; 1193fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff } 1194fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return false; 1195fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff} 1196b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 11978a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 11983b8d116703db8018f855cbb4733ace426422623bNate Begemanvoid ExtVectorElementExpr::getEncodedElementAccess( 11993b8d116703db8018f855cbb4733ace426422623bNate Begeman llvm::SmallVectorImpl<unsigned> &Elts) const { 12007e3e9b152e06edf329ceb32190d3255f248d4d5fChris Lattner const char *compStr = Accessor.getName(); 1201353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman if (*compStr == 's') 1202353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman compStr++; 1203353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman 1204353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isHi = !strcmp(compStr, "hi"); 1205353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isLo = !strcmp(compStr, "lo"); 1206353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isEven = !strcmp(compStr, "even"); 1207353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isOdd = !strcmp(compStr, "odd"); 1208353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman 12098a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 12108a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman uint64_t Index; 12118a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 12128a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (isHi) 12138a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = e + i; 12148a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isLo) 12158a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = i; 12168a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isEven) 12178a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i; 12188a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isOdd) 12198a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i + 1; 12208a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else 12218a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = ExtVectorType::getAccessorIdx(compStr[i]); 1222b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 12233b8d116703db8018f855cbb4733ace426422623bNate Begeman Elts.push_back(Index); 1224b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner } 12258a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman} 12268a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 122768d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for instance messages. 1228bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1229a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1230db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 123149f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1232db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1233ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 123449f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 12355549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 123668d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[RECEIVER] = receiver; 123749f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 123849f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 123968d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 124068d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1241563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1242563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1243563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1244563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 124568d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for class messages. 124668d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// FIXME: clsName should be typed to ObjCInterfaceType 1247bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1248a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1249db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 125049f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1251db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1252ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 125349f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 12545549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 12554df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown); 125649f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 125749f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 125868d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 125968d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1260563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1261563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1262563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1263563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 12644df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek// constructor for class messages. 12654df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo, 12664df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek QualType retType, ObjCMethodDecl *mproto, 12674df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SourceLocation LBrac, SourceLocation RBrac, 12684df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek Expr **ArgExprs, unsigned nargs) 12694df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek: Expr(ObjCMessageExprClass, retType), SelName(selInfo), 12704df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekMethodProto(mproto) { 12714df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek NumArgs = nargs; 12724df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 12734df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown); 12744df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek if (NumArgs) { 12754df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek for (unsigned i = 0; i != NumArgs; ++i) 12764df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 12774df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 12784df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek LBracloc = LBrac; 12794df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek RBracloc = RBrac; 12804df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 12814df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 12824df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const { 12834df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek uintptr_t x = (uintptr_t) SubExprs[RECEIVER]; 12844df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek switch (x & Flags) { 12854df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek default: 12864df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek assert(false && "Invalid ObjCMessageExpr."); 12874df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsInstMeth: 12884df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, 0); 12894df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclUnknown: 12904df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, (IdentifierInfo*) (x & ~Flags)); 12914df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclKnown: { 12924df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags); 12934df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(D, D->getIdentifier()); 12944df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 12954df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 12964df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 12974df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 129827437caadea35f84d550cd29f024fcf3ea240eecChris Lattnerbool ChooseExpr::isConditionTrue(ASTContext &C) const { 129932442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar return getCond()->getIntegerConstantExprValue(C) != 0; 130027437caadea35f84d550cd29f024fcf3ea240eecChris Lattner} 130127437caadea35f84d550cd29f024fcf3ea240eecChris Lattner 1302670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattnerstatic int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) { 13035a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 13045a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson QualType Ty = ME->getBase()->getType(); 13055a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 13065a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson RecordDecl *RD = Ty->getAsRecordType()->getDecl(); 130798be4943e8dc4f3905629a7102668960873cf863Chris Lattner const ASTRecordLayout &RL = C.getASTRecordLayout(RD); 130886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) { 130986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // FIXME: This is linear time. And the fact that we're indexing 131086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // into the layout by position in the record means that we're 131186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // either stuck numbering the fields in the AST or we have to keep 131286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // the linear search (yuck and yuck). 131386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor unsigned i = 0; 131486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor for (RecordDecl::field_iterator Field = RD->field_begin(), 131586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor FieldEnd = RD->field_end(); 131686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor Field != FieldEnd; (void)++Field, ++i) { 131786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (*Field == FD) 131886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor break; 131986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor } 132086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 132186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase()); 13225a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } 13235a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) { 13245a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson const Expr *Base = ASE->getBase(); 13255a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 132698be4943e8dc4f3905629a7102668960873cf863Chris Lattner int64_t size = C.getTypeSize(ASE->getType()); 132732442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar size *= ASE->getIdx()->getIntegerConstantExprValue(C).getSExtValue(); 13285a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 13295a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return size + evaluateOffsetOf(C, Base); 13305a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } else if (isa<CompoundLiteralExpr>(E)) 13315a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return 0; 13325a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 13335a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson assert(0 && "Unknown offsetof subexpression!"); 13345a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return 0; 13355a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 13365a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 13375a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlssonint64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const 13385a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson{ 13395a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson assert(Opc == OffsetOf && "Unary operator not offsetof!"); 13405a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 134198be4943e8dc4f3905629a7102668960873cf863Chris Lattner unsigned CharSize = C.Target.getCharWidth(); 13425549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize; 13435a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 13445a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 13450518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redlvoid SizeOfAlignOfExpr::Destroy(ASTContext& C) { 13460518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // Override default behavior of traversing children. If this has a type 13470518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // operand and the type is a variable-length array, the child iteration 13480518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // will iterate over the size expression. However, this expression belongs 13490518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // to the type, not to this, so we don't want to delete it. 13500518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // We still want to delete this expression. 13518189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek if (isArgumentType()) { 13528189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek this->~SizeOfAlignOfExpr(); 13538189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek C.Deallocate(this); 13548189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek } 13550518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl else 13560518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl Expr::Destroy(C); 13579048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar} 13589048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar 135977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 136005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor// DesignatedInitExpr 136105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor//===----------------------------------------------------------------------===// 136205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 136305c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorIdentifierInfo *DesignatedInitExpr::Designator::getFieldName() { 136405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(Kind == FieldDesignator && "Only valid on a field designator"); 136505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (Field.NameOrField & 0x01) 136605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01); 136705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else 136805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return getField()->getIdentifier(); 136905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 137005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 137105c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr * 137205c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr::Create(ASTContext &C, Designator *Designators, 137305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor unsigned NumDesignators, 137405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Expr **IndexExprs, unsigned NumIndexExprs, 137505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor SourceLocation ColonOrEqualLoc, 137605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor bool UsesColonSyntax, Expr *Init) { 1377c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 1378c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff sizeof(Designator) * NumDesignators + 1379c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff sizeof(Stmt *) * (NumIndexExprs + 1), 8); 138005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor DesignatedInitExpr *DIE 138105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor = new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators, 138205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ColonOrEqualLoc, UsesColonSyntax, 138305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor NumIndexExprs + 1); 138405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 138505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor // Fill in the designators 138605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor unsigned ExpectedNumSubExprs = 0; 138705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor designators_iterator Desig = DIE->designators_begin(); 138805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor for (unsigned Idx = 0; Idx < NumDesignators; ++Idx, ++Desig) { 138905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor new (static_cast<void*>(Desig)) Designator(Designators[Idx]); 139005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (Designators[Idx].isArrayDesignator()) 139105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ++ExpectedNumSubExprs; 139205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else if (Designators[Idx].isArrayRangeDesignator()) 139305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ExpectedNumSubExprs += 2; 139405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor } 139505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(ExpectedNumSubExprs == NumIndexExprs && "Wrong number of indices!"); 139605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 139705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor // Fill in the subexpressions, including the initializer expression. 139805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor child_iterator Child = DIE->child_begin(); 139905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor *Child++ = Init; 140005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor for (unsigned Idx = 0; Idx < NumIndexExprs; ++Idx, ++Child) 140105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor *Child = IndexExprs[Idx]; 140205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 140305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return DIE; 140405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 140505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 140605c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorSourceRange DesignatedInitExpr::getSourceRange() const { 140705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor SourceLocation StartLoc; 1408d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner Designator &First = 1409d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner *const_cast<DesignatedInitExpr*>(this)->designators_begin(); 141005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (First.isFieldDesignator()) { 141105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (UsesColonSyntax) 141205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc); 141305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else 141405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc); 141505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor } else 1416d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner StartLoc = 1417d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc); 141805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return SourceRange(StartLoc, getInit()->getSourceRange().getEnd()); 141905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 142005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 1421d603eaa682cecac2c10771a700cb83aa301653b4Chris LattnerDesignatedInitExpr::designators_iterator 1422d603eaa682cecac2c10771a700cb83aa301653b4Chris LattnerDesignatedInitExpr::designators_begin() { 142305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 142405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 142505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return static_cast<Designator*>(static_cast<void*>(Ptr)); 142605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 142705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 142805c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr::designators_iterator DesignatedInitExpr::designators_end() { 142905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return designators_begin() + NumDesignators; 143005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 143105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 143205c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayIndex(const Designator& D) { 143305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayDesignator && "Requires array designator"); 143405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 143505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 143605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 143705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 143805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 143905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 144005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 144105c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) { 144205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayRangeDesignator && 144305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor "Requires array range designator"); 144405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 144505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 144605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 144705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 144805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 144905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 145005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 145105c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) { 145205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayRangeDesignator && 145305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor "Requires array range designator"); 145405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 145505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 145605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 145705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 145805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2)); 145905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 146005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 146105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor//===----------------------------------------------------------------------===// 1462ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek// ExprIterator. 1463ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek//===----------------------------------------------------------------------===// 1464ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek 1465ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 1466ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator*() const { return cast<Expr>(*I); } 1467ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator->() const { return cast<Expr>(*I); } 1468ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator[](size_t idx) const { 1469ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek return cast<Expr>(I[idx]); 1470ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek} 1471ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 1472ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 1473ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek 1474ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek//===----------------------------------------------------------------------===// 147577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// Child Iterators for iterating over subexpressions/substatements 147677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 147777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 147877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// DeclRefExpr 14799ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 14809ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 148177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 14827779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff// ObjCIvarRefExpr 14835549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; } 14845549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; } 14857779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff 1486e3e9add4fd788927df6f545570e7838db59c01d7Steve Naroff// ObjCPropertyRefExpr 14875549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; } 14885549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; } 1489ae7840776d6cd31b4d7a4a345b61bcbb3744df6cSteve Naroff 14905daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian// ObjCKVCRefExpr 14915daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz JahanianStmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; } 14925daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz JahanianStmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; } 14935daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian 1494cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas Gregor// ObjCSuperExpr 1495cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas GregorStmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); } 1496cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas GregorStmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); } 1497cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas Gregor 1498d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner// PredefinedExpr 1499d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); } 1500d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); } 150177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 150277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// IntegerLiteral 15039ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 15049ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 150577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 150677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CharacterLiteral 1507d603eaa682cecac2c10771a700cb83aa301653b4Chris LattnerStmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();} 15089ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 150977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 151077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// FloatingLiteral 15119ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 15129ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 151377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 15145d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner// ImaginaryLiteral 15155549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; } 15165549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; } 15175d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner 151877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// StringLiteral 15199ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 15209ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 152177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 152277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ParenExpr 15235549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_begin() { return &Val; } 15245549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_end() { return &Val+1; } 152577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 152677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// UnaryOperator 15275549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_begin() { return &Val; } 15285549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_end() { return &Val+1; } 152977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 15300518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl// SizeOfAlignOfExpr 15310518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlStmt::child_iterator SizeOfAlignOfExpr::child_begin() { 15320518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // If this is of a type and the type is a VLA type (and not a typedef), the 15330518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // size expression of the VLA needs to be treated as an executable expression. 15340518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // Why isn't this weirdness documented better in StmtIterator? 15350518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (isArgumentType()) { 15360518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (VariableArrayType* T = dyn_cast<VariableArrayType>( 15370518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl getArgumentType().getTypePtr())) 15380518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(T); 15390518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(); 15400518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl } 1541d457589fc69dc7a9c80cd74d317c0b81a35a27c9Sebastian Redl return child_iterator(&Argument.Ex); 15429ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 15430518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlStmt::child_iterator SizeOfAlignOfExpr::child_end() { 15440518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (isArgumentType()) 15450518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(); 1546d457589fc69dc7a9c80cd74d317c0b81a35a27c9Sebastian Redl return child_iterator(&Argument.Ex + 1); 15479ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 154877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 154977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ArraySubscriptExpr 15501237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_begin() { 15515549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 155277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 15531237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_end() { 15545549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 155577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 155677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 155777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CallExpr 15581237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_begin() { 15595549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 156077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 15611237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_end() { 15625549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumArgs+ARGS_START; 156377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 15641237c673c07f9d827129ba02720108816abde562Ted Kremenek 15651237c673c07f9d827129ba02720108816abde562Ted Kremenek// MemberExpr 15665549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_begin() { return &Base; } 15675549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_end() { return &Base+1; } 15681237c673c07f9d827129ba02720108816abde562Ted Kremenek 1569213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman// ExtVectorElementExpr 15705549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; } 15715549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; } 15721237c673c07f9d827129ba02720108816abde562Ted Kremenek 15731237c673c07f9d827129ba02720108816abde562Ted Kremenek// CompoundLiteralExpr 15745549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; } 15755549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; } 15761237c673c07f9d827129ba02720108816abde562Ted Kremenek 15771237c673c07f9d827129ba02720108816abde562Ted Kremenek// CastExpr 15785549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_begin() { return &Op; } 15795549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_end() { return &Op+1; } 15801237c673c07f9d827129ba02720108816abde562Ted Kremenek 15811237c673c07f9d827129ba02720108816abde562Ted Kremenek// BinaryOperator 15821237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_begin() { 15835549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 15841237c673c07f9d827129ba02720108816abde562Ted Kremenek} 15851237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_end() { 15865549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 15871237c673c07f9d827129ba02720108816abde562Ted Kremenek} 15881237c673c07f9d827129ba02720108816abde562Ted Kremenek 15891237c673c07f9d827129ba02720108816abde562Ted Kremenek// ConditionalOperator 15901237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_begin() { 15915549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 15921237c673c07f9d827129ba02720108816abde562Ted Kremenek} 15931237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_end() { 15945549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 15951237c673c07f9d827129ba02720108816abde562Ted Kremenek} 15961237c673c07f9d827129ba02720108816abde562Ted Kremenek 15971237c673c07f9d827129ba02720108816abde562Ted Kremenek// AddrLabelExpr 15989ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 15999ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 16001237c673c07f9d827129ba02720108816abde562Ted Kremenek 16011237c673c07f9d827129ba02720108816abde562Ted Kremenek// StmtExpr 16025549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_begin() { return &SubStmt; } 16035549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; } 16041237c673c07f9d827129ba02720108816abde562Ted Kremenek 16051237c673c07f9d827129ba02720108816abde562Ted Kremenek// TypesCompatibleExpr 16069ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_begin() { 16079ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 16089ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 16099ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek 16109ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_end() { 16119ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 16129ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 16131237c673c07f9d827129ba02720108816abde562Ted Kremenek 16141237c673c07f9d827129ba02720108816abde562Ted Kremenek// ChooseExpr 16155549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; } 16165549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; } 16172d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor 16182d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor// GNUNullExpr 16192d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas GregorStmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); } 16202d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas GregorStmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); } 16211237c673c07f9d827129ba02720108816abde562Ted Kremenek 1622d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman// ShuffleVectorExpr 1623d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_begin() { 16245549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 1625d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1626d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_end() { 16275549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumExprs; 1628d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1629d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 16307c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson// VAArgExpr 16315549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_begin() { return &Val; } 16325549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_end() { return &Val+1; } 16337c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 163466b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson// InitListExpr 163566b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_begin() { 16365549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] : 0; 163766b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 163866b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_end() { 16395549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0; 164066b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 164166b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson 16423498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor// DesignatedInitExpr 164305c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorStmt::child_iterator DesignatedInitExpr::child_begin() { 164405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 164505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 164605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(Designator) * NumDesignators; 164705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 164805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 164905c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorStmt::child_iterator DesignatedInitExpr::child_end() { 165005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return child_iterator(&*child_begin() + NumSubExprs); 165105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 165205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 16533498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor// ImplicitValueInitExpr 16543498bdb9e9cb300de74c7b51c92608e2902b2348Douglas GregorStmt::child_iterator ImplicitValueInitExpr::child_begin() { 16553498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return child_iterator(); 16563498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor} 16573498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor 16583498bdb9e9cb300de74c7b51c92608e2902b2348Douglas GregorStmt::child_iterator ImplicitValueInitExpr::child_end() { 16593498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return child_iterator(); 16603498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor} 16613498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor 16621237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCStringLiteral 16639ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_begin() { 1664c6c16af963eddc3e9b75b5d2614d069e1162fe27Chris Lattner return &String; 16659ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 16669ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_end() { 1667c6c16af963eddc3e9b75b5d2614d069e1162fe27Chris Lattner return &String+1; 16689ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 16691237c673c07f9d827129ba02720108816abde562Ted Kremenek 16701237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCEncodeExpr 16719ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 16729ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 16731237c673c07f9d827129ba02720108816abde562Ted Kremenek 1674b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian// ObjCSelectorExpr 16759ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_begin() { 16769ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 16779ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 16789ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_end() { 16799ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 16809ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1681b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 1682390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian// ObjCProtocolExpr 16839ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_begin() { 16849ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 16859ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 16869ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_end() { 16879ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 16889ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1689390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian 1690563477da25f824e37c535131695dc4dc9b68c465Steve Naroff// ObjCMessageExpr 1691ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted KremenekStmt::child_iterator ObjCMessageExpr::child_begin() { 16925549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START; 1693563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1694563477da25f824e37c535131695dc4dc9b68c465Steve NaroffStmt::child_iterator ObjCMessageExpr::child_end() { 16955549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+ARGS_START+getNumArgs(); 1696563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1697563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 16984eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff// Blocks 169956ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt::child_iterator BlockExpr::child_begin() { return child_iterator(); } 170056ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt::child_iterator BlockExpr::child_end() { return child_iterator(); } 17014eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff 17029da13f9ddb2567e36f4bbee7b3c32f54aeb76d5bTed KremenekStmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();} 17039da13f9ddb2567e36f4bbee7b3c32f54aeb76d5bTed KremenekStmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); } 1704