Expr.cpp revision 9a901bb63990574ff0bcc12ff851d7a71cff8ddb
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" 23ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor#include <algorithm> 245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Primary Expressions. 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 30a135fb43eb94524a6529768596a4533eed9aa70dAnders CarlssonIntegerLiteral* IntegerLiteral::Clone(ASTContext &C) const { 31a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson return new (C) IntegerLiteral(Value, getType(), Loc); 32a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson} 33a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson 34da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// getValueAsApproximateDouble - This returns the value as an inaccurate 35da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// double. Note that this may cause loss of precision, but is useful for 36da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// debugging dumps, etc. 37da8249e57f3badecf925571881fe57243935c6c1Chris Lattnerdouble FloatingLiteral::getValueAsApproximateDouble() const { 38da8249e57f3badecf925571881fe57243935c6c1Chris Lattner llvm::APFloat V = getValue(); 39ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen bool ignored; 40ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven, 41ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen &ignored); 42da8249e57f3badecf925571881fe57243935c6c1Chris Lattner return V.convertToDouble(); 43da8249e57f3badecf925571881fe57243935c6c1Chris Lattner} 44da8249e57f3badecf925571881fe57243935c6c1Chris Lattner 452085fd6cd22ec5c268175251db10d7c60caf7aaaChris LattnerStringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData, 462085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner unsigned ByteLength, bool Wide, 472085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner QualType Ty, 48a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson const SourceLocation *Loc, 49a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson unsigned NumStrs) { 502085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner // Allocate enough space for the StringLiteral plus an array of locations for 512085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner // any concatenated string tokens. 522085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner void *Mem = C.Allocate(sizeof(StringLiteral)+ 532085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner sizeof(SourceLocation)*(NumStrs-1), 542085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner llvm::alignof<StringLiteral>()); 552085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner StringLiteral *SL = new (Mem) StringLiteral(Ty); 562085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner 575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // OPTIMIZE: could allocate this appended to the StringLiteral. 582085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner char *AStrData = new (C, 1) char[ByteLength]; 592085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner memcpy(AStrData, StrData, ByteLength); 602085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->StrData = AStrData; 612085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->ByteLength = ByteLength; 622085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->IsWide = Wide; 632085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->TokLocs[0] = Loc[0]; 642085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner SL->NumConcatenated = NumStrs; 655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 66726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner if (NumStrs != 1) 672085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1)); 682085fd6cd22ec5c268175251db10d7c60caf7aaaChris Lattner return SL; 69726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner} 70726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner 71673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas GregorStringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) { 72673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor void *Mem = C.Allocate(sizeof(StringLiteral)+ 73673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor sizeof(SourceLocation)*(NumStrs-1), 74673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor llvm::alignof<StringLiteral>()); 75673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor StringLiteral *SL = new (Mem) StringLiteral(QualType()); 76673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor SL->StrData = 0; 77673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor SL->ByteLength = 0; 78673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor SL->NumConcatenated = NumStrs; 79673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor return SL; 80673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor} 81673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor 82a135fb43eb94524a6529768596a4533eed9aa70dAnders CarlssonStringLiteral* StringLiteral::Clone(ASTContext &C) const { 83a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson return Create(C, StrData, ByteLength, IsWide, getType(), 84a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson TokLocs, NumConcatenated); 85a135fb43eb94524a6529768596a4533eed9aa70dAnders Carlsson} 86726e168dc09fb23f53c7b004f8e919421ee91806Chris Lattner 876e94ef5696cfb005d3fc7bbac8dcf7690b64f0a5Ted Kremenekvoid StringLiteral::Destroy(ASTContext &C) { 888189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek C.Deallocate(const_cast<char*>(StrData)); 89353ffceafc6bcebd5592cb9d93ea3f9242e5370aTed Kremenek this->~StringLiteral(); 90353ffceafc6bcebd5592cb9d93ea3f9242e5370aTed Kremenek C.Deallocate(this); 915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 93673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregorvoid StringLiteral::setStrData(ASTContext &C, const char *Str, unsigned Len) { 94673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor if (StrData) 95673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor C.Deallocate(const_cast<char*>(StrData)); 96673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor 97673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor char *AStrData = new (C, 1) char[Len]; 98673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor memcpy(AStrData, Str, Len); 99673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor StrData = AStrData; 100673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor ByteLength = Len; 101673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor} 102673ecd6a4a9f7c12fb6f76f84f654dbdcdc89e76Douglas Gregor 1035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 1045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "sizeof" or "[pre]++". 1055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *UnaryOperator::getOpcodeStr(Opcode Op) { 1065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 1075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown unary operator"); 1085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostInc: return "++"; 1095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostDec: return "--"; 1105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreInc: return "++"; 1115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreDec: return "--"; 1125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddrOf: return "&"; 1135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Deref: return "*"; 1145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Plus: return "+"; 1155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Minus: return "-"; 1165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Not: return "~"; 1175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LNot: return "!"; 1185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Real: return "__real"; 1195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Imag: return "__imag"; 1205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Extension: return "__extension__"; 12173d0d4fac161ed12926e010dcf8b448a8de6a2ecChris Lattner case OffsetOf: return "__builtin_offsetof"; 1225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 125bc736fceca6f0bca31d16003a7587857190408fbDouglas GregorUnaryOperator::Opcode 126bc736fceca6f0bca31d16003a7587857190408fbDouglas GregorUnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) { 127bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor switch (OO) { 128bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor default: assert(false && "No unary operator for overloaded function"); 129b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_PlusPlus: return Postfix ? PostInc : PreInc; 130b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_MinusMinus: return Postfix ? PostDec : PreDec; 131b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Amp: return AddrOf; 132b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Star: return Deref; 133b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Plus: return Plus; 134b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Minus: return Minus; 135b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Tilde: return Not; 136b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner case OO_Exclaim: return LNot; 137bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor } 138bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor} 139bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor 140bc736fceca6f0bca31d16003a7587857190408fbDouglas GregorOverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) { 141bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor switch (Opc) { 142bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case PostInc: case PreInc: return OO_PlusPlus; 143bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case PostDec: case PreDec: return OO_MinusMinus; 144bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case AddrOf: return OO_Amp; 145bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case Deref: return OO_Star; 146bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case Plus: return OO_Plus; 147bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case Minus: return OO_Minus; 148bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case Not: return OO_Tilde; 149bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor case LNot: return OO_Exclaim; 150bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor default: return OO_None; 151bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor } 152bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor} 153bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor 154bc736fceca6f0bca31d16003a7587857190408fbDouglas Gregor 1555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Postfix Operators. 1575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 159668bf91d31265b6ea8c3eb854ba450857701f269Ted KremenekCallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args, 1608189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek unsigned numargs, QualType t, SourceLocation rparenloc) 161898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor : Expr(SC, t, 162898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 163d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 164898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor NumArgs(numargs) { 165668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 166668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek SubExprs = new (C) Stmt*[numargs+1]; 167b4609806e9232593ece09ce08b630836e825865cDouglas Gregor SubExprs[FN] = fn; 168b4609806e9232593ece09ce08b630836e825865cDouglas Gregor for (unsigned i = 0; i != numargs; ++i) 169b4609806e9232593ece09ce08b630836e825865cDouglas Gregor SubExprs[i+ARGS_START] = args[i]; 170668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 171b4609806e9232593ece09ce08b630836e825865cDouglas Gregor RParenLoc = rparenloc; 172b4609806e9232593ece09ce08b630836e825865cDouglas Gregor} 173e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman 174668bf91d31265b6ea8c3eb854ba450857701f269Ted KremenekCallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs, 175668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek QualType t, SourceLocation rparenloc) 176898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor : Expr(CallExprClass, t, 177898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs), 178d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)), 179898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor NumArgs(numargs) { 180668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 181668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek SubExprs = new (C) Stmt*[numargs+1]; 18277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[FN] = fn; 1835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != numargs; ++i) 18477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[i+ARGS_START] = args[i]; 185668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 1865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RParenLoc = rparenloc; 1875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1891f0d0133b0e8d1f01f63951ee04927796b34740dDouglas GregorCallExpr::CallExpr(ASTContext &C, EmptyShell Empty) 1901f0d0133b0e8d1f01f63951ee04927796b34740dDouglas Gregor : Expr(CallExprClass, Empty), SubExprs(0), NumArgs(0) { 1911f0d0133b0e8d1f01f63951ee04927796b34740dDouglas Gregor SubExprs = new (C) Stmt*[1]; 1921f0d0133b0e8d1f01f63951ee04927796b34740dDouglas Gregor} 1931f0d0133b0e8d1f01f63951ee04927796b34740dDouglas Gregor 194668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenekvoid CallExpr::Destroy(ASTContext& C) { 195668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek DestroyChildren(C); 196668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek if (SubExprs) C.Deallocate(SubExprs); 197668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek this->~CallExpr(); 198668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek C.Deallocate(this); 199668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek} 200668bf91d31265b6ea8c3eb854ba450857701f269Ted Kremenek 201d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// setNumArgs - This changes the number of arguments present in this call. 202d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// Any orphaned expressions are deleted by this, and any new operands are set 203d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// to null. 2048189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenekvoid CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) { 205d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // No change, just return. 206d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs == getNumArgs()) return; 207d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 208d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // If shrinking # arguments, just delete the extras and forgot them. 209d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs < getNumArgs()) { 210d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 2118189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek getArg(i)->Destroy(C); 212d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 213d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner return; 214d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner } 215d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 216d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Otherwise, we are growing the # arguments. New an bigger argument array. 2175549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek Stmt **NewSubExprs = new Stmt*[NumArgs+1]; 218d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Copy over args. 219d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 220d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = SubExprs[i]; 221d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Null out new args. 222d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 223d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = 0; 224d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 22588c9a46f0b84f1ee83e01917825346551ee540d0Douglas Gregor if (SubExprs) C.Deallocate(SubExprs); 226d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner SubExprs = NewSubExprs; 227d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 228d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner} 229d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 230cb888967400a03504c88acedd5248d6778a82f46Chris Lattner/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If 231cb888967400a03504c88acedd5248d6778a82f46Chris Lattner/// not, return 0. 2323c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregorunsigned CallExpr::isBuiltinCall(ASTContext &Context) const { 233c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // All simple function calls (e.g. func()) are implicitly cast to pointer to 234c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // function. As a result, we try and obtain the DeclRefExpr from the 235c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // ImplicitCastExpr. 236c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 237c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 238cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 239cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 240c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 241c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!DRE) 242cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 243cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 244bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 245bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson if (!FDecl) 246cb888967400a03504c88acedd5248d6778a82f46Chris Lattner return 0; 247cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 2484fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor if (!FDecl->getIdentifier()) 2494fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor return 0; 2504fcd399a52ae45ed8ebfdd3a25e01cfb76fa366dDouglas Gregor 2513c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor return FDecl->getBuiltinID(Context); 252cb888967400a03504c88acedd5248d6778a82f46Chris Lattner} 253bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson 254cb888967400a03504c88acedd5248d6778a82f46Chris Lattner 2555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 2565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "<<=". 2575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *BinaryOperator::getOpcodeStr(Opcode Op) { 2585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 259baf534875ed0a55c6342636ff3f4602b8ac22b69Douglas Gregor case PtrMemD: return ".*"; 260baf534875ed0a55c6342636ff3f4602b8ac22b69Douglas Gregor case PtrMemI: return "->*"; 2615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Mul: return "*"; 2625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Div: return "/"; 2635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Rem: return "%"; 2645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Add: return "+"; 2655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Sub: return "-"; 2665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shl: return "<<"; 2675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shr: return ">>"; 2685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LT: return "<"; 2695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GT: return ">"; 2705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LE: return "<="; 2715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GE: return ">="; 2725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case EQ: return "=="; 2735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case NE: return "!="; 2745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case And: return "&"; 2755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Xor: return "^"; 2765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Or: return "|"; 2775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LAnd: return "&&"; 2785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LOr: return "||"; 2795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Assign: return "="; 2805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MulAssign: return "*="; 2815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DivAssign: return "/="; 2825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case RemAssign: return "%="; 2835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddAssign: return "+="; 2845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SubAssign: return "-="; 2855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShlAssign: return "<<="; 2865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShrAssign: return ">>="; 2875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AndAssign: return "&="; 2885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case XorAssign: return "^="; 2895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case OrAssign: return "|="; 2905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Comma: return ","; 2915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 292baf534875ed0a55c6342636ff3f4602b8ac22b69Douglas Gregor 293baf534875ed0a55c6342636ff3f4602b8ac22b69Douglas Gregor return ""; 2945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 296063daf6e196c51f162e0485478355d8e280eef5cDouglas GregorBinaryOperator::Opcode 297063daf6e196c51f162e0485478355d8e280eef5cDouglas GregorBinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) { 298063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor switch (OO) { 299b7beee9f2b52f34a3b0800a5f0038f0e4295b260Chris Lattner default: assert(false && "Not an overloadable binary operator"); 300063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Plus: return Add; 301063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Minus: return Sub; 302063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Star: return Mul; 303063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Slash: return Div; 304063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Percent: return Rem; 305063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Caret: return Xor; 306063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Amp: return And; 307063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Pipe: return Or; 308063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Equal: return Assign; 309063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Less: return LT; 310063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Greater: return GT; 311063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_PlusEqual: return AddAssign; 312063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_MinusEqual: return SubAssign; 313063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_StarEqual: return MulAssign; 314063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_SlashEqual: return DivAssign; 315063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_PercentEqual: return RemAssign; 316063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_CaretEqual: return XorAssign; 317063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_AmpEqual: return AndAssign; 318063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_PipeEqual: return OrAssign; 319063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_LessLess: return Shl; 320063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_GreaterGreater: return Shr; 321063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_LessLessEqual: return ShlAssign; 322063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_GreaterGreaterEqual: return ShrAssign; 323063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_EqualEqual: return EQ; 324063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_ExclaimEqual: return NE; 325063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_LessEqual: return LE; 326063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_GreaterEqual: return GE; 327063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_AmpAmp: return LAnd; 328063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_PipePipe: return LOr; 329063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_Comma: return Comma; 330063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor case OO_ArrowStar: return PtrMemI; 331063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor } 332063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor} 333063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor 334063daf6e196c51f162e0485478355d8e280eef5cDouglas GregorOverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) { 335063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor static const OverloadedOperatorKind OverOps[] = { 336063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor /* .* Cannot be overloaded */OO_None, OO_ArrowStar, 337063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Star, OO_Slash, OO_Percent, 338063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Plus, OO_Minus, 339063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_LessLess, OO_GreaterGreater, 340063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual, 341063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_EqualEqual, OO_ExclaimEqual, 342063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Amp, 343063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Caret, 344063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Pipe, 345063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_AmpAmp, 346063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_PipePipe, 347063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Equal, OO_StarEqual, 348063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_SlashEqual, OO_PercentEqual, 349063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_PlusEqual, OO_MinusEqual, 350063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_LessLessEqual, OO_GreaterGreaterEqual, 351063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_AmpEqual, OO_CaretEqual, 352063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_PipeEqual, 353063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor OO_Comma 354063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor }; 355063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor return OverOps[Opc]; 356063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor} 357063daf6e196c51f162e0485478355d8e280eef5cDouglas Gregor 35866b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonInitListExpr::InitListExpr(SourceLocation lbraceloc, 359418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner Expr **initExprs, unsigned numInits, 3604c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor SourceLocation rbraceloc) 361c5ae899b4bbf65488445316c63168079177db0edSteve Naroff : Expr(InitListExprClass, QualType()), 3620bb76897bedb8b747efc6523efb432fc24966118Douglas Gregor LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0), 363a9c878086036de36482cc21e35a33cabe9699b0aDouglas Gregor UnionFieldInit(0), HadArrayRangeDesignator(false) { 364418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner 365418f6c7d142e5ff4607f70cd8431d008442bafe9Chris Lattner InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits); 36666b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 3675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 368fa2192042f223b5122a9e17719930f77634fd31fDouglas Gregorvoid InitListExpr::reserveInits(unsigned NumInits) { 369fa2192042f223b5122a9e17719930f77634fd31fDouglas Gregor if (NumInits > InitExprs.size()) 370fa2192042f223b5122a9e17719930f77634fd31fDouglas Gregor InitExprs.reserve(NumInits); 371fa2192042f223b5122a9e17719930f77634fd31fDouglas Gregor} 372fa2192042f223b5122a9e17719930f77634fd31fDouglas Gregor 3734c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregorvoid InitListExpr::resizeInits(ASTContext &Context, unsigned NumInits) { 374d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner for (unsigned Idx = NumInits, LastIdx = InitExprs.size(); 375f592c929bd1f083abcc8199b24bb825fdd28df1cDaniel Dunbar Idx < LastIdx; ++Idx) 376068636800594844c53fba0bc871c579745757d0eDouglas Gregor InitExprs[Idx]->Destroy(Context); 3774c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.resize(NumInits, 0); 3784c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor} 3794c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 3804c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas GregorExpr *InitListExpr::updateInit(unsigned Init, Expr *expr) { 3814c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor if (Init >= InitExprs.size()) { 3824c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.insert(InitExprs.end(), Init - InitExprs.size() + 1, 0); 3834c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs.back() = expr; 3844c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor return 0; 3854c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor } 3864c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 3874c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor Expr *Result = cast_or_null<Expr>(InitExprs[Init]); 3884c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor InitExprs[Init] = expr; 3894c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor return Result; 3904c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor} 3914c67834407ca6ab344dcf44fc599ad4938cfa96dDouglas Gregor 392bfdcae678d44906293e21c0cddc6537f3ee8b5a4Steve Naroff/// getFunctionType - Return the underlying function type for this block. 3934eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff/// 3944eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroffconst FunctionType *BlockExpr::getFunctionType() const { 3954eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff return getType()->getAsBlockPointerType()-> 3964eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff getPointeeType()->getAsFunctionType(); 3974eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff} 3984eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff 39956ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffSourceLocation BlockExpr::getCaretLocation() const { 40056ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff return TheBlock->getCaretLocation(); 40156ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff} 4027297134f128423fce2e88f92421ed135bded7d4eDouglas Gregorconst Stmt *BlockExpr::getBody() const { 4037297134f128423fce2e88f92421ed135bded7d4eDouglas Gregor return TheBlock->getBody(); 4047297134f128423fce2e88f92421ed135bded7d4eDouglas Gregor} 4057297134f128423fce2e88f92421ed135bded7d4eDouglas GregorStmt *BlockExpr::getBody() { 4067297134f128423fce2e88f92421ed135bded7d4eDouglas Gregor return TheBlock->getBody(); 4077297134f128423fce2e88f92421ed135bded7d4eDouglas Gregor} 40856ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff 40956ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve Naroff 4105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 4115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Generic Expression Routines 4125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 4135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 414026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// isUnusedResultAWarning - Return true if this immediate expression should 415026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// be warned about if the result is unused. If so, fill in Loc and Ranges 416026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// with location to warn on and the source range[s] to report with the 417026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner/// warning. 418026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattnerbool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1, 419026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner SourceRange &R2) const { 4205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 4215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 422026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = getExprLoc(); 423026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = getSourceRange(); 424026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 4255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: 426026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<ParenExpr>(this)->getSubExpr()-> 427026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner isUnusedResultAWarning(Loc, R1, R2); 4285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperatorClass: { 4295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const UnaryOperator *UO = cast<UnaryOperator>(this); 4305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (UO->getOpcode()) { 432026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner default: break; 4335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostInc: 4345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostDec: 4355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PreInc: 436026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner case UnaryOperator::PreDec: // ++/-- 437026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; // Not a warning. 4385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Deref: 4395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Dereferencing a volatile pointer is a side-effect. 440026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 441026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 442026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner break; 4435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Real: 4445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Imag: 4455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // accessing a piece of a volatile complex is a side-effect. 446026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (UO->getSubExpr()->getType().isVolatileQualified()) 447026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 448026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner break; 4495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 450026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 4515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 452026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = UO->getOperatorLoc(); 453026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = UO->getSubExpr()->getSourceRange(); 454026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 4555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 456e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner case BinaryOperatorClass: { 457026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const BinaryOperator *BO = cast<BinaryOperator>(this); 458026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // Consider comma to have side effects if the LHS or RHS does. 459026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (BO->getOpcode() == BinaryOperator::Comma) 460026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2) || 461026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2); 462e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner 463026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (BO->isAssignmentOp()) 464026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 465026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = BO->getOperatorLoc(); 466026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = BO->getLHS()->getSourceRange(); 467026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = BO->getRHS()->getSourceRange(); 468026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 469e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner } 470eb14fe839ec24c2ca14e5f094be147a34e3d3339Chris Lattner case CompoundAssignOperatorClass: 471026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 4725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 473ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian case ConditionalOperatorClass: { 474026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // The condition must be evaluated, but if either the LHS or RHS is a 475026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // warning, warn about them. 476ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 477befbcf4e02756f252d1263774ef2249f0921c1c9Mike Stump if (Exp->getLHS() && Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2)) 478026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 479026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2); 480ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian } 481ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian 4825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MemberExprClass: 483026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If the base pointer or element is to a volatile pointer/field, accessing 484026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // it is a side effect. 485026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 486026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 487026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<MemberExpr>(this)->getMemberLoc(); 488026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = SourceRange(Loc, Loc); 489026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = cast<MemberExpr>(this)->getBase()->getSourceRange(); 490026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 491026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 4925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: 4935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the base pointer or element is to a volatile pointer/field, accessing 494026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // it is a side effect. 495026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType().isVolatileQualified()) 496026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 497026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc(); 498026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange(); 499026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange(); 500026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 501211f6adf1301a1461015fb6cb08a05f0a35b65f3Eli Friedman 5025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case CallExprClass: 503026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner case CXXOperatorCallExprClass: { 504026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If this is a direct call, get the callee. 505026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const CallExpr *CE = cast<CallExpr>(this); 506026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner const Expr *CalleeExpr = CE->getCallee()->IgnoreParenCasts(); 507026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (const DeclRefExpr *CalleeDRE = dyn_cast<DeclRefExpr>(CalleeExpr)) { 508026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If the callee has attribute pure, const, or warn_unused_result, warn 509026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // about it. void foo() { strlen("bar"); } should warn. 510026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CalleeDRE->getDecl())) 511026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (FD->getAttr<WarnUnusedResultAttr>() || 512026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) { 513026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = CE->getCallee()->getLocStart(); 514026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = CE->getCallee()->getSourceRange(); 515026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 516026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (unsigned NumArgs = CE->getNumArgs()) 517026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R2 = SourceRange(CE->getArg(0)->getLocStart(), 518026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner CE->getArg(NumArgs-1)->getLocEnd()); 519026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 520026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 521026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 522026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 523026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner } 524a9c01021724b9b546d282b8609cbe559734812ecChris Lattner case ObjCMessageExprClass: 525026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 526611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner case StmtExprClass: { 527611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // Statement exprs don't logically have side effects themselves, but are 528611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // sometimes used in macros in ways that give them a type that is unused. 529611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // For example ({ blah; foo(); }) will end up with a type if foo has a type. 530611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // however, if the result of the stmt expr is dead, we don't want to emit a 531611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // warning. 532611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 533611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (!CS->body_empty()) 534611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 535026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return E->isUnusedResultAWarning(Loc, R1, R2); 536026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 537026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<StmtExpr>(this)->getLParenLoc(); 538026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = getSourceRange(); 539026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 540611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner } 5416eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 542026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // If this is a cast to void, check the operand. Otherwise, the result of 543026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner // the cast is unused. 544026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner if (getType()->isVoidType()) 545026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CastExpr>(this)->getSubExpr()->isUnusedResultAWarning(Loc, 546026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1, R2); 547026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<CStyleCastExpr>(this)->getLParenLoc(); 548026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange(); 549026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 550987a14bf5883ef6e5d07f1c83eb6d41a8212a78cArgyrios Kyrtzidis case CXXFunctionalCastExprClass: 5515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is a cast to void, check the operand. Otherwise, the result of 5525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the cast is unused. 5535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (getType()->isVoidType()) 554026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CastExpr>(this)->getSubExpr()->isUnusedResultAWarning(Loc, 555026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1, R2); 556026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc(); 557026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange(); 558026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return true; 559026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner 5604be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman case ImplicitCastExprClass: 5614be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman // Check the operand, since implicit casts are inserted by Sema 562026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<ImplicitCastExpr>(this) 563026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2); 5644be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman 56504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 566026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return cast<CXXDefaultArgExpr>(this) 567026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner ->getExpr()->isUnusedResultAWarning(Loc, R1, R2); 5684c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl 5694c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl case CXXNewExprClass: 5704c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl // FIXME: In theory, there might be new expressions that don't have side 5714c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl // effects (e.g. a placement new with an uninitialized POD). 5724c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl case CXXDeleteExprClass: 573026dc96ac6ece60da5e1b98e2a71bd0ff0939fd8Chris Lattner return false; 5744c5d320a7581f4b80b151630c91cea5727fa9923Sebastian Redl } 5755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 577ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor/// DeclCanBeLvalue - Determine whether the given declaration can be 578ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor/// an lvalue. This is a helper routine for isLvalue. 579ba7e210a999275695f58be03ef402758cfec3635Douglas Gregorstatic bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) { 58072c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor // C++ [temp.param]p6: 58172c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor // A non-type non-reference template-parameter is not an lvalue. 58272c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor if (const NonTypeTemplateParmDecl *NTTParm 58372c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor = dyn_cast<NonTypeTemplateParmDecl>(Decl)) 58472c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor return NTTParm->getType()->isReferenceType(); 58572c3f314d92d65c050ee1c07b7753623c044d6c7Douglas Gregor 58644b4321feab46299d3f5cfd404680884752a0fcfDouglas Gregor return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) || 587ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor // C++ 3.10p2: An lvalue refers to an object or function. 588ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor (Ctx.getLangOptions().CPlusPlus && 589ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl))); 590ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor} 591ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor 5925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 5935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// incomplete type other than void. Nonarray expressions that can be lvalues: 5945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - name, where name must be a variable 5955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e[i] 5965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - (e), where e must be an lvalue 5975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e.name, where e must be an lvalue 5985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e->name 5995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - *e, the type of e cannot be a function type 6005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - string-constant 6017da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 60208ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling/// - reference type [C++ [expr]] 6035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 60428be73f74c9e241a23ea24fe5756623de6bf1084Chris LattnerExpr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const { 60598cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor // first, check the type (C99 6.3.2.1). Expressions with function 60698cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor // type in C are not lvalues, but they can be lvalues in C++. 60798cd599ee8a9b259ed7388ee2921a20d97658864Douglas Gregor if (!Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 6085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_NotObjectType; 6095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 610acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff // Allow qualified void which is an incomplete type other than void (yuck). 61128be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers()) 612acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff return LV_IncompleteVoidType; 613acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff 6147c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl assert(!TR->isReferenceType() && "Expressions can't have reference type."); 61508ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling 6165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the type looks fine, now check the expression 6175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 618eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case StringLiteralClass: // C99 6.5.1p4 619eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case ObjCEncodeExprClass: // @encode behaves like its string in every way. 6207323a6297edad643c202594dcf3d9a174de96ca6Anders Carlsson return LV_Valid; 6215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 6225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // For vectors, make sure base is an lvalue (i.e. not a function call). 6235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 62428be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx); 6255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 6261a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case DeclRefExprClass: 6271a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case QualifiedDeclRefExprClass: { // C99 6.5.1p2 628ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl(); 629ba7e210a999275695f58be03ef402758cfec3635Douglas Gregor if (DeclCanBeLvalue(RefdDecl, Ctx)) 6305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 6315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 6324111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner } 633dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff case BlockDeclRefExprClass: { 634dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 6354f6a7d7ead09b439216c32f2de806a998aeb222aSteve Naroff if (isa<VarDecl>(BDR->getDecl())) 636dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff return LV_Valid; 637dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff break; 638dd972f20dc2bd3609d833893e5c6544ac09b59a9Steve Naroff } 63986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor case MemberExprClass: { 6405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const MemberExpr *m = cast<MemberExpr>(this); 64186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4: 64286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor NamedDecl *Member = m->getMemberDecl(); 64386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // C++ [expr.ref]p4: 64486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // If E2 is declared to have type "reference to T", then E1.E2 64586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // is an lvalue. 64686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (ValueDecl *Value = dyn_cast<ValueDecl>(Member)) 64786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (Value->getType()->isReferenceType()) 64886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_Valid; 64986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 65086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a static data member [...] then E1.E2 is an lvalue. 6512d2e9cfdc1dbb6e4a22f8c0b1abcd30437e3795dDouglas Gregor if (isa<VarDecl>(Member) && Member->getDeclContext()->isRecord()) 65286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_Valid; 65386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 65486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a non-static data member [...]. If E1 is an 65586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // lvalue, then E1.E2 is an lvalue. 65686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (isa<FieldDecl>(Member)) 65786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 65886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 65986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If it refers to a static member function [...], then 66086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // E1.E2 is an lvalue. 66186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- Otherwise, if E1.E2 refers to a non-static member 66286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // function [...], then E1.E2 is not an lvalue. 66386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member)) 66486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return Method->isStatic()? LV_Valid : LV_MemberFunction; 66586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 66686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // -- If E2 is a member enumerator [...], the expression E1.E2 66786f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // is not an lvalue. 66886f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (isa<EnumConstantDecl>(Member)) 66986f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_InvalidExpression; 67086f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 67186f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // Not an lvalue. 67286f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return LV_InvalidExpression; 67386f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor } 67486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor 67586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor // C99 6.5.2.3p4 67628be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 677fdd75663fffeb2058a7847975e50837e61200593Anton Korobeynikov } 6787da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner case UnaryOperatorClass: 6795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 6807da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner return LV_Valid; // C99 6.5.3p4 6817da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner 6827da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 683baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag || 684baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension) 68528be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU. 68674253736184c0717a0649922551bf9d8b6815651Douglas Gregor 68774253736184c0717a0649922551bf9d8b6815651Douglas Gregor if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1 68874253736184c0717a0649922551bf9d8b6815651Douglas Gregor (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc || 68974253736184c0717a0649922551bf9d8b6815651Douglas Gregor cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec)) 69074253736184c0717a0649922551bf9d8b6815651Douglas Gregor return LV_Valid; 6915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 692eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case ImplicitCastExprClass: 693eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid 694eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor : LV_InvalidExpression; 6955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: // C99 6.5.1p5 69628be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx); 697eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case BinaryOperatorClass: 698eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor case CompoundAssignOperatorClass: { 699eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor const BinaryOperator *BinOp = cast<BinaryOperator>(this); 700337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor 701337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1 702337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor BinOp->getOpcode() == BinaryOperator::Comma) 703337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor return BinOp->getRHS()->isLvalue(Ctx); 704337c6b9f5d502dc1c5acea628bf7bf9e828efc0eDouglas Gregor 705224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl // C++ [expr.mptr.oper]p6 706224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl if ((BinOp->getOpcode() == BinaryOperator::PtrMemD || 707224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl BinOp->getOpcode() == BinaryOperator::PtrMemI) && 708224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl !BinOp->getType()->isFunctionType()) 709224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl return BinOp->getLHS()->isLvalue(Ctx); 710224605064a4ef87d1c3d35ad1cb363f8b534012bSebastian Redl 711bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor if (!BinOp->isAssignmentOp()) 712eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor return LV_InvalidExpression; 713eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor 714bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor if (Ctx.getLangOptions().CPlusPlus) 715bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // C++ [expr.ass]p1: 716bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // The result of an assignment operation [...] is an lvalue. 717bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor return LV_Valid; 718bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor 719bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor 720bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // C99 6.5.16: 721bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor // An assignment expression [...] is not an lvalue. 722bf3af056289893f58d37b05a2c80970708781d61Douglas Gregor return LV_InvalidExpression; 723eb8f3063257a392f15aea48d42fb73ec51afc548Douglas Gregor } 724b4609806e9232593ece09ce08b630836e825865cDouglas Gregor case CallExprClass: 72588a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor case CXXOperatorCallExprClass: 72688a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor case CXXMemberCallExprClass: { 7277c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // C++0x [expr.call]p10 7289d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // A function call is an lvalue if and only if the result type 7297c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // is an lvalue reference. 73027c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor QualType CalleeType = cast<CallExpr>(this)->getCallee()->getType(); 7319d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor if (const PointerType *FnTypePtr = CalleeType->getAsPointerType()) 73288a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor CalleeType = FnTypePtr->getPointeeType(); 73388a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor if (const FunctionType *FnType = CalleeType->getAsFunctionType()) 7347c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (FnType->getResultType()->isLValueReferenceType()) 73588a3514f36de96b19cdf50141c640df1a5f13f6cDouglas Gregor return LV_Valid; 7367c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl 7379d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor break; 7389d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor } 739e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff case CompoundLiteralExprClass: // C99 6.5.2.5p5 740e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff return LV_Valid; 741670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner case ChooseExprClass: 742670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner // __builtin_choose_expr is an lvalue if the selected operand is. 7437976932a1c256d447316ffac58e9821417725e34Eli Friedman return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)->isLvalue(Ctx); 744213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case ExtVectorElementExprClass: 745213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 746fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_DuplicateVectorComponents; 747fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_Valid; 748027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 749027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff return LV_Valid; 750799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff case ObjCPropertyRefExprClass: // FIXME: check if read-only property. 751799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff return LV_Valid; 7525daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian case ObjCKVCRefExprClass: // FIXME: check if read-only property. 753670a62cd1d51042ea076cda5e93f26a1d8327fb3Chris Lattner return LV_Valid; 754d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 755796da18402f286b897782a298ae3b20c459c102eDouglas Gregor return LV_Valid; 7569d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case VAArgExprClass: 757adadd8db2aba32f689e7057d8b7ce004be30685bDaniel Dunbar return LV_NotObjectType; 75804421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 75928be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx); 76024b41fa8239c63b9eb570d3e83c4a82840656a65Argyrios Kyrtzidis case CXXConditionDeclExprClass: 76124b41fa8239c63b9eb570d3e83c4a82840656a65Argyrios Kyrtzidis return LV_Valid; 7626eec8e883de118b431e3ead5b1e604a6ac68ff6bDouglas Gregor case CStyleCastExprClass: 7639d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXFunctionalCastExprClass: 7649d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXStaticCastExprClass: 7659d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXDynamicCastExprClass: 7669d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXReinterpretCastExprClass: 7679d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor case CXXConstCastExprClass: 7689d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // The result of an explicit cast is an lvalue if the type we are 7697c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl // casting to is an lvalue reference type. See C++ [expr.cast]p1, 7709d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2, 7719d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1. 7727c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()-> 7737c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl isLValueReferenceType()) 7749d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor return LV_Valid; 7759d293dfc0ad7c44ae0b5eb9517f1ed8c8d8b7ff7Douglas Gregor break; 776c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl case CXXTypeidExprClass: 777c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ... 778c42e1183846228a7fa5143ad76507d6d60f5c6f3Sebastian Redl return LV_Valid; 77976458501a8963fa11b91c9337a487de6871169b4Sebastian Redl case ConditionalOperatorClass: { 78076458501a8963fa11b91c9337a487de6871169b4Sebastian Redl // Complicated handling is only for C++. 78176458501a8963fa11b91c9337a487de6871169b4Sebastian Redl if (!Ctx.getLangOptions().CPlusPlus) 78276458501a8963fa11b91c9337a487de6871169b4Sebastian Redl return LV_InvalidExpression; 78376458501a8963fa11b91c9337a487de6871169b4Sebastian Redl 78476458501a8963fa11b91c9337a487de6871169b4Sebastian Redl // Sema should have taken care to ensure that a CXXTemporaryObjectExpr is 78576458501a8963fa11b91c9337a487de6871169b4Sebastian Redl // everywhere there's an object converted to an rvalue. Also, any other 78676458501a8963fa11b91c9337a487de6871169b4Sebastian Redl // casts should be wrapped by ImplicitCastExprs. There's just the special 78776458501a8963fa11b91c9337a487de6871169b4Sebastian Redl // case involving throws to work out. 78876458501a8963fa11b91c9337a487de6871169b4Sebastian Redl const ConditionalOperator *Cond = cast<ConditionalOperator>(this); 78976458501a8963fa11b91c9337a487de6871169b4Sebastian Redl Expr *LHS = Cond->getLHS(); 79076458501a8963fa11b91c9337a487de6871169b4Sebastian Redl Expr *RHS = Cond->getRHS(); 79176458501a8963fa11b91c9337a487de6871169b4Sebastian Redl // C++0x 5.16p2 79276458501a8963fa11b91c9337a487de6871169b4Sebastian Redl // If either the second or the third operand has type (cv) void, [...] 79376458501a8963fa11b91c9337a487de6871169b4Sebastian Redl // the result [...] is an rvalue. 79476458501a8963fa11b91c9337a487de6871169b4Sebastian Redl if (LHS->getType()->isVoidType() || RHS->getType()->isVoidType()) 79576458501a8963fa11b91c9337a487de6871169b4Sebastian Redl return LV_InvalidExpression; 79676458501a8963fa11b91c9337a487de6871169b4Sebastian Redl 79776458501a8963fa11b91c9337a487de6871169b4Sebastian Redl // Both sides must be lvalues for the result to be an lvalue. 79876458501a8963fa11b91c9337a487de6871169b4Sebastian Redl if (LHS->isLvalue(Ctx) != LV_Valid || RHS->isLvalue(Ctx) != LV_Valid) 79976458501a8963fa11b91c9337a487de6871169b4Sebastian Redl return LV_InvalidExpression; 80076458501a8963fa11b91c9337a487de6871169b4Sebastian Redl 80176458501a8963fa11b91c9337a487de6871169b4Sebastian Redl // That's it. 80276458501a8963fa11b91c9337a487de6871169b4Sebastian Redl return LV_Valid; 80376458501a8963fa11b91c9337a487de6871169b4Sebastian Redl } 80476458501a8963fa11b91c9337a487de6871169b4Sebastian Redl 8055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 8065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_InvalidExpression; 8095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 8105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 8125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// does not have an incomplete type, does not have a const-qualified type, and 8135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// if it is a structure or union, does not have any member (including, 8145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// recursively, any member or element of all contained aggregates or unions) 8155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// with a const-qualified type. 81644e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel DunbarExpr::isModifiableLvalueResult 81744e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel DunbarExpr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const { 81828be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner isLvalueResult lvalResult = isLvalue(Ctx); 8195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (lvalResult) { 821ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor case LV_Valid: 822ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor // C++ 3.10p11: Functions cannot be modified, but pointers to 823ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor // functions can be modifiable. 824ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType()) 825ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor return MLV_NotObjectType; 826ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor break; 827ae8d467e75a4e72b19e1eca199bf93dfaab47acfDouglas Gregor 8285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_NotObjectType: return MLV_NotObjectType; 8295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 830fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 831ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner case LV_InvalidExpression: 832ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // If the top level is a C-style cast, and the subexpression is a valid 833ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // lvalue, then this is probably a use of the old-school "cast as lvalue" 834ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // GCC extension. We don't support it, but we want to produce good 835ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner // diagnostics when it happens so that the user knows why. 83644e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(IgnoreParens())) { 83744e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) { 83844e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar if (Loc) 83944e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar *Loc = CE->getLParenLoc(); 840ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner return MLV_LValueCast; 84144e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar } 84244e35f7b2b5da1eb338639e46bf0b5522e75c5f3Daniel Dunbar } 843ca354faa7e9b99af17070c82b9662a5fca76422cChris Lattner return MLV_InvalidExpression; 84486f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor case LV_MemberFunction: return MLV_MemberFunction; 8455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 84604831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman 84704831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman // The following is illegal: 84804831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman // void takeclosure(void (^C)(void)); 84904831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman // void func() { int x = 1; takeclosure(^{ x = 7; }); } 85004831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman // 8517fd0995e993438a3a1f5408d8549b3af0009ff30Chris Lattner if (isa<BlockDeclRefExpr>(this)) { 85204831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this); 85304831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl())) 85404831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman return MLV_NotBlockQualified; 85504831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman } 85604831aa3271edc5f00a651bf7152c2902981d7c3Eli Friedman 857c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType CT = Ctx.getCanonicalType(getType()); 858c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 859c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT.isConstQualified()) 8605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 861c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isArrayType()) 8625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ArrayType; 863c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isIncompleteType()) 8645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_IncompleteType; 8655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 866c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const RecordType *r = CT->getAsRecordType()) { 8675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (r->hasConstFields()) 8685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 8695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 870d1fa6449e9dbdd667466e9e1e971aa17c9793e8aFariborz Jahanian 871ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian // Assigning to an 'implicit' property? 8727fd0995e993438a3a1f5408d8549b3af0009ff30Chris Lattner else if (isa<ObjCKVCRefExpr>(this)) { 873ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian const ObjCKVCRefExpr* KVCExpr = cast<ObjCKVCRefExpr>(this); 874ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian if (KVCExpr->getSetterMethod() == 0) 875ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian return MLV_NoSetterProperty; 876ba8d2d684e74a20bef03828c21c991d222c7e9e5Fariborz Jahanian } 8775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_Valid; 8785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 8795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8802e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek/// hasGlobalStorage - Return true if this expression has static storage 8814cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// duration. This means that the address of this expression is a link-time 8824cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// constant. 8832e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenekbool Expr::hasGlobalStorage() const { 8841d09ecca892185ba067e47ba879f424de59950efChris Lattner switch (getStmtClass()) { 8851d09ecca892185ba067e47ba879f424de59950efChris Lattner default: 8861d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 8873aaa482ea5b8d20b705f6ac8573b539be88d273aSteve Naroff case BlockExprClass: 8883aaa482ea5b8d20b705f6ac8573b539be88d273aSteve Naroff return true; 8894cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ParenExprClass: 8902e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage(); 8914cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ImplicitCastExprClass: 8922e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage(); 893e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff case CompoundLiteralExprClass: 894e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff return cast<CompoundLiteralExpr>(this)->isFileScope(); 8951a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case DeclRefExprClass: 8961a49af9681c350fef58e677f85ccb9a77e8e9d0aDouglas Gregor case QualifiedDeclRefExprClass: { 8971d09ecca892185ba067e47ba879f424de59950efChris Lattner const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 8981d09ecca892185ba067e47ba879f424de59950efChris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 8992e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return VD->hasGlobalStorage(); 90063f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon if (isa<FunctionDecl>(D)) 90163f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon return true; 9021d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 9031d09ecca892185ba067e47ba879f424de59950efChris Lattner } 904fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner case MemberExprClass: { 9051d09ecca892185ba067e47ba879f424de59950efChris Lattner const MemberExpr *M = cast<MemberExpr>(this); 9062e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return !M->isArrow() && M->getBase()->hasGlobalStorage(); 907fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner } 9084cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ArraySubscriptExprClass: 9092e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage(); 910d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 911fa28b30d5a1e93e5263be33e343532b900d2c643Chris Lattner return true; 91204421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 91304421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage(); 9141d09ecca892185ba067e47ba879f424de59950efChris Lattner } 9151d09ecca892185ba067e47ba879f424de59950efChris Lattner} 9161d09ecca892185ba067e47ba879f424de59950efChris Lattner 91744baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian/// isOBJCGCCandidate - Check if an expression is objc gc'able. 91844baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian/// 91944baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanianbool Expr::isOBJCGCCandidate() const { 92044baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian switch (getStmtClass()) { 92144baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian default: 92244baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return false; 92344baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ObjCIvarRefExprClass: 92444baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return true; 925207c5210eb0ac7b632609f0c006eb97ef2738948Fariborz Jahanian case Expr::UnaryOperatorClass: 926207c5210eb0ac7b632609f0c006eb97ef2738948Fariborz Jahanian return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate(); 92744baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ParenExprClass: 92844baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate(); 92944baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ImplicitCastExprClass: 93044baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(); 93144baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case DeclRefExprClass: 93244baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case QualifiedDeclRefExprClass: { 93344baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 93444baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 93544baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return VD->hasGlobalStorage(); 93644baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return false; 93744baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian } 93844baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case MemberExprClass: { 93944baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian const MemberExpr *M = cast<MemberExpr>(this); 94044baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return !M->isArrow() && M->getBase()->isOBJCGCCandidate(); 94144baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian } 94244baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian case ArraySubscriptExprClass: 94344baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate(); 94444baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian } 94544baa8abba2a1552b6b50bf750a8750ab9da9f76Fariborz Jahanian} 9464e99a5fc3b203397a91136c6e695e405fb8fc606Ted KremenekExpr* Expr::IgnoreParens() { 9474e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek Expr* E = this; 9484e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 9494e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek E = P->getSubExpr(); 9504e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 9514e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek return E; 9524e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek} 9534e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 95456f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 95556f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// or CastExprs or ImplicitCastExprs, returning their operand. 95656f349400c5932a196509c0480ff6f99a9a0b48fChris LattnerExpr *Expr::IgnoreParenCasts() { 95756f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner Expr *E = this; 95856f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner while (true) { 95956f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 96056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 96156f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else if (CastExpr *P = dyn_cast<CastExpr>(E)) 96256f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 96356f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else 96456f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner return E; 96556f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner } 96656f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner} 96756f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner 968ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the 969ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner/// value (including ptr->int casts of the same size). Strip off any 970ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner/// ParenExpr or CastExprs, returning their operand. 971ecdd84147c0765caa999ddc22dde25b42712bb4dChris LattnerExpr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) { 972ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner Expr *E = this; 973ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner while (true) { 974ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner if (ParenExpr *P = dyn_cast<ParenExpr>(E)) { 975ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner E = P->getSubExpr(); 976ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner continue; 977ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner } 978ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 979ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner if (CastExpr *P = dyn_cast<CastExpr>(E)) { 980ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner // We ignore integer <-> casts that are of the same width, ptr<->ptr and 981ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner // ptr<->int casts of the same width. We also ignore all identify casts. 982ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner Expr *SE = P->getSubExpr(); 983ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 984ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) { 985ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner E = SE; 986ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner continue; 987ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner } 988ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 989ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner if ((E->getType()->isPointerType() || E->getType()->isIntegralType()) && 990ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner (SE->getType()->isPointerType() || SE->getType()->isIntegralType()) && 991ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) { 992ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner E = SE; 993ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner continue; 994ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner } 995ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner } 996ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 997ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner return E; 998ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner } 999ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner} 1000ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 1001ecdd84147c0765caa999ddc22dde25b42712bb4dChris Lattner 1002898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// hasAnyTypeDependentArguments - Determines if any of the expressions 1003898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// in Exprs is type-dependent. 1004898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorbool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) { 1005898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor for (unsigned I = 0; I < NumExprs; ++I) 1006898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (Exprs[I]->isTypeDependent()) 1007898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return true; 1008898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 1009898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return false; 1010898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 1011898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 1012898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// hasAnyValueDependentArguments - Determines if any of the expressions 1013898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor/// in Exprs is value-dependent. 1014898574e7496ba8fd76290079d3a9d06954992734Douglas Gregorbool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) { 1015898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor for (unsigned I = 0; I < NumExprs; ++I) 1016898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor if (Exprs[I]->isValueDependent()) 1017898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return true; 1018898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 1019898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor return false; 1020898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor} 1021898574e7496ba8fd76290079d3a9d06954992734Douglas Gregor 1022c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedmanbool Expr::isConstantInitializer(ASTContext &Ctx) const { 1023c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // This function is attempting whether an expression is an initializer 1024c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // which can be evaluated at compile-time. isEvaluatable handles most 1025c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // of the cases, but it can't deal with some initializer-specific 1026c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // expressions, and it can't deal with aggregates; we deal with those here, 1027c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // and fall back to isEvaluatable for the other cases. 1028c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman 10291f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This function assumes the variable being assigned to 10301f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // isn't a reference type! 10311f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman 1032e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson switch (getStmtClass()) { 1033c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman default: break; 1034e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson case StringLiteralClass: 1035eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner case ObjCEncodeExprClass: 1036e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson return true; 103759b5da6d853b4368b984700315adf7b37de05764Nate Begeman case CompoundLiteralExprClass: { 10381f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // This handles gcc's extension that allows global initializers like 10391f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // "struct x {int x;} x = (struct x) {};". 10401f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This accepts other cases it shouldn't! 104159b5da6d853b4368b984700315adf7b37de05764Nate Begeman const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer(); 1042c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedman return Exp->isConstantInitializer(Ctx); 104359b5da6d853b4368b984700315adf7b37de05764Nate Begeman } 1044e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson case InitListExprClass: { 10451f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This doesn't deal with fields with reference types correctly. 10461f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // FIXME: This incorrectly allows pointers cast to integers to be assigned 10471f4a6db271f389d6ab3cb1bc28cb5c23a7828602Eli Friedman // to bitfields. 1048e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson const InitListExpr *Exp = cast<InitListExpr>(this); 1049e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson unsigned numInits = Exp->getNumInits(); 1050e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson for (unsigned i = 0; i < numInits; i++) { 1051c9e8f606787b0bc0c3b08e566b87cc1751694168Eli Friedman if (!Exp->getInit(i)->isConstantInitializer(Ctx)) 1052e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson return false; 1053e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 1054c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return true; 1055e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 10563498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor case ImplicitValueInitExprClass: 10573498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return true; 1058c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case ParenExprClass: { 1059c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 1060c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman } 1061c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case UnaryOperatorClass: { 1062c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman const UnaryOperator* Exp = cast<UnaryOperator>(this); 1063c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman if (Exp->getOpcode() == UnaryOperator::Extension) 1064c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return Exp->getSubExpr()->isConstantInitializer(Ctx); 1065c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman break; 1066c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman } 106781045d8dcd967def69d8e0945566214a9fe9ffccChris Lattner case ImplicitCastExprClass: 1068c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman case CStyleCastExprClass: 1069c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // Handle casts with a destination that's a struct or union; this 1070c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // deals with both the gcc no-op struct cast extension and the 1071c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman // cast-to-union extension. 1072c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman if (getType()->isRecordType()) 1073c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx); 1074c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman break; 1075e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson } 1076e8a32b855ce4e8580a191f8d29d2f3f459834302Anders Carlsson 1077c39dc9a25a9d74a5302e8567a4d3fc008212024cEli Friedman return isEvaluatable(Ctx); 107838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff} 107938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 10805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isIntegerConstantExpr - this recursive routine will test if an expression is 1081e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman/// an integer constant expression. 10825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 10845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// comma, etc 10855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 1086ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof 1087ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer 1088ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// cast+dereference. 10892d6744ff04c1690a1485178d550d2fab84a0270bDaniel Dunbar 1090e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// CheckICE - This function does the fundamental ICE checking: the returned 1091e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// ICEDiag contains a Val of 0, 1, or 2, and a possibly null SourceLocation. 1092e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// Note that to reduce code duplication, this helper does no evaluation 1093e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// itself; the caller checks whether the expression is evaluatable, and 1094e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// in the rare cases where CheckICE actually cares about the evaluated 1095e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// value, it calls into Evalute. 1096e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 1097e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// Meanings of Val: 1098e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 0: This expression is an ICE if it can be evaluated by Evaluate. 1099e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 1: This expression is not an ICE, but if it isn't evaluated, it's 1100e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// a legal subexpression for an ICE. This return value is used to handle 1101e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// the comma operator in C99 mode. 1102e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman// 2: This expression is not an ICE, and is not a legal subexpression for one. 1103e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 1104e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedmanstruct ICEDiag { 1105e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman unsigned Val; 1106e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman SourceLocation Loc; 1107e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 1108e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman public: 1109e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag(unsigned v, SourceLocation l) : Val(v), Loc(l) {} 1110e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag() : Val(0) {} 1111e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman}; 1112e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 1113e28d7195aad595154130ac8d03cc6c6513ece1bfEli FriedmanICEDiag NoDiag() { return ICEDiag(); } 1114e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 111560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedmanstatic ICEDiag CheckEvalInICE(const Expr* E, ASTContext &Ctx) { 111660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman Expr::EvalResult EVResult; 111760ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects || 111860ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman !EVResult.Val.isInt()) { 111960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(2, E->getLocStart()); 112060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 112160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return NoDiag(); 112260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman} 112360ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman 1124e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedmanstatic ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) { 1125c3082413e4207173b32c118e922d63149df6261fAnders Carlsson assert(!E->isValueDependent() && "Should not see value dependent exprs!"); 1126e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (!E->getType()->isIntegralType()) { 1127e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1128a6afa768aa7bd3102a2807aa720917e4a1771e4eEli Friedman } 1129e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman 1130e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman switch (E->getStmtClass()) { 11315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 1132e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1133e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::ParenExprClass: 1134e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx); 1135e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::IntegerLiteralClass: 1136e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CharacterLiteralClass: 1137e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXBoolLiteralExprClass: 1138e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXZeroInitValueExprClass: 1139e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::TypesCompatibleExprClass: 1140e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::UnaryTypeTraitExprClass: 1141e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1142e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CallExprClass: 1143e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXOperatorCallExprClass: { 1144e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const CallExpr *CE = cast<CallExpr>(E); 114560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (CE->isBuiltinCall(Ctx)) 114660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return CheckEvalInICE(E, Ctx); 1147e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 114813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff } 1149e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::DeclRefExprClass: 1150e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::QualifiedDeclRefExprClass: 1151e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl())) 1152e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 11534a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (Ctx.getLangOptions().CPlusPlus && 1154e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman E->getType().getCVRQualifiers() == QualType::Const) { 11554a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // C++ 7.1.5.1p2 11564a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // A variable of non-volatile const-qualified integral or enumeration 11574a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl // type initialized by an ICE can be used in ICEs. 11584a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (const VarDecl *Dcl = 1159e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) { 11604a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl if (const Expr *Init = Dcl->getInit()) 1161e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(Init, Ctx); 11624a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl } 11634a4251b9e719415f30db0f5170abf31296a62225Sebastian Redl } 1164e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1165e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::UnaryOperatorClass: { 1166e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const UnaryOperator *Exp = cast<UnaryOperator>(E); 11675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 11685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 1169e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 11705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 1171e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case UnaryOperator::LNot: 11725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Plus: 11735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Minus: 11745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Not: 117560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman case UnaryOperator::Real: 117660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman case UnaryOperator::Imag: 1177e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(Exp->getSubExpr(), Ctx); 11785a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson case UnaryOperator::OffsetOf: 117960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // Note that per C99, offsetof must be an ICE. And AFAIK, using 118060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // Evaluate matches the proposed gcc behavior for cases like 118160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // "offsetof(struct s{int x[4];}, x[!.0])". This doesn't affect 118260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // compliance: we should warn earlier for offsetof expressions with 118360ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // array subscripts that aren't ICEs, and if the array subscripts 118460ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // are ICEs, the value of the offsetof must be an integer constant. 118560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return CheckEvalInICE(E, Ctx); 11865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 11875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1188e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::SizeOfAlignOfExprClass: { 1189e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(E); 1190e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (Exp->isSizeOf() && Exp->getTypeOfArgument()->isVariableArrayType()) 1191e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1192e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 11935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1194e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::BinaryOperatorClass: { 1195e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const BinaryOperator *Exp = cast<BinaryOperator>(E); 11965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 11975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 1198e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 11995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Mul: 12005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Div: 12015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Rem: 1202e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Add: 1203e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Sub: 12045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shl: 12055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shr: 1206e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LT: 1207e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::GT: 1208e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LE: 1209e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::GE: 1210e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::EQ: 1211e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::NE: 1212e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::And: 1213e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Xor: 1214e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Or: 1215e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::Comma: { 1216e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 1217e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 121860ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (Exp->getOpcode() == BinaryOperator::Div || 121960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman Exp->getOpcode() == BinaryOperator::Rem) { 122060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // Evaluate gives an error for undefined Div/Rem, so make sure 122160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // we don't evaluate one. 122260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (LHSResult.Val != 2 && RHSResult.Val != 2) { 122360ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman llvm::APSInt REval = Exp->getRHS()->EvaluateAsInt(Ctx); 122460ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (REval == 0) 122560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(1, E->getLocStart()); 122660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (REval.isSigned() && REval.isAllOnesValue()) { 122760ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman llvm::APSInt LEval = Exp->getLHS()->EvaluateAsInt(Ctx); 122860ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (LEval.isMinSignedValue()) 122960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(1, E->getLocStart()); 123060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 123160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 123260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 123360ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (Exp->getOpcode() == BinaryOperator::Comma) { 123460ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (Ctx.getLangOptions().C99) { 123560ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // C99 6.6p3 introduces a strange edge case: comma can be in an ICE 123660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // if it isn't evaluated. 123760ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (LHSResult.Val == 0 && RHSResult.Val == 0) 123860ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(1, E->getLocStart()); 123960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } else { 124060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman // In both C89 and C++, commas in ICEs are illegal. 124160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(2, E->getLocStart()); 124260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 1243b11e77836dd0867955c5abf32baf1c3e6c7f81e1Eli Friedman } 1244e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (LHSResult.Val >= RHSResult.Val) 1245e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return LHSResult; 1246e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return RHSResult; 12475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1248e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LAnd: 1249e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case BinaryOperator::LOr: { 1250e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx); 1251e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx); 1252e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (LHSResult.Val == 0 && RHSResult.Val == 1) { 1253e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // Rare case where the RHS has a comma "side-effect"; we need 1254e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // to actually check the condition to see whether the side 1255e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // with the comma is evaluated. 1256e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if ((Exp->getOpcode() == BinaryOperator::LAnd) != 125760ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman (Exp->getLHS()->EvaluateAsInt(Ctx) == 0)) 1258e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return RHSResult; 1259e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1260a135975d4257ccc83f13b607b29d882bb00c80b6Daniel Dunbar } 126160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman 1262e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (LHSResult.Val >= RHSResult.Val) 1263e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return LHSResult; 1264e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return RHSResult; 12655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1266987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner } 12675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1268e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::ImplicitCastExprClass: 1269e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CStyleCastExprClass: 1270e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXFunctionalCastExprClass: { 1271e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr(); 1272e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (SubExpr->getType()->isIntegralType()) 1273e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(SubExpr, Ctx); 1274e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (isa<FloatingLiteral>(SubExpr->IgnoreParens())) 1275e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1276e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return ICEDiag(2, E->getLocStart()); 1277e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1278e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::ConditionalOperatorClass: { 1279e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman const ConditionalOperator *Exp = cast<ConditionalOperator>(E); 128028daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner // If the condition (ignoring parens) is a __builtin_constant_p call, 128128daa53db73341b7ee7f269924ccfca1c6d179acChris Lattner // then only the true side is actually considered in an integer constant 128242b83dde7c700b34f9435ad746984169888ae705Chris Lattner // expression, and it is fully evaluated. This is an important GNU 128342b83dde7c700b34f9435ad746984169888ae705Chris Lattner // extension. See GCC PR38377 for discussion. 1284e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (const CallExpr *CallCE = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts())) 12853c385e5f8d9008fff18597ca302be19fa86e51f6Douglas Gregor if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) { 1286e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman Expr::EvalResult EVResult; 1287e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects || 1288e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman !EVResult.Val.isInt()) { 128960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman return ICEDiag(2, E->getLocStart()); 1290e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1291e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 129242b83dde7c700b34f9435ad746984169888ae705Chris Lattner } 1293e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx); 1294e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx); 1295e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx); 1296e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (CondResult.Val == 2) 1297e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CondResult; 1298e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (TrueResult.Val == 2) 1299e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return TrueResult; 1300e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (FalseResult.Val == 2) 1301e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return FalseResult; 1302e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (CondResult.Val == 1) 1303e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CondResult; 1304e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (TrueResult.Val == 0 && FalseResult.Val == 0) 1305e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return NoDiag(); 1306e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // Rare case where the diagnostics depend on which side is evaluated 1307e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // Note that if we get here, CondResult is 0, and at least one of 1308e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman // TrueResult and FalseResult is non-zero. 130960ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (Exp->getCond()->EvaluateAsInt(Ctx) == 0) { 1310e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return FalseResult; 1311e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1312e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return TrueResult; 13135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1314e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman case Expr::CXXDefaultArgExprClass: 1315e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx); 131660ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman case Expr::ChooseExprClass: { 13177976932a1c256d447316ffac58e9821417725e34Eli Friedman return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(Ctx), Ctx); 131860ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman } 13195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1320e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman} 13215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1322e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedmanbool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, 1323e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman SourceLocation *Loc, bool isEvaluated) const { 1324e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman ICEDiag d = CheckICE(this, Ctx); 1325e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (d.Val != 0) { 1326e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman if (Loc) *Loc = d.Loc; 1327e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman return false; 1328e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman } 1329e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman EvalResult EvalResult; 133060ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman if (!Evaluate(EvalResult, Ctx)) 133160ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman assert(0 && "ICE cannot be evaluated!"); 133260ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman assert(!EvalResult.HasSideEffects && "ICE with side effects!"); 133360ce9635b969d17ff1bbe269deff5ec3c6b1bc06Eli Friedman assert(EvalResult.Val.isInt() && "ICE that isn't integer!"); 1334e28d7195aad595154130ac8d03cc6c6513ece1bfEli Friedman Result = EvalResult.Val.getInt(); 13355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 13365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 13375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 13385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an 13395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// integer constant expression with the value zero, or if this is one that is 13405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// cast to void*. 1341efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlssonbool Expr::isNullPointerConstant(ASTContext &Ctx) const 1342efa9b3877ef298bcb792600ac33521827e1f7fafAnders Carlsson{ 13430777972d38a3125efed962b045704c30ae6965cfSebastian Redl // Strip off a cast to void*, if it exists. Except in C++. 13440835a3cdeefe714b4959d31127ea155e56393125Argyrios Kyrtzidis if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) { 13456215dee86c0e715b9f2b0d401ab2a5fcf629f1afSebastian Redl if (!Ctx.getLangOptions().CPlusPlus) { 13460777972d38a3125efed962b045704c30ae6965cfSebastian Redl // Check that it is a cast to void*. 13470777972d38a3125efed962b045704c30ae6965cfSebastian Redl if (const PointerType *PT = CE->getType()->getAsPointerType()) { 13480777972d38a3125efed962b045704c30ae6965cfSebastian Redl QualType Pointee = PT->getPointeeType(); 13490777972d38a3125efed962b045704c30ae6965cfSebastian Redl if (Pointee.getCVRQualifiers() == 0 && 13500777972d38a3125efed962b045704c30ae6965cfSebastian Redl Pointee->isVoidType() && // to void* 13510777972d38a3125efed962b045704c30ae6965cfSebastian Redl CE->getSubExpr()->getType()->isIntegerType()) // from int. 1352d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return CE->getSubExpr()->isNullPointerConstant(Ctx); 13530777972d38a3125efed962b045704c30ae6965cfSebastian Redl } 13545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1355aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1356aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Ignore the ImplicitCastExpr type entirely. 1357d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return ICE->getSubExpr()->isNullPointerConstant(Ctx); 1358aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1359aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Accept ((void*)0) as a null pointer constant, as many other 1360aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // implementations do. 1361d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return PE->getSubExpr()->isNullPointerConstant(Ctx); 13628123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner } else if (const CXXDefaultArgExpr *DefaultArg 13638123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner = dyn_cast<CXXDefaultArgExpr>(this)) { 136404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner // See through default argument expressions 1365d26527708b2b2f3b1d747f570efd10149d48364eAnders Carlsson return DefaultArg->getExpr()->isNullPointerConstant(Ctx); 13662d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor } else if (isa<GNUNullExpr>(this)) { 13672d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor // The GNU __null extension is always a null pointer constant. 13682d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor return true; 1369aaffbf7c790a324ed114184db771aae2d2e9151cSteve Naroff } 13702d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor 1371aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // This expression must be an integer type. 1372aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff if (!getType()->isIntegerType()) 1373aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return false; 1374aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff 13755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If we have an integer constant expression, we need to *evaluate* it and 13765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // test for the value 0. 137709de1767990d4828bcaf0dd22033a5dddeecbe08Eli Friedman llvm::APSInt Result; 137809de1767990d4828bcaf0dd22033a5dddeecbe08Eli Friedman return isIntegerConstantExpr(Result, Ctx) && Result == 0; 13795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 138031a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff 138127c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor/// isBitField - Return true if this expression is a bit-field. 138227c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregorbool Expr::isBitField() { 138327c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor Expr *E = this->IgnoreParenCasts(); 138427c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E)) 138586f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl())) 138686f194083504938df72135b5b66bf0c5cafd9498Douglas Gregor return Field->isBitField(); 138727c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor return false; 138827c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor} 138927c8dc06f65d7abcf6a7e7f64a7960c9a150ca01Douglas Gregor 13902140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner/// isArrow - Return true if the base expression is a pointer to vector, 13912140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner/// return false if the base expression is a vector. 13922140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattnerbool ExtVectorElementExpr::isArrow() const { 13932140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner return getBase()->getType()->isPointerType(); 13942140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner} 13952140e904dbe53657339cb5b1cc13de563ca0d1fcChris Lattner 1396213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanunsigned ExtVectorElementExpr::getNumElements() const { 13978a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (const VectorType *VT = getType()->getAsVectorType()) 13988a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return VT->getNumElements(); 13998a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return 1; 14004d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner} 14014d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner 14028a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// containsDuplicateElements - Return true if any element access is repeated. 1403213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanbool ExtVectorElementExpr::containsDuplicateElements() const { 1404d3c98a02c73417689deaaa6671ea6df7f2a8a73cDouglas Gregor const char *compStr = Accessor->getName(); 1405d3c98a02c73417689deaaa6671ea6df7f2a8a73cDouglas Gregor unsigned length = Accessor->getLength(); 1406190d6a25393995b42e32086949a68285ee423fb9Nate Begeman 1407190d6a25393995b42e32086949a68285ee423fb9Nate Begeman // Halving swizzles do not contain duplicate elements. 1408190d6a25393995b42e32086949a68285ee423fb9Nate Begeman if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") || 1409190d6a25393995b42e32086949a68285ee423fb9Nate Begeman !strcmp(compStr, "even") || !strcmp(compStr, "odd")) 1410190d6a25393995b42e32086949a68285ee423fb9Nate Begeman return false; 1411190d6a25393995b42e32086949a68285ee423fb9Nate Begeman 1412190d6a25393995b42e32086949a68285ee423fb9Nate Begeman // Advance past s-char prefix on hex swizzles. 1413190d6a25393995b42e32086949a68285ee423fb9Nate Begeman if (*compStr == 's') { 1414190d6a25393995b42e32086949a68285ee423fb9Nate Begeman compStr++; 1415190d6a25393995b42e32086949a68285ee423fb9Nate Begeman length--; 1416190d6a25393995b42e32086949a68285ee423fb9Nate Begeman } 1417fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff 14187e3e9b152e06edf329ceb32190d3255f248d4d5fChris Lattner for (unsigned i = 0; i != length-1; i++) { 1419fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *s = compStr+i; 1420fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff for (const char c = *s++; *s; s++) 1421fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff if (c == *s) 1422fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return true; 1423fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff } 1424fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return false; 1425fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff} 1426b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 14278a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 14283b8d116703db8018f855cbb4733ace426422623bNate Begemanvoid ExtVectorElementExpr::getEncodedElementAccess( 14293b8d116703db8018f855cbb4733ace426422623bNate Begeman llvm::SmallVectorImpl<unsigned> &Elts) const { 1430d3c98a02c73417689deaaa6671ea6df7f2a8a73cDouglas Gregor const char *compStr = Accessor->getName(); 1431353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman if (*compStr == 's') 1432353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman compStr++; 1433353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman 1434353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isHi = !strcmp(compStr, "hi"); 1435353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isLo = !strcmp(compStr, "lo"); 1436353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isEven = !strcmp(compStr, "even"); 1437353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman bool isOdd = !strcmp(compStr, "odd"); 1438353417af9d254d4fd0eb7d0a3ff71c4d8594ac58Nate Begeman 14398a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 14408a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman uint64_t Index; 14418a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 14428a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (isHi) 14438a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = e + i; 14448a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isLo) 14458a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = i; 14468a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isEven) 14478a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i; 14488a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isOdd) 14498a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i + 1; 14508a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else 14518a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = ExtVectorType::getAccessorIdx(compStr[i]); 1452b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 14533b8d116703db8018f855cbb4733ace426422623bNate Begeman Elts.push_back(Index); 1454b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner } 14558a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman} 14568a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 145768d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for instance messages. 1458bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1459a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1460db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 146149f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1462db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1463ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 146449f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 14655549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 146668d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[RECEIVER] = receiver; 146749f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 146849f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 146968d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 147068d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1471563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1472563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1473563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1474563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 147568d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for class messages. 147668d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// FIXME: clsName should be typed to ObjCInterfaceType 1477bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1478a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1479db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 148049f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1481db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1482ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 148349f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 14845549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 14854df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown); 148649f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 148749f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 148868d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 148968d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1490563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1491563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1492563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1493563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 14944df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek// constructor for class messages. 14954df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo, 14964df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek QualType retType, ObjCMethodDecl *mproto, 14974df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SourceLocation LBrac, SourceLocation RBrac, 14984df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek Expr **ArgExprs, unsigned nargs) 14994df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek: Expr(ObjCMessageExprClass, retType), SelName(selInfo), 15004df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekMethodProto(mproto) { 15014df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek NumArgs = nargs; 15024df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 15034df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown); 15044df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek if (NumArgs) { 15054df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek for (unsigned i = 0; i != NumArgs; ++i) 15064df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 15074df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 15084df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek LBracloc = LBrac; 15094df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek RBracloc = RBrac; 15104df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 15114df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 15124df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const { 15134df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek uintptr_t x = (uintptr_t) SubExprs[RECEIVER]; 15144df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek switch (x & Flags) { 15154df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek default: 15164df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek assert(false && "Invalid ObjCMessageExpr."); 15174df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsInstMeth: 15184df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, 0); 15194df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclUnknown: 15204df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, (IdentifierInfo*) (x & ~Flags)); 15214df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclKnown: { 15224df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags); 15234df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(D, D->getIdentifier()); 15244df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 15254df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 15264df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 15274df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 15280389e6bd0159bfdd08f7c50a37543b6e3adf0c33Chris Lattnervoid ObjCMessageExpr::setClassInfo(const ObjCMessageExpr::ClassInfo &CI) { 15290389e6bd0159bfdd08f7c50a37543b6e3adf0c33Chris Lattner if (CI.first == 0 && CI.second == 0) 15300389e6bd0159bfdd08f7c50a37543b6e3adf0c33Chris Lattner SubExprs[RECEIVER] = (Expr*)((uintptr_t)0 | IsInstMeth); 15310389e6bd0159bfdd08f7c50a37543b6e3adf0c33Chris Lattner else if (CI.first == 0) 15320389e6bd0159bfdd08f7c50a37543b6e3adf0c33Chris Lattner SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.second | IsClsMethDeclUnknown); 15330389e6bd0159bfdd08f7c50a37543b6e3adf0c33Chris Lattner else 15340389e6bd0159bfdd08f7c50a37543b6e3adf0c33Chris Lattner SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.first | IsClsMethDeclKnown); 15350389e6bd0159bfdd08f7c50a37543b6e3adf0c33Chris Lattner} 15360389e6bd0159bfdd08f7c50a37543b6e3adf0c33Chris Lattner 15370389e6bd0159bfdd08f7c50a37543b6e3adf0c33Chris Lattner 153827437caadea35f84d550cd29f024fcf3ea240eecChris Lattnerbool ChooseExpr::isConditionTrue(ASTContext &C) const { 15399a901bb63990574ff0bcc12ff851d7a71cff8ddbEli Friedman return getCond()->EvaluateAsInt(C) != 0; 154027437caadea35f84d550cd29f024fcf3ea240eecChris Lattner} 154127437caadea35f84d550cd29f024fcf3ea240eecChris Lattner 154294cd5d1397bb1a8bcd109602aa38dd787b164c22Douglas Gregorvoid ShuffleVectorExpr::setExprs(Expr ** Exprs, unsigned NumExprs) { 154394cd5d1397bb1a8bcd109602aa38dd787b164c22Douglas Gregor if (NumExprs) 154494cd5d1397bb1a8bcd109602aa38dd787b164c22Douglas Gregor delete [] SubExprs; 154594cd5d1397bb1a8bcd109602aa38dd787b164c22Douglas Gregor 154694cd5d1397bb1a8bcd109602aa38dd787b164c22Douglas Gregor SubExprs = new Stmt* [NumExprs]; 154794cd5d1397bb1a8bcd109602aa38dd787b164c22Douglas Gregor this->NumExprs = NumExprs; 154894cd5d1397bb1a8bcd109602aa38dd787b164c22Douglas Gregor memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs); 154994cd5d1397bb1a8bcd109602aa38dd787b164c22Douglas Gregor} 155094cd5d1397bb1a8bcd109602aa38dd787b164c22Douglas Gregor 15510518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redlvoid SizeOfAlignOfExpr::Destroy(ASTContext& C) { 15520518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // Override default behavior of traversing children. If this has a type 15530518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // operand and the type is a variable-length array, the child iteration 15540518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // will iterate over the size expression. However, this expression belongs 15550518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // to the type, not to this, so we don't want to delete it. 15560518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // We still want to delete this expression. 15578189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek if (isArgumentType()) { 15588189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek this->~SizeOfAlignOfExpr(); 15598189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek C.Deallocate(this); 15608189cde56b4f6f938cd65f53c932fe1860d0204cTed Kremenek } 15610518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl else 15620518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl Expr::Destroy(C); 15639048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar} 15649048891ff983d0681c116c6e8f1073aa31bdd6e8Daniel Dunbar 156577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 156605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor// DesignatedInitExpr 156705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor//===----------------------------------------------------------------------===// 156805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 156905c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorIdentifierInfo *DesignatedInitExpr::Designator::getFieldName() { 157005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(Kind == FieldDesignator && "Only valid on a field designator"); 157105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (Field.NameOrField & 0x01) 157205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01); 157305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else 157405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return getField()->getIdentifier(); 157505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 157605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 1577ffb4b6e299069139908540ce97be4462e16b53a4Douglas GregorDesignatedInitExpr::DesignatedInitExpr(QualType Ty, unsigned NumDesignators, 1578ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor const Designator *Designators, 1579ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor SourceLocation EqualOrColonLoc, 1580ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor bool GNUSyntax, 1581ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor unsigned NumSubExprs) 1582ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor : Expr(DesignatedInitExprClass, Ty), 1583ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax), 1584ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor NumDesignators(NumDesignators), NumSubExprs(NumSubExprs) { 1585ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor this->Designators = new Designator[NumDesignators]; 1586ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor for (unsigned I = 0; I != NumDesignators; ++I) 1587ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor this->Designators[I] = Designators[I]; 1588ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor} 1589ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor 159005c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr * 159105c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorDesignatedInitExpr::Create(ASTContext &C, Designator *Designators, 159205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor unsigned NumDesignators, 159305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Expr **IndexExprs, unsigned NumIndexExprs, 159405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor SourceLocation ColonOrEqualLoc, 159505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor bool UsesColonSyntax, Expr *Init) { 1596c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 1597c0ac4923f08b25ae973a8ee7942cf3eb89da57b7Steve Naroff sizeof(Stmt *) * (NumIndexExprs + 1), 8); 159805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor DesignatedInitExpr *DIE 1599ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor = new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators, Designators, 160005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ColonOrEqualLoc, UsesColonSyntax, 160105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor NumIndexExprs + 1); 160205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 160305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor // Fill in the designators 160405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor unsigned ExpectedNumSubExprs = 0; 160505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor designators_iterator Desig = DIE->designators_begin(); 160605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor for (unsigned Idx = 0; Idx < NumDesignators; ++Idx, ++Desig) { 160705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (Designators[Idx].isArrayDesignator()) 160805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ++ExpectedNumSubExprs; 160905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else if (Designators[Idx].isArrayRangeDesignator()) 161005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor ExpectedNumSubExprs += 2; 161105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor } 161205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(ExpectedNumSubExprs == NumIndexExprs && "Wrong number of indices!"); 161305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 161405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor // Fill in the subexpressions, including the initializer expression. 161505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor child_iterator Child = DIE->child_begin(); 161605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor *Child++ = Init; 161705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor for (unsigned Idx = 0; Idx < NumIndexExprs; ++Idx, ++Child) 161805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor *Child = IndexExprs[Idx]; 161905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 162005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return DIE; 162105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 162205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 1623d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas GregorDesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C, 1624d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor unsigned NumIndexExprs) { 1625d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor void *Mem = C.Allocate(sizeof(DesignatedInitExpr) + 1626d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor sizeof(Stmt *) * (NumIndexExprs + 1), 8); 1627d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor return new (Mem) DesignatedInitExpr(NumIndexExprs + 1); 1628d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor} 1629d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor 1630d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregorvoid DesignatedInitExpr::setDesignators(const Designator *Desigs, 1631d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor unsigned NumDesigs) { 1632d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor if (Designators) 1633d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor delete [] Designators; 1634d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor 1635d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor Designators = new Designator[NumDesigs]; 1636d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor NumDesignators = NumDesigs; 1637d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor for (unsigned I = 0; I != NumDesigs; ++I) 1638d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor Designators[I] = Desigs[I]; 1639d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor} 1640d077d759d0c7fceee98f4e77b6423a3f11cfc849Douglas Gregor 164105c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorSourceRange DesignatedInitExpr::getSourceRange() const { 164205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor SourceLocation StartLoc; 1643d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner Designator &First = 1644d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner *const_cast<DesignatedInitExpr*>(this)->designators_begin(); 164505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor if (First.isFieldDesignator()) { 1646eeae8f072748affce25ab4064982626361293390Douglas Gregor if (GNUSyntax) 164705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc); 164805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor else 164905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc); 165005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor } else 1651d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner StartLoc = 1652d603eaa682cecac2c10771a700cb83aa301653b4Chris Lattner SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc); 165305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return SourceRange(StartLoc, getInit()->getSourceRange().getEnd()); 165405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 165505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 165605c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayIndex(const Designator& D) { 165705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayDesignator && "Requires array designator"); 165805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 165905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 166005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 166105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 166205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 166305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 166405c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) { 166505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayRangeDesignator && 166605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor "Requires array range designator"); 166705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 166805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 166905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 167005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1)); 167105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 167205c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 167305c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorExpr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) { 167405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor assert(D.Kind == Designator::ArrayRangeDesignator && 167505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor "Requires array range designator"); 167605c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 167705c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 167805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 167905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2)); 168005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 168105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 1682ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor/// \brief Replaces the designator at index @p Idx with the series 1683ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor/// of designators in [First, Last). 1684ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregorvoid DesignatedInitExpr::ExpandDesignator(unsigned Idx, 1685ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor const Designator *First, 1686ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor const Designator *Last) { 1687ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor unsigned NumNewDesignators = Last - First; 1688ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor if (NumNewDesignators == 0) { 1689ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor std::copy_backward(Designators + Idx + 1, 1690ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor Designators + NumDesignators, 1691ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor Designators + Idx); 1692ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor --NumNewDesignators; 1693ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor return; 1694ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor } else if (NumNewDesignators == 1) { 1695ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor Designators[Idx] = *First; 1696ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor return; 1697ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor } 1698ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor 1699ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor Designator *NewDesignators 1700ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor = new Designator[NumDesignators - 1 + NumNewDesignators]; 1701ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor std::copy(Designators, Designators + Idx, NewDesignators); 1702ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor std::copy(First, Last, NewDesignators + Idx); 1703ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor std::copy(Designators + Idx + 1, Designators + NumDesignators, 1704ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor NewDesignators + Idx + NumNewDesignators); 1705ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor delete [] Designators; 1706ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor Designators = NewDesignators; 1707ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor NumDesignators = NumDesignators - 1 + NumNewDesignators; 1708ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor} 1709ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor 1710ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregorvoid DesignatedInitExpr::Destroy(ASTContext &C) { 1711ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor delete [] Designators; 1712ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor Expr::Destroy(C); 1713ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor} 1714ffb4b6e299069139908540ce97be4462e16b53a4Douglas Gregor 171505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor//===----------------------------------------------------------------------===// 1716ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek// ExprIterator. 1717ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek//===----------------------------------------------------------------------===// 1718ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek 1719ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); } 1720ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator*() const { return cast<Expr>(*I); } 1721ce2fc3a343ea6098a96d587071cee7299f11957aTed KremenekExpr* ExprIterator::operator->() const { return cast<Expr>(*I); } 1722ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator[](size_t idx) const { 1723ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek return cast<Expr>(I[idx]); 1724ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek} 1725ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); } 1726ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenekconst Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); } 1727ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek 1728ce2fc3a343ea6098a96d587071cee7299f11957aTed Kremenek//===----------------------------------------------------------------------===// 172977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// Child Iterators for iterating over subexpressions/substatements 173077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 173177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 173277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// DeclRefExpr 17339ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 17349ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 173577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 17367779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff// ObjCIvarRefExpr 17375549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; } 17385549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; } 17397779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff 1740e3e9add4fd788927df6f545570e7838db59c01d7Steve Naroff// ObjCPropertyRefExpr 17415549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; } 17425549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; } 1743ae7840776d6cd31b4d7a4a345b61bcbb3744df6cSteve Naroff 17445daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian// ObjCKVCRefExpr 17455daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz JahanianStmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; } 17465daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz JahanianStmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; } 17475daf570d0ce027e18ed5f9d66e6b2a14a40b720dFariborz Jahanian 1748cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas Gregor// ObjCSuperExpr 1749cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas GregorStmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); } 1750cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas GregorStmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); } 1751cd9b46e5442a3ef17f83f75177d8545cb5b3e2b9Douglas Gregor 1752d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner// PredefinedExpr 1753d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); } 1754d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); } 175577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 175677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// IntegerLiteral 17579ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 17589ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 175977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 176077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CharacterLiteral 1761d603eaa682cecac2c10771a700cb83aa301653b4Chris LattnerStmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();} 17629ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 176377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 176477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// FloatingLiteral 17659ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 17669ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 176777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 17685d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner// ImaginaryLiteral 17695549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; } 17705549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; } 17715d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner 177277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// StringLiteral 17739ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 17749ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 177577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 177677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ParenExpr 17775549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_begin() { return &Val; } 17785549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_end() { return &Val+1; } 177977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 178077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// UnaryOperator 17815549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_begin() { return &Val; } 17825549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_end() { return &Val+1; } 178377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 17840518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl// SizeOfAlignOfExpr 17850518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlStmt::child_iterator SizeOfAlignOfExpr::child_begin() { 17860518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // If this is of a type and the type is a VLA type (and not a typedef), the 17870518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // size expression of the VLA needs to be treated as an executable expression. 17880518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // Why isn't this weirdness documented better in StmtIterator? 17890518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (isArgumentType()) { 17900518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (VariableArrayType* T = dyn_cast<VariableArrayType>( 17910518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl getArgumentType().getTypePtr())) 17920518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(T); 17930518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(); 17940518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl } 1795d457589fc69dc7a9c80cd74d317c0b81a35a27c9Sebastian Redl return child_iterator(&Argument.Ex); 17969ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 17970518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlStmt::child_iterator SizeOfAlignOfExpr::child_end() { 17980518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl if (isArgumentType()) 17990518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl return child_iterator(); 1800d457589fc69dc7a9c80cd74d317c0b81a35a27c9Sebastian Redl return child_iterator(&Argument.Ex + 1); 18019ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 180277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 180377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ArraySubscriptExpr 18041237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_begin() { 18055549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 180677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 18071237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_end() { 18085549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 180977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 181077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 181177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CallExpr 18121237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_begin() { 18135549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 181477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 18151237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_end() { 18165549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumArgs+ARGS_START; 181777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 18181237c673c07f9d827129ba02720108816abde562Ted Kremenek 18191237c673c07f9d827129ba02720108816abde562Ted Kremenek// MemberExpr 18205549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_begin() { return &Base; } 18215549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_end() { return &Base+1; } 18221237c673c07f9d827129ba02720108816abde562Ted Kremenek 1823213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman// ExtVectorElementExpr 18245549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; } 18255549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; } 18261237c673c07f9d827129ba02720108816abde562Ted Kremenek 18271237c673c07f9d827129ba02720108816abde562Ted Kremenek// CompoundLiteralExpr 18285549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; } 18295549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; } 18301237c673c07f9d827129ba02720108816abde562Ted Kremenek 18311237c673c07f9d827129ba02720108816abde562Ted Kremenek// CastExpr 18325549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_begin() { return &Op; } 18335549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_end() { return &Op+1; } 18341237c673c07f9d827129ba02720108816abde562Ted Kremenek 18351237c673c07f9d827129ba02720108816abde562Ted Kremenek// BinaryOperator 18361237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_begin() { 18375549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 18381237c673c07f9d827129ba02720108816abde562Ted Kremenek} 18391237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_end() { 18405549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 18411237c673c07f9d827129ba02720108816abde562Ted Kremenek} 18421237c673c07f9d827129ba02720108816abde562Ted Kremenek 18431237c673c07f9d827129ba02720108816abde562Ted Kremenek// ConditionalOperator 18441237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_begin() { 18455549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 18461237c673c07f9d827129ba02720108816abde562Ted Kremenek} 18471237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_end() { 18485549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 18491237c673c07f9d827129ba02720108816abde562Ted Kremenek} 18501237c673c07f9d827129ba02720108816abde562Ted Kremenek 18511237c673c07f9d827129ba02720108816abde562Ted Kremenek// AddrLabelExpr 18529ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 18539ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 18541237c673c07f9d827129ba02720108816abde562Ted Kremenek 18551237c673c07f9d827129ba02720108816abde562Ted Kremenek// StmtExpr 18565549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_begin() { return &SubStmt; } 18575549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; } 18581237c673c07f9d827129ba02720108816abde562Ted Kremenek 18591237c673c07f9d827129ba02720108816abde562Ted Kremenek// TypesCompatibleExpr 18609ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_begin() { 18619ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18629ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 18639ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek 18649ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_end() { 18659ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 18669ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 18671237c673c07f9d827129ba02720108816abde562Ted Kremenek 18681237c673c07f9d827129ba02720108816abde562Ted Kremenek// ChooseExpr 18695549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; } 18705549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; } 18712d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor 18722d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas Gregor// GNUNullExpr 18732d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas GregorStmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); } 18742d8b273470684a9cd47f0ce24743cc1f71ef7cbcDouglas GregorStmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); } 18751237c673c07f9d827129ba02720108816abde562Ted Kremenek 1876d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman// ShuffleVectorExpr 1877d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_begin() { 18785549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 1879d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1880d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_end() { 18815549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumExprs; 1882d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1883d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 18847c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson// VAArgExpr 18855549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_begin() { return &Val; } 18865549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_end() { return &Val+1; } 18877c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 188866b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson// InitListExpr 188966b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_begin() { 18905549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] : 0; 189166b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 189266b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_end() { 18935549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0; 189466b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 189566b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson 18963498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor// DesignatedInitExpr 189705c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorStmt::child_iterator DesignatedInitExpr::child_begin() { 189805c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor char* Ptr = static_cast<char*>(static_cast<void *>(this)); 189905c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor Ptr += sizeof(DesignatedInitExpr); 190005c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr)); 190105c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 190205c13a3411782108d65aab3c77b1a231a4963bc0Douglas GregorStmt::child_iterator DesignatedInitExpr::child_end() { 190305c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor return child_iterator(&*child_begin() + NumSubExprs); 190405c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor} 190505c13a3411782108d65aab3c77b1a231a4963bc0Douglas Gregor 19063498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor// ImplicitValueInitExpr 19073498bdb9e9cb300de74c7b51c92608e2902b2348Douglas GregorStmt::child_iterator ImplicitValueInitExpr::child_begin() { 19083498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return child_iterator(); 19093498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor} 19103498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor 19113498bdb9e9cb300de74c7b51c92608e2902b2348Douglas GregorStmt::child_iterator ImplicitValueInitExpr::child_end() { 19123498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return child_iterator(); 19133498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor} 19143498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor 19151237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCStringLiteral 19169ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_begin() { 1917c6c16af963eddc3e9b75b5d2614d069e1162fe27Chris Lattner return &String; 19189ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 19199ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_end() { 1920c6c16af963eddc3e9b75b5d2614d069e1162fe27Chris Lattner return &String+1; 19219ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 19221237c673c07f9d827129ba02720108816abde562Ted Kremenek 19231237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCEncodeExpr 19249ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 19259ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 19261237c673c07f9d827129ba02720108816abde562Ted Kremenek 1927b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian// ObjCSelectorExpr 19289ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_begin() { 19299ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 19309ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 19319ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_end() { 19329ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 19339ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1934b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 1935390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian// ObjCProtocolExpr 19369ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_begin() { 19379ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 19389ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 19399ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_end() { 19409ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 19419ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1942390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian 1943563477da25f824e37c535131695dc4dc9b68c465Steve Naroff// ObjCMessageExpr 1944ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted KremenekStmt::child_iterator ObjCMessageExpr::child_begin() { 19455549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START; 1946563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1947563477da25f824e37c535131695dc4dc9b68c465Steve NaroffStmt::child_iterator ObjCMessageExpr::child_end() { 19485549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+ARGS_START+getNumArgs(); 1949563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1950563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 19514eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff// Blocks 195256ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt::child_iterator BlockExpr::child_begin() { return child_iterator(); } 195356ee6896f2efebffb4a2cce5a7610cdf1eddbbbeSteve NaroffStmt::child_iterator BlockExpr::child_end() { return child_iterator(); } 19544eb206bebcdab28ababe8df55c6185cec2cdc071Steve Naroff 19559da13f9ddb2567e36f4bbee7b3c32f54aeb76d5bTed KremenekStmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();} 19569da13f9ddb2567e36f4bbee7b3c32f54aeb76d5bTed KremenekStmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); } 1957