Expr.cpp revision e91593ef084479340582b2ba177b44be50a717b7
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 14f494b579b22f9950f5af021f0bf9879a91bb8b41Steve Naroff#include "clang/AST/ExprObjC.h" 152eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner#include "clang/AST/ASTContext.h" 16c44eec6dd29ee9415cbd38a35deff4c8b67abb6aAnders Carlsson#include "clang/AST/APValue.h" 17e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar#include "clang/AST/RecordLayout.h" 185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/StmtVisitor.h" 19c7229c338c21ef26b01ef3ecf9eec4fd373fa9ecChris Lattner#include "clang/Basic/IdentifierTable.h" 20da5a6b6d9fd52899499d5b7b46273ec844dcaa6eChris Lattner#include "clang/Basic/TargetInfo.h" 215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Primary Expressions. 255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 27da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// getValueAsApproximateDouble - This returns the value as an inaccurate 28da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// double. Note that this may cause loss of precision, but is useful for 29da8249e57f3badecf925571881fe57243935c6c1Chris Lattner/// debugging dumps, etc. 30da8249e57f3badecf925571881fe57243935c6c1Chris Lattnerdouble FloatingLiteral::getValueAsApproximateDouble() const { 31da8249e57f3badecf925571881fe57243935c6c1Chris Lattner llvm::APFloat V = getValue(); 32da8249e57f3badecf925571881fe57243935c6c1Chris Lattner V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven); 33da8249e57f3badecf925571881fe57243935c6c1Chris Lattner return V.convertToDouble(); 34da8249e57f3badecf925571881fe57243935c6c1Chris Lattner} 35da8249e57f3badecf925571881fe57243935c6c1Chris Lattner 36da8249e57f3badecf925571881fe57243935c6c1Chris Lattner 375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerStringLiteral::StringLiteral(const char *strData, unsigned byteLength, 385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer bool Wide, QualType t, SourceLocation firstLoc, 395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation lastLoc) : 405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Expr(StringLiteralClass, t) { 415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // OPTIMIZE: could allocate this appended to the StringLiteral. 425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer char *AStrData = new char[byteLength]; 435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer memcpy(AStrData, strData, byteLength); 445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer StrData = AStrData; 455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ByteLength = byteLength; 465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer IsWide = Wide; 475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer firstTokLoc = firstLoc; 485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer lastTokLoc = lastLoc; 495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerStringLiteral::~StringLiteral() { 525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer delete[] StrData; 535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool UnaryOperator::isPostfix(Opcode Op) { 565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostInc: 585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostDec: 595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 655a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenekbool UnaryOperator::isPrefix(Opcode Op) { 665a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek switch (Op) { 675a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek case PreInc: 685a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek case PreDec: 695a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek return true; 705a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek default: 715a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek return false; 725a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek } 735a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek} 745a56ac30d04e8f0431a08980885662a47a6308aaTed Kremenek 755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "sizeof" or "[pre]++". 775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *UnaryOperator::getOpcodeStr(Opcode Op) { 785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown unary operator"); 805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostInc: return "++"; 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PostDec: return "--"; 825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreInc: return "++"; 835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case PreDec: return "--"; 845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddrOf: return "&"; 855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Deref: return "*"; 865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Plus: return "+"; 875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Minus: return "-"; 885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Not: return "~"; 895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LNot: return "!"; 905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Real: return "__real"; 915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Imag: return "__imag"; 925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SizeOf: return "sizeof"; 935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AlignOf: return "alignof"; 945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Extension: return "__extension__"; 9573d0d4fac161ed12926e010dcf8b448a8de6a2ecChris Lattner case OffsetOf: return "__builtin_offsetof"; 965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Postfix Operators. 1015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 103e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman 1045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerCallExpr::CallExpr(Expr *fn, Expr **args, unsigned numargs, QualType t, 1055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation rparenloc) 10677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek : Expr(CallExprClass, t), NumArgs(numargs) { 1075549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[numargs+1]; 10877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[FN] = fn; 1095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0; i != numargs; ++i) 11077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek SubExprs[i+ARGS_START] = args[i]; 1115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RParenLoc = rparenloc; 1125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 114d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// setNumArgs - This changes the number of arguments present in this call. 115d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// Any orphaned expressions are deleted by this, and any new operands are set 116d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner/// to null. 117d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattnervoid CallExpr::setNumArgs(unsigned NumArgs) { 118d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // No change, just return. 119d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs == getNumArgs()) return; 120d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 121d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // If shrinking # arguments, just delete the extras and forgot them. 122d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner if (NumArgs < getNumArgs()) { 123d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i) 124d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner delete getArg(i); 125d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 126d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner return; 127d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner } 128d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 129d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Otherwise, we are growing the # arguments. New an bigger argument array. 1305549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek Stmt **NewSubExprs = new Stmt*[NumArgs+1]; 131d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Copy over args. 132d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) 133d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = SubExprs[i]; 134d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner // Null out new args. 135d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) 136d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner NewSubExprs[i] = 0; 137d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 138d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner delete[] SubExprs; 139d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner SubExprs = NewSubExprs; 140d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner this->NumArgs = NumArgs; 141d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner} 142d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 143c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroffbool CallExpr::isBuiltinConstantExpr() const { 144c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // All simple function calls (e.g. func()) are implicitly cast to pointer to 145c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // function. As a result, we try and obtain the DeclRefExpr from the 146c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff // ImplicitCastExpr. 147c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 148c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 149c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff return false; 150c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff 151c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 152c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (!DRE) 153c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff return false; 154c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff 155bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 156bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson if (!FDecl) 157bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson return false; 158bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson 159bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson unsigned builtinID = FDecl->getIdentifier()->getBuiltinID(); 160bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson if (!builtinID) 161bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson return false; 162bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson 163bcba201a1118d7852b8b97187d495ae2a4f49519Anders Carlsson // We have a builtin that is a constant expression 164861dc46e3c53d64d8685fd9a0f95faac710b61c6Eli Friedman return builtinID == Builtin::BI__builtin___CFStringMakeConstantString || 165861dc46e3c53d64d8685fd9a0f95faac710b61c6Eli Friedman builtinID == Builtin::BI__builtin_classify_type; 166c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff} 167d18b3299debb7b0dbd9d34d9369189dc98c87f53Chris Lattner 16813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroffbool CallExpr::isBuiltinClassifyType(llvm::APSInt &Result) const { 16913b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff // The following enum mimics gcc's internal "typeclass.h" file. 17013b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff enum gcc_type_class { 17113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff no_type_class = -1, 17213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff void_type_class, integer_type_class, char_type_class, 17313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff enumeral_type_class, boolean_type_class, 17413b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff pointer_type_class, reference_type_class, offset_type_class, 17513b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff real_type_class, complex_type_class, 17613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff function_type_class, method_type_class, 17713b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff record_type_class, union_type_class, 17813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff array_type_class, string_type_class, 17913b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff lang_type_class 18013b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff }; 18113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result.setIsSigned(true); 18213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff 18313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff // All simple function calls (e.g. func()) are implicitly cast to pointer to 18413b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff // function. As a result, we try and obtain the DeclRefExpr from the 18513b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff // ImplicitCastExpr. 18613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee()); 18713b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()). 18813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return false; 18913b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()); 19013b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (!DRE) 19113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return false; 19213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff 19313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff // We have a DeclRefExpr. 19413b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (strcmp(DRE->getDecl()->getName(), "__builtin_classify_type") == 0) { 19513b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff // If no argument was supplied, default to "no_type_class". This isn't 19613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff // ideal, however it's what gcc does. 19713b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = static_cast<uint64_t>(no_type_class); 19813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (NumArgs >= 1) { 19913b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff QualType argType = getArg(0)->getType(); 20013b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff 20113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (argType->isVoidType()) 20213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = void_type_class; 20313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isEnumeralType()) 20413b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = enumeral_type_class; 20513b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isBooleanType()) 20613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = boolean_type_class; 20713b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isCharType()) 20813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = string_type_class; // gcc doesn't appear to use char_type_class 20913b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isIntegerType()) 21013b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = integer_type_class; 21113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isPointerType()) 21213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = pointer_type_class; 21313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isReferenceType()) 21413b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = reference_type_class; 21513b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isRealType()) 21613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = real_type_class; 21713b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isComplexType()) 21813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = complex_type_class; 21913b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isFunctionType()) 22013b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = function_type_class; 22113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isStructureType()) 22213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = record_type_class; 22313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isUnionType()) 22413b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = union_type_class; 22513b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isArrayType()) 22613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = array_type_class; 22713b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else if (argType->isUnionType()) 22813b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff Result = union_type_class; 22913b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff else // FIXME: offset_type_class, method_type_class, & lang_type_class? 2303ef5bc03d0bfc05fd76fc83beeb1b7ddbbb463daChris Lattner assert(0 && "CallExpr::isBuiltinClassifyType(): unimplemented type"); 23113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff } 23213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return true; 23313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff } 23413b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return false; 23513b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff} 23613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff 2375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it 2385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// corresponds to, e.g. "<<=". 2395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerconst char *BinaryOperator::getOpcodeStr(Opcode Op) { 2405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Op) { 2415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown binary operator"); 2425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Mul: return "*"; 2435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Div: return "/"; 2445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Rem: return "%"; 2455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Add: return "+"; 2465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Sub: return "-"; 2475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shl: return "<<"; 2485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Shr: return ">>"; 2495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LT: return "<"; 2505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GT: return ">"; 2515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LE: return "<="; 2525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case GE: return ">="; 2535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case EQ: return "=="; 2545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case NE: return "!="; 2555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case And: return "&"; 2565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Xor: return "^"; 2575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Or: return "|"; 2585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LAnd: return "&&"; 2595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LOr: return "||"; 2605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Assign: return "="; 2615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MulAssign: return "*="; 2625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DivAssign: return "/="; 2635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case RemAssign: return "%="; 2645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AddAssign: return "+="; 2655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SubAssign: return "-="; 2665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShlAssign: return "<<="; 2675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ShrAssign: return ">>="; 2685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case AndAssign: return "&="; 2695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case XorAssign: return "^="; 2705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case OrAssign: return "|="; 2715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case Comma: return ","; 2725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 27566b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonInitListExpr::InitListExpr(SourceLocation lbraceloc, 27666b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson Expr **initexprs, unsigned numinits, 27766b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson SourceLocation rbraceloc) 278c5ae899b4bbf65488445316c63168079177db0edSteve Naroff : Expr(InitListExprClass, QualType()), 279c5ae899b4bbf65488445316c63168079177db0edSteve Naroff LBraceLoc(lbraceloc), RBraceLoc(rbraceloc) 28066b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson{ 28166b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson for (unsigned i = 0; i != numinits; i++) 282c5ae899b4bbf65488445316c63168079177db0edSteve Naroff InitExprs.push_back(initexprs[i]); 28366b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 2845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 2865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Generic Expression Routines 2875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 2885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// hasLocalSideEffect - Return true if this immediate expression has side 2905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// effects, not counting any sub-expressions. 2915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerbool Expr::hasLocalSideEffect() const { 2925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 2935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 2945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 2955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: 2965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return cast<ParenExpr>(this)->getSubExpr()->hasLocalSideEffect(); 2975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperatorClass: { 2985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const UnaryOperator *UO = cast<UnaryOperator>(this); 2995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (UO->getOpcode()) { 3015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: return false; 3025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostInc: 3035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PostDec: 3045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PreInc: 3055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::PreDec: 3065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; // ++/-- 3075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Deref: 3095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Dereferencing a volatile pointer is a side-effect. 3105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return getType().isVolatileQualified(); 3115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Real: 3125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Imag: 3135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // accessing a piece of a volatile complex is a side-effect. 3145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return UO->getSubExpr()->getType().isVolatileQualified(); 3155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 3175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return UO->getSubExpr()->hasLocalSideEffect(); 3185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 320e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner case BinaryOperatorClass: { 321e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(this); 322e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner // Consider comma to have side effects if the LHS and RHS both do. 323e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner if (BinOp->getOpcode() == BinaryOperator::Comma) 324e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner return BinOp->getLHS()->hasLocalSideEffect() && 325e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner BinOp->getRHS()->hasLocalSideEffect(); 326e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner 327e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner return BinOp->isAssignmentOp(); 328e7716e6133e23e4a89248a65a388bc840d8c130cChris Lattner } 329eb14fe839ec24c2ca14e5f094be147a34e3d3339Chris Lattner case CompoundAssignOperatorClass: 3301f683e9cf2e855b32d3fb4b142aa121cd3cf1088Chris Lattner return true; 3315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 332ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian case ConditionalOperatorClass: { 333ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 334ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian return Exp->getCond()->hasLocalSideEffect() 335ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian || (Exp->getLHS() && Exp->getLHS()->hasLocalSideEffect()) 336ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian || (Exp->getRHS() && Exp->getRHS()->hasLocalSideEffect()); 337ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian } 338ab38e4b50268633f037a10841fdfb612513f8d33Fariborz Jahanian 3395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case MemberExprClass: 3405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: 3415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the base pointer or element is to a volatile pointer/field, accessing 3425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // if is a side effect. 3435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return getType().isVolatileQualified(); 344211f6adf1301a1461015fb6cb08a05f0a35b65f3Eli Friedman 3455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case CallExprClass: 3465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // TODO: check attributes for pure/const. "void foo() { strlen("bar"); }" 3475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // should warn. 3485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 349a9c01021724b9b546d282b8609cbe559734812ecChris Lattner case ObjCMessageExprClass: 350a9c01021724b9b546d282b8609cbe559734812ecChris Lattner return true; 351611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner case StmtExprClass: { 352611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // Statement exprs don't logically have side effects themselves, but are 353611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // sometimes used in macros in ways that give them a type that is unused. 354611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // For example ({ blah; foo(); }) will end up with a type if foo has a type. 355611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // however, if the result of the stmt expr is dead, we don't want to emit a 356611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner // warning. 357611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt(); 358611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (!CS->body_empty()) 359611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner if (const Expr *E = dyn_cast<Expr>(CS->body_back())) 360611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner return E->hasLocalSideEffect(); 361611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner return false; 362611b2eccaf3869f32de51ecc02985426d1c0aaefChris Lattner } 3635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case CastExprClass: 3645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is a cast to void, check the operand. Otherwise, the result of 3655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the cast is unused. 3665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (getType()->isVoidType()) 3675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return cast<CastExpr>(this)->getSubExpr()->hasLocalSideEffect(); 3685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 36904421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner 3704be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman case ImplicitCastExprClass: 3714be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman // Check the operand, since implicit casts are inserted by Sema 3724be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman return cast<ImplicitCastExpr>(this)->getSubExpr()->hasLocalSideEffect(); 3734be1f47de20525ad90f02ba8682a7e2cbd3205d1Eli Friedman 37404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 37504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->hasLocalSideEffect(); 3765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 3785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an 3805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// incomplete type other than void. Nonarray expressions that can be lvalues: 3815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - name, where name must be a variable 3825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e[i] 3835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - (e), where e must be an lvalue 3845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e.name, where e must be an lvalue 3855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - e->name 3865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - *e, the type of e cannot be a function type 3875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// - string-constant 3887da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner/// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension] 38908ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling/// - reference type [C++ [expr]] 3905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 39128be73f74c9e241a23ea24fe5756623de6bf1084Chris LattnerExpr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const { 3925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // first, check the type (C99 6.3.2.1) 393cb4f9a6d0be445d84af35ba81323be6127816f9eChris Lattner if (TR->isFunctionType()) // from isObjectType() 3945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_NotObjectType; 3955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 396acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff // Allow qualified void which is an incomplete type other than void (yuck). 39728be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers()) 398acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff return LV_IncompleteVoidType; 399acb818a4f7d9b608826171094d6b5a555a8fe694Steve Naroff 400cb4f9a6d0be445d84af35ba81323be6127816f9eChris Lattner if (TR->isReferenceType()) // C++ [expr] 40108ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling return LV_Valid; 40208ad47cbd1f81fcb31dbc731c13b885a07e12704Bill Wendling 4035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the type looks fine, now check the expression 4045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 4055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case StringLiteralClass: // C99 6.5.1p4 4067323a6297edad643c202594dcf3d9a174de96ca6Anders Carlsson return LV_Valid; 4075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2)))) 4085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // For vectors, make sure base is an lvalue (i.e. not a function call). 4095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType()) 41028be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx); 4115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 4124111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner case DeclRefExprClass: { // C99 6.5.1p2 4134111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner const Decl *RefdDecl = cast<DeclRefExpr>(this)->getDecl(); 4144111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner if (isa<VarDecl>(RefdDecl) || isa<ImplicitParamDecl>(RefdDecl)) 4155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_Valid; 4165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 4174111024be81e7c0525e42dadcc126d27e5bf2425Chris Lattner } 418fdd75663fffeb2058a7847975e50837e61200593Anton Korobeynikov case MemberExprClass: { // C99 6.5.2.3p4 4195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const MemberExpr *m = cast<MemberExpr>(this); 42028be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx); 421fdd75663fffeb2058a7847975e50837e61200593Anton Korobeynikov } 4227da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner case UnaryOperatorClass: 4235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref) 4247da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner return LV_Valid; // C99 6.5.3p4 4257da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner 4267da36f642e907ff5a5ba4b18b5bfebfabf36ecc7Chris Lattner if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real || 427baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag || 428baf0d6678418e0dd9309438c3e50274253cfc7b2Chris Lattner cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension) 42928be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU. 4305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 4315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: // C99 6.5.1p5 43228be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx); 433e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff case CompoundLiteralExprClass: // C99 6.5.2.5p5 434e6386394677ed4f77b20e2e3d5446a3a2f628e53Steve Naroff return LV_Valid; 435213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman case ExtVectorElementExprClass: 436213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements()) 437fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_DuplicateVectorComponents; 438fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return LV_Valid; 439027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff case ObjCIvarRefExprClass: // ObjC instance variables are lvalues. 440027282d1c1ac151aa7b1b3b45babc918b8ad456aSteve Naroff return LV_Valid; 441799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff case ObjCPropertyRefExprClass: // FIXME: check if read-only property. 442799a6a6850af625946bb8d88ca960bb6604e3858Steve Naroff return LV_Valid; 443d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 444d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner return (cast<PredefinedExpr>(this)->getIdentType() 445d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner == PredefinedExpr::CXXThis 4467c4a191d8be7eac565a64369de072b2a52bf6749Chris Lattner ? LV_InvalidExpression : LV_Valid); 44704421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 44828be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx); 4495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 4505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 4515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LV_InvalidExpression; 4535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, 4565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// does not have an incomplete type, does not have a const-qualified type, and 4575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// if it is a structure or union, does not have any member (including, 4585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// recursively, any member or element of all contained aggregates or unions) 4595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// with a const-qualified type. 46028be73f74c9e241a23ea24fe5756623de6bf1084Chris LattnerExpr::isModifiableLvalueResult Expr::isModifiableLvalue(ASTContext &Ctx) const { 46128be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner isLvalueResult lvalResult = isLvalue(Ctx); 4625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (lvalResult) { 4645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_Valid: break; 4655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_NotObjectType: return MLV_NotObjectType; 4665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_IncompleteVoidType: return MLV_IncompleteVoidType; 467fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents; 4685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case LV_InvalidExpression: return MLV_InvalidExpression; 4695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 470c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 471c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner QualType CT = Ctx.getCanonicalType(getType()); 472c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner 473c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT.isConstQualified()) 4745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 475c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isArrayType()) 4765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ArrayType; 477c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (CT->isIncompleteType()) 4785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_IncompleteType; 4795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 480c63a1f276f7b324fd9a4be82098b1c8f7bf30733Chris Lattner if (const RecordType *r = CT->getAsRecordType()) { 4815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (r->hasConstFields()) 4825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_ConstQualified; 4835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return MLV_Valid; 4855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4872e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek/// hasGlobalStorage - Return true if this expression has static storage 4884cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// duration. This means that the address of this expression is a link-time 4894cc627111453b75519d5130b57e06256da7b00e8Chris Lattner/// constant. 4902e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenekbool Expr::hasGlobalStorage() const { 4911d09ecca892185ba067e47ba879f424de59950efChris Lattner switch (getStmtClass()) { 4921d09ecca892185ba067e47ba879f424de59950efChris Lattner default: 4931d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 4944cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ParenExprClass: 4952e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage(); 4964cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ImplicitCastExprClass: 4972e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage(); 498e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff case CompoundLiteralExprClass: 499e9b12198c4cc7f5687960100351b4af006c14469Steve Naroff return cast<CompoundLiteralExpr>(this)->isFileScope(); 5001d09ecca892185ba067e47ba879f424de59950efChris Lattner case DeclRefExprClass: { 5011d09ecca892185ba067e47ba879f424de59950efChris Lattner const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 5021d09ecca892185ba067e47ba879f424de59950efChris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 5032e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return VD->hasGlobalStorage(); 50463f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon if (isa<FunctionDecl>(D)) 50563f067f5a75ae97b53dc7a6a6530e2c72c8bb7f8Seo Sanghyeon return true; 5061d09ecca892185ba067e47ba879f424de59950efChris Lattner return false; 5071d09ecca892185ba067e47ba879f424de59950efChris Lattner } 508fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner case MemberExprClass: { 5091d09ecca892185ba067e47ba879f424de59950efChris Lattner const MemberExpr *M = cast<MemberExpr>(this); 5102e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return !M->isArrow() && M->getBase()->hasGlobalStorage(); 511fb7080663a0f0abd687a6f58ac917d9a76318b73Chris Lattner } 5124cc627111453b75519d5130b57e06256da7b00e8Chris Lattner case ArraySubscriptExprClass: 5132e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage(); 514d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner case PredefinedExprClass: 515fa28b30d5a1e93e5263be33e343532b900d2c643Chris Lattner return true; 51604421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 51704421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage(); 5181d09ecca892185ba067e47ba879f424de59950efChris Lattner } 5191d09ecca892185ba067e47ba879f424de59950efChris Lattner} 5201d09ecca892185ba067e47ba879f424de59950efChris Lattner 5214e99a5fc3b203397a91136c6e695e405fb8fc606Ted KremenekExpr* Expr::IgnoreParens() { 5224e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek Expr* E = this; 5234e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek while (ParenExpr* P = dyn_cast<ParenExpr>(E)) 5244e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek E = P->getSubExpr(); 5254e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 5264e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek return E; 5274e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek} 5284e99a5fc3b203397a91136c6e695e405fb8fc606Ted Kremenek 52956f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr 53056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner/// or CastExprs or ImplicitCastExprs, returning their operand. 53156f349400c5932a196509c0480ff6f99a9a0b48fChris LattnerExpr *Expr::IgnoreParenCasts() { 53256f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner Expr *E = this; 53356f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner while (true) { 53456f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner if (ParenExpr *P = dyn_cast<ParenExpr>(E)) 53556f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 53656f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else if (CastExpr *P = dyn_cast<CastExpr>(E)) 53756f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 53856f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) 53956f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner E = P->getSubExpr(); 54056f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner else 54156f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner return E; 54256f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner } 54356f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner} 54456f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner 54556f349400c5932a196509c0480ff6f99a9a0b48fChris Lattner 54638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroffbool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const { 54738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff switch (getStmtClass()) { 54838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff default: 54938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (Loc) *Loc = getLocStart(); 55038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 55138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case ParenExprClass: 55238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return cast<ParenExpr>(this)->getSubExpr()->isConstantExpr(Ctx, Loc); 55338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case StringLiteralClass: 5545d37e32a5bfefacdd7b4d0664199d72c703d489dSteve Naroff case ObjCStringLiteralClass: 55538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case FloatingLiteralClass: 55638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case IntegerLiteralClass: 55738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case CharacterLiteralClass: 55838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case ImaginaryLiteralClass: 5591a86b33c1870fee08d281c9f07ac1280195a7faeAnders Carlsson case TypesCompatibleExprClass: 5601a86b33c1870fee08d281c9f07ac1280195a7faeAnders Carlsson case CXXBoolLiteralExprClass: 5612777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 56238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case CallExprClass: { 56338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const CallExpr *CE = cast<CallExpr>(this); 564c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff if (CE->isBuiltinConstantExpr()) 565c4f8e8b645b8e0e685c089dde0674c6f29a24168Steve Naroff return true; 56638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (Loc) *Loc = getLocStart(); 56738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 56838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 5694ef8dd6e8736097bf9e3c387139c668565d89dcaChris Lattner case DeclRefExprClass: { 5704ef8dd6e8736097bf9e3c387139c668565d89dcaChris Lattner const Decl *D = cast<DeclRefExpr>(this)->getDecl(); 5714ef8dd6e8736097bf9e3c387139c668565d89dcaChris Lattner // Accept address of function. 5724ef8dd6e8736097bf9e3c387139c668565d89dcaChris Lattner if (isa<EnumConstantDecl>(D) || isa<FunctionDecl>(D)) 5732777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 57438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (Loc) *Loc = getLocStart(); 5751d09ecca892185ba067e47ba879f424de59950efChris Lattner if (isa<VarDecl>(D)) 5761d09ecca892185ba067e47ba879f424de59950efChris Lattner return TR->isArrayType(); 57738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 5784ef8dd6e8736097bf9e3c387139c668565d89dcaChris Lattner } 579b8f13a8baff3df080fe024fec47746e9a79fe649Steve Naroff case CompoundLiteralExprClass: 580b8f13a8baff3df080fe024fec47746e9a79fe649Steve Naroff if (Loc) *Loc = getLocStart(); 581b8f13a8baff3df080fe024fec47746e9a79fe649Steve Naroff // Allow "(int []){2,4}", since the array will be converted to a pointer. 582d47d4f518e43eaa716e2d18359bd725a03b87f58Nate Begeman // Allow "(vector type){2,4}" since the elements are all constant. 583d47d4f518e43eaa716e2d18359bd725a03b87f58Nate Begeman return TR->isArrayType() || TR->isVectorType(); 58438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperatorClass: { 58538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const UnaryOperator *Exp = cast<UnaryOperator>(this); 58638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 5871d09ecca892185ba067e47ba879f424de59950efChris Lattner // C99 6.6p9 588239c15e5b07a6cc84278ede87edf638922767520Chris Lattner if (Exp->getOpcode() == UnaryOperator::AddrOf) { 5892e5f54aa1dd15a62c34a9d1d24a5a0692f43934aTed Kremenek if (!Exp->getSubExpr()->hasGlobalStorage()) { 590239c15e5b07a6cc84278ede87edf638922767520Chris Lattner if (Loc) *Loc = getLocStart(); 591239c15e5b07a6cc84278ede87edf638922767520Chris Lattner return false; 592239c15e5b07a6cc84278ede87edf638922767520Chris Lattner } 593239c15e5b07a6cc84278ede87edf638922767520Chris Lattner return true; 594239c15e5b07a6cc84278ede87edf638922767520Chris Lattner } 5951d09ecca892185ba067e47ba879f424de59950efChris Lattner 59638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // Get the operand value. If this is sizeof/alignof, do not evalute the 59738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // operand. This affects C99 6.6p3. 598d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff if (!Exp->isSizeOfAlignOfOp() && 599d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff Exp->getOpcode() != UnaryOperator::OffsetOf && 60038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff !Exp->getSubExpr()->isConstantExpr(Ctx, Loc)) 60138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 60238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 60338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff switch (Exp->getOpcode()) { 60438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 60538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // See C99 6.6p3. 60638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff default: 60738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (Loc) *Loc = Exp->getOperatorLoc(); 60838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 60938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::Extension: 61038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return true; // FIXME: this is wrong. 61138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::SizeOf: 61238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::AlignOf: 613d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff case UnaryOperator::OffsetOf: 61438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2. 6153c2b3170041f69a92904e3bab9b6d654eaf260acEli Friedman if (!Exp->getSubExpr()->getType()->isConstantSizeType()) { 61665383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner if (Loc) *Loc = Exp->getOperatorLoc(); 61738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 61865383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner } 6192777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 62038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::LNot: 62138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::Plus: 62238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::Minus: 62338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case UnaryOperator::Not: 6242777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 62538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 62638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 62738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case SizeOfAlignOfTypeExprClass: { 62838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(this); 62938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // alignof always evaluates to a constant. 630a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner if (Exp->isSizeOf() && !Exp->getArgumentType()->isVoidType() && 631a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner !Exp->getArgumentType()->isConstantSizeType()) { 63265383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner if (Loc) *Loc = Exp->getOperatorLoc(); 63338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 63465383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner } 6352777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 63638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 63738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case BinaryOperatorClass: { 63838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const BinaryOperator *Exp = cast<BinaryOperator>(this); 63938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 64038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff // The LHS of a constant expr is always evaluated and needed. 64138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (!Exp->getLHS()->isConstantExpr(Ctx, Loc)) 64238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 64338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 64438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (!Exp->getRHS()->isConstantExpr(Ctx, Loc)) 64538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 6462777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 64738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 64838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case ImplicitCastExprClass: 64938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case CastExprClass: { 65038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const Expr *SubExpr; 65138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff SourceLocation CastLoc; 65238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (const CastExpr *C = dyn_cast<CastExpr>(this)) { 65338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff SubExpr = C->getSubExpr(); 65438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff CastLoc = C->getLParenLoc(); 65538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } else { 65638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff SubExpr = cast<ImplicitCastExpr>(this)->getSubExpr(); 65738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff CastLoc = getLocStart(); 65838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 65938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (!SubExpr->isConstantExpr(Ctx, Loc)) { 66038374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff if (Loc) *Loc = SubExpr->getLocStart(); 66138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 66238374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 6632777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 66438374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 66538374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff case ConditionalOperatorClass: { 66638374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 6672777e494c96bee69141a10a0174d5da16e7b927bChris Lattner if (!Exp->getCond()->isConstantExpr(Ctx, Loc) || 6683907323dd6665c0c4e383435cb145233f4533406Anders Carlsson // Handle the GNU extension for missing LHS. 6693907323dd6665c0c4e383435cb145233f4533406Anders Carlsson !(Exp->getLHS() && Exp->getLHS()->isConstantExpr(Ctx, Loc)) || 6702777e494c96bee69141a10a0174d5da16e7b927bChris Lattner !Exp->getRHS()->isConstantExpr(Ctx, Loc)) 67138374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff return false; 6722777e494c96bee69141a10a0174d5da16e7b927bChris Lattner return true; 67338374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 674d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff case InitListExprClass: { 675d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff const InitListExpr *Exp = cast<InitListExpr>(this); 676d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff unsigned numInits = Exp->getNumInits(); 677d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff for (unsigned i = 0; i < numInits; i++) { 678d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff if (!Exp->getInit(i)->isConstantExpr(Ctx, Loc)) { 679d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff if (Loc) *Loc = Exp->getInit(i)->getLocStart(); 680d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff return false; 681d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff } 682d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff } 683d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff return true; 684d0091aa3850a8c8be94c68710ed4ef1317729ba0Steve Naroff } 68504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 68604421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this)->getExpr()->isConstantExpr(Ctx, Loc); 68738374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff } 68838374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff} 68938374b05791ee93300b9fbe8ceb3957f54184b37Steve Naroff 6905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isIntegerConstantExpr - this recursive routine will test if an expression is 6915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// an integer constant expression. Note: With the introduction of VLA's in 6925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// C99 the result of the sizeof operator is no longer always a constant 6935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// expression. The generalization of the wording to include any subexpression 6945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// that is not evaluated (C99 6.6p3) means that nonconstant subexpressions 6955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// can appear as operands to other operators (e.g. &&, ||, ?:). For instance, 6965f6b632391e24b08ead3e62ba2e2765e770382edNuno Lopes/// "0 || f()" can be treated as a constant expression. In C90 this expression, 6975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// occurring in a context requiring a constant, would have been a constraint 6985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// violation. FIXME: This routine currently implements C90 semantics. 6995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// To properly implement C99 semantics this routine will need to evaluate 7005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// expressions involving operators previously mentioned. 7015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero, 7035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// comma, etc 7045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 7055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// FIXME: This should ext-warn on overflow during evaluation! ISO C does not 706ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner/// permit this. This includes things like (int)1e1000 707ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// 708ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof 709ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer 710ce0afc0b09accbf7370b2ba87574b2c4be7fb032Chris Lattner/// cast+dereference. 711590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattnerbool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx, 712590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner SourceLocation *Loc, bool isEvaluated) const { 7135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (getStmtClass()) { 7145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 7155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 7165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 7175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ParenExprClass: 7185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return cast<ParenExpr>(this)->getSubExpr()-> 719590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 7205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case IntegerLiteralClass: 7215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = cast<IntegerLiteral>(this)->getValue(); 7225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 7232eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner case CharacterLiteralClass: { 7242eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner const CharacterLiteral *CL = cast<CharacterLiteral>(this); 72598be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 7262eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner Result = CL->getValue(); 727f0fbcb356bc4eb5f6467dc4fc4bc447e9a630102Chris Lattner Result.setIsUnsigned(!getType()->isSignedIntegerType()); 7285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 7292eadfb638eb1bb6ccfd6fd0453e764d47e27eed9Chris Lattner } 7307b658aa315784fa489a32daeacfe400512ce468dSteve Naroff case TypesCompatibleExprClass: { 7317b658aa315784fa489a32daeacfe400512ce468dSteve Naroff const TypesCompatibleExpr *TCE = cast<TypesCompatibleExpr>(this); 73298be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 733ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff Result = Ctx.typesAreCompatible(TCE->getArgType1(), TCE->getArgType2()); 734389cecc83f33e93c8ba6bf2e8269b8690404416fSteve Naroff break; 7357b658aa315784fa489a32daeacfe400512ce468dSteve Naroff } 73613b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff case CallExprClass: { 73713b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff const CallExpr *CE = cast<CallExpr>(this); 73898be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 73913b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (CE->isBuiltinClassifyType(Result)) 74013b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff break; 74113b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff if (Loc) *Loc = getLocStart(); 74213b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff return false; 74313b7c5ff42d6077a8d59e2c9ec9e7fedd0150ae6Steve Naroff } 7445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclRefExprClass: 7455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const EnumConstantDecl *D = 7465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer dyn_cast<EnumConstantDecl>(cast<DeclRefExpr>(this)->getDecl())) { 7475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = D->getInitVal(); 7485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 7495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 7505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 7515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 7525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperatorClass: { 7535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const UnaryOperator *Exp = cast<UnaryOperator>(this); 7545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Get the operand value. If this is sizeof/alignof, do not evalute the 7565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // operand. This affects C99 6.6p3. 7575a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson if (!Exp->isSizeOfAlignOfOp() && !Exp->isOffsetOfOp() && 758602dafdea34b78c7bc1f4601f94062afa4139e76Chris Lattner !Exp->getSubExpr()->isIntegerConstantExpr(Result, Ctx, Loc,isEvaluated)) 7595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 7605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 7625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Address, indirect, pre/post inc/dec, etc are not valid constant exprs. 7635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // See C99 6.6p3. 7645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 7655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = Exp->getOperatorLoc(); 7665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 7675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Extension: 76876e773a443be9f006610f46529e07d4c8d857680Chris Lattner return true; // FIXME: this is wrong. 7695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::SizeOf: 7705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::AlignOf: 771a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // Return the result in the right width. 77298be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 773a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 774a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // sizeof(void) and __alignof__(void) = 1 as a gcc extension. 775a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner if (Exp->getSubExpr()->getType()->isVoidType()) { 776a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner Result = 1; 777a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner break; 778a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner } 779a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 7805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // sizeof(vla) is not a constantexpr: C99 6.5.3.4p2. 7813c2b3170041f69a92904e3bab9b6d654eaf260acEli Friedman if (!Exp->getSubExpr()->getType()->isConstantSizeType()) { 78265383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner if (Loc) *Loc = Exp->getOperatorLoc(); 7835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 78465383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner } 7855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 78676e773a443be9f006610f46529e07d4c8d857680Chris Lattner // Get information about the size or align. 787efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner if (Exp->getSubExpr()->getType()->isFunctionType()) { 788efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner // GCC extension: sizeof(function) = 1. 789efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner Result = Exp->getOpcode() == UnaryOperator::AlignOf ? 4 : 1; 790da5a6b6d9fd52899499d5b7b46273ec844dcaa6eChris Lattner } else { 79198be4943e8dc4f3905629a7102668960873cf863Chris Lattner unsigned CharSize = Ctx.Target.getCharWidth(); 79264a31ef8d46fcdf2bca38098e3206a45052b515dAnders Carlsson if (Exp->getOpcode() == UnaryOperator::AlignOf) 79398be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result = Ctx.getTypeAlign(Exp->getSubExpr()->getType()) / CharSize; 79464a31ef8d46fcdf2bca38098e3206a45052b515dAnders Carlsson else 79598be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result = Ctx.getTypeSize(Exp->getSubExpr()->getType()) / CharSize; 796da5a6b6d9fd52899499d5b7b46273ec844dcaa6eChris Lattner } 7975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 7985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::LNot: { 799bf7553889594886213e05cd3f94a6d6f7747bf7bChris Lattner bool Val = Result == 0; 80098be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 8015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = Val; 8025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Plus: 8055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Minus: 8075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = -Result; 8085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case UnaryOperator::Not: 8105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = ~Result; 8115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8125a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson case UnaryOperator::OffsetOf: 8135a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson Result = Exp->evaluateOffsetOf(Ctx); 8145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case SizeOfAlignOfTypeExprClass: { 8185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const SizeOfAlignOfTypeExpr *Exp = cast<SizeOfAlignOfTypeExpr>(this); 819a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 820a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // Return the result in the right width. 82198be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType()))); 822a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 823a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // sizeof(void) and __alignof__(void) = 1 as a gcc extension. 824a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner if (Exp->getArgumentType()->isVoidType()) { 825a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner Result = 1; 826a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner break; 827a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner } 828a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner 829a269ebfd91c4fa47e051fa1fa904833a022fe025Chris Lattner // alignof always evaluates to a constant, sizeof does if arg is not VLA. 8303c2b3170041f69a92904e3bab9b6d654eaf260acEli Friedman if (Exp->isSizeOf() && !Exp->getArgumentType()->isConstantSizeType()) { 83165383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner if (Loc) *Loc = Exp->getOperatorLoc(); 8325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 83365383479cb2caf0f136f58fecdbdbaf9c497b7a1Chris Lattner } 8345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 83576e773a443be9f006610f46529e07d4c8d857680Chris Lattner // Get information about the size or align. 836efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner if (Exp->getArgumentType()->isFunctionType()) { 837efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner // GCC extension: sizeof(function) = 1. 838efdd1574e3cca00ef0410aee8b7ee36eda5a2f71Chris Lattner Result = Exp->isSizeOf() ? 1 : 4; 8396a24acbb3dbb3bea9426716bee6ad6023ad15f3fAnders Carlsson } else { 84098be4943e8dc4f3905629a7102668960873cf863Chris Lattner unsigned CharSize = Ctx.Target.getCharWidth(); 8416a24acbb3dbb3bea9426716bee6ad6023ad15f3fAnders Carlsson if (Exp->isSizeOf()) 84298be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result = Ctx.getTypeSize(Exp->getArgumentType()) / CharSize; 8436a24acbb3dbb3bea9426716bee6ad6023ad15f3fAnders Carlsson else 84498be4943e8dc4f3905629a7102668960873cf863Chris Lattner Result = Ctx.getTypeAlign(Exp->getArgumentType()) / CharSize; 845060e470e53b73167114284eb0b8c3e25bb3dad99Ted Kremenek } 8465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperatorClass: { 8495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const BinaryOperator *Exp = cast<BinaryOperator>(this); 8505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // The LHS of a constant expr is always evaluated and needed. 852590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner if (!Exp->getLHS()->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 8535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 8545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::APSInt RHS(Result); 8565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // The short-circuiting &&/|| operators don't necessarily evaluate their 8585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // RHS. Make sure to pass isEvaluated down correctly. 8595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Exp->isLogicalOp()) { 8605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer bool RHSEval; 8615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Exp->getOpcode() == BinaryOperator::LAnd) 8625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RHSEval = Result != 0; 8635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else { 8645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(Exp->getOpcode() == BinaryOperator::LOr &&"Unexpected logical"); 8655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RHSEval = Result == 0; 8665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 868590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, 8695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer isEvaluated & RHSEval)) 8705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 8715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 872590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, isEvaluated)) 8735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 8745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 8765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (Exp->getOpcode()) { 8775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: 8785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 8795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 8805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Mul: 8815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result *= RHS; 8825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Div: 8845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (RHS == 0) { 8855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!isEvaluated) break; 8865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 8875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 8885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result /= RHS; 8905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Rem: 8925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (RHS == 0) { 8935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!isEvaluated) break; 8945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 8955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 8965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 8975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result %= RHS; 8985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 8995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Add: Result += RHS; break; 9005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Sub: Result -= RHS; break; 9015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shl: 902701e5eb608d7b0b94279b6be86bf90f8dea68e9eChris Lattner Result <<= 903701e5eb608d7b0b94279b6be86bf90f8dea68e9eChris Lattner static_cast<uint32_t>(RHS.getLimitedValue(Result.getBitWidth()-1)); 9045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Shr: 906701e5eb608d7b0b94279b6be86bf90f8dea68e9eChris Lattner Result >>= 907701e5eb608d7b0b94279b6be86bf90f8dea68e9eChris Lattner static_cast<uint32_t>(RHS.getLimitedValue(Result.getBitWidth()-1)); 9085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::LT: Result = Result < RHS; break; 9105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::GT: Result = Result > RHS; break; 9115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::LE: Result = Result <= RHS; break; 9125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::GE: Result = Result >= RHS; break; 9135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::EQ: Result = Result == RHS; break; 9145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::NE: Result = Result != RHS; break; 9155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::And: Result &= RHS; break; 9165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Xor: Result ^= RHS; break; 9175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Or: Result |= RHS; break; 9185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::LAnd: 9195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = Result != 0 && RHS != 0; 9205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::LOr: 9225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = Result != 0 || RHS != 0; 9235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case BinaryOperator::Comma: 9265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.6p3: "shall not contain assignment, ..., or comma operators, 9275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // *except* when they are contained within a subexpression that is not 9285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // evaluated". Note that Assignment can never happen due to constraints 9295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // on the LHS subexpr, so we don't need to check it here. 9305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (isEvaluated) { 9315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Loc) *Loc = getLocStart(); 9325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // The result of the constant expr is the RHS. 9365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result = RHS; 9375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 9385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(!Exp->isAssignmentOp() && "LHS can't be a constant expr!"); 9415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 94326dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner case ImplicitCastExprClass: 9445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case CastExprClass: { 94526dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner const Expr *SubExpr; 94626dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner SourceLocation CastLoc; 94726dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (const CastExpr *C = dyn_cast<CastExpr>(this)) { 94826dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner SubExpr = C->getSubExpr(); 94926dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner CastLoc = C->getLParenLoc(); 95026dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner } else { 95126dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner SubExpr = cast<ImplicitCastExpr>(this)->getSubExpr(); 95226dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner CastLoc = getLocStart(); 95326dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner } 95426dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner 9555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.6p6: shall only convert arithmetic types to integer types. 95626dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (!SubExpr->getType()->isArithmeticType() || 95726dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner !getType()->isIntegerType()) { 95826dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (Loc) *Loc = SubExpr->getLocStart(); 9595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 9605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 961987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner 96298be4943e8dc4f3905629a7102668960873cf863Chris Lattner uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType())); 963987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner 9645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Handle simple integer->integer casts. 96526dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (SubExpr->getType()->isIntegerType()) { 96626dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner if (!SubExpr->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 9675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 96826dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner 96926dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner // Figure out if this is a truncate, extend or noop cast. 97026dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner // If the input is signed, do a sign extend, noop, or truncate. 971c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner if (getType()->isBooleanType()) { 972c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner // Conversion to bool compares against zero. 973c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner Result = Result != 0; 974c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner Result.zextOrTrunc(DestWidth); 975c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner } else if (SubExpr->getType()->isSignedIntegerType()) 97626dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner Result.sextOrTrunc(DestWidth); 97726dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner else // If the input is unsigned, do a zero extend, noop, or truncate. 97826dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner Result.zextOrTrunc(DestWidth); 9795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 9805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 9815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 9825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Allow floating constants that are the immediate operands of casts or that 9835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // are parenthesized. 98426dc7b39267b7d29b35a7887a5b8e54697192192Chris Lattner const Expr *Operand = SubExpr; 9855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer while (const ParenExpr *PE = dyn_cast<ParenExpr>(Operand)) 9865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Operand = PE->getSubExpr(); 987987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner 988987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner // If this isn't a floating literal, we can't handle it. 989987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(Operand); 990987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner if (!FL) { 991987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner if (Loc) *Loc = Operand->getLocStart(); 992987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner return false; 993987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner } 994c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner 995c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner // If the destination is boolean, compare against zero. 996c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner if (getType()->isBooleanType()) { 997c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner Result = !FL->getValue().isZero(); 998c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner Result.zextOrTrunc(DestWidth); 999c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner break; 1000c0a356b4fa35bf3f7d6031c229c071eef1a8f7a9Chris Lattner } 10015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1002987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner // Determine whether we are converting to unsigned or signed. 1003987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner bool DestSigned = getType()->isSignedIntegerType(); 1004ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner 1005ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner // TODO: Warn on overflow, but probably not here: isIntegerConstantExpr can 1006ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner // be called multiple times per AST. 1007987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner uint64_t Space[4]; 1008ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner (void)FL->getValue().convertToInteger(Space, DestWidth, DestSigned, 1009ccc213f5d4034bb6fcda14cad112d9029a508b66Chris Lattner llvm::APFloat::rmTowardZero); 1010987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner Result = llvm::APInt(DestWidth, 4, Space); 1011987b15db39745cd7fb2e634ba1a4b85469ac9131Chris Lattner break; 10125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case ConditionalOperatorClass: { 10145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const ConditionalOperator *Exp = cast<ConditionalOperator>(this); 10155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1016590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattner if (!Exp->getCond()->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 10175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const Expr *TrueExp = Exp->getLHS(); 10205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const Expr *FalseExp = Exp->getRHS(); 10215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Result == 0) std::swap(TrueExp, FalseExp); 10225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Evaluate the false one first, discard the result. 10243907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (FalseExp && !FalseExp->isIntegerConstantExpr(Result, Ctx, Loc, false)) 10255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Evalute the true one, capture the result. 10273907323dd6665c0c4e383435cb145233f4533406Anders Carlsson if (TrueExp && 10283907323dd6665c0c4e383435cb145233f4533406Anders Carlsson !TrueExp->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated)) 10295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return false; 10305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 10315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 103204421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner case CXXDefaultArgExprClass: 103304421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return cast<CXXDefaultArgExpr>(this) 103404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner ->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated); 10355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 10365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Cases that are valid constant exprs fall through to here. 10385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result.setIsUnsigned(getType()->isUnsignedIntegerType()); 10395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 10405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 10415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 10425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an 10435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// integer constant expression with the value zero, or if this is one that is 10445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// cast to void*. 1045590b6646ef747d2f7b42e5f40487ff07642d7b6fChris Lattnerbool Expr::isNullPointerConstant(ASTContext &Ctx) const { 1046aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Strip off a cast to void*, if it exists. 1047aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff if (const CastExpr *CE = dyn_cast<CastExpr>(this)) { 1048aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Check that it is a cast to void*. 10494b3f9b367c16e494c181d6f03d53497ae1275fbeEli Friedman if (const PointerType *PT = CE->getType()->getAsPointerType()) { 10505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer QualType Pointee = PT->getPointeeType(); 1051f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner if (Pointee.getCVRQualifiers() == 0 && 1052f46699ce225811d8d9dbab9d00189a0e54469457Chris Lattner Pointee->isVoidType() && // to void* 1053aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff CE->getSubExpr()->getType()->isIntegerType()) // from int. 1054aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return CE->getSubExpr()->isNullPointerConstant(Ctx); 10555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1056aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) { 1057aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Ignore the ImplicitCastExpr type entirely. 1058aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return ICE->getSubExpr()->isNullPointerConstant(Ctx); 1059aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) { 1060aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // Accept ((void*)0) as a null pointer constant, as many other 1061aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // implementations do. 1062aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return PE->getSubExpr()->isNullPointerConstant(Ctx); 10638123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner } else if (const CXXDefaultArgExpr *DefaultArg 10648123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner = dyn_cast<CXXDefaultArgExpr>(this)) { 106504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner // See through default argument expressions 106604421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return DefaultArg->getExpr()->isNullPointerConstant(Ctx); 1067aaffbf7c790a324ed114184db771aae2d2e9151cSteve Naroff } 1068aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff 1069aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff // This expression must be an integer type. 1070aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff if (!getType()->isIntegerType()) 1071aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return false; 1072aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff 10735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If we have an integer constant expression, we need to *evaluate* it and 10745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // test for the value 0. 10755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::APSInt Val(32); 1076aa58f00ebba5f14955001736b7aea20bb5bd91e6Steve Naroff return isIntegerConstantExpr(Val, Ctx, 0, true) && Val == 0; 10775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 107831a458462c6cf417a84e0c47852b18fb22d79acbSteve Naroff 1079213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanunsigned ExtVectorElementExpr::getNumElements() const { 10808a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (const VectorType *VT = getType()->getAsVectorType()) 10818a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return VT->getNumElements(); 10828a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman return 1; 10834d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner} 10844d0ac88428b3ed7c6f3a2f4e758ea5424ecd70aeChris Lattner 10858a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// containsDuplicateElements - Return true if any element access is repeated. 1086213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begemanbool ExtVectorElementExpr::containsDuplicateElements() const { 1087fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *compStr = Accessor.getName(); 1088fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff unsigned length = strlen(compStr); 1089fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff 1090fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff for (unsigned i = 0; i < length-1; i++) { 1091fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff const char *s = compStr+i; 1092fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff for (const char c = *s++; *s; s++) 1093fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff if (c == *s) 1094fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return true; 1095fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff } 1096fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff return false; 1097fec0b49c3fa621fbf63e420f3d54a5bb3a0265d2Steve Naroff} 1098b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 10998a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray. 11003b8d116703db8018f855cbb4733ace426422623bNate Begemanvoid ExtVectorElementExpr::getEncodedElementAccess( 11013b8d116703db8018f855cbb4733ace426422623bNate Begeman llvm::SmallVectorImpl<unsigned> &Elts) const { 1102b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner const char *compStr = Accessor.getName(); 11038a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 11048a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman bool isHi = !strcmp(compStr, "hi"); 11058a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman bool isLo = !strcmp(compStr, "lo"); 11068a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman bool isEven = !strcmp(compStr, "e"); 11078a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman bool isOdd = !strcmp(compStr, "o"); 11088a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 11098a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman for (unsigned i = 0, e = getNumElements(); i != e; ++i) { 11108a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman uint64_t Index; 11118a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 11128a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman if (isHi) 11138a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = e + i; 11148a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isLo) 11158a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = i; 11168a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isEven) 11178a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i; 11188a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else if (isOdd) 11198a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = 2 * i + 1; 11208a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman else 11218a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman Index = ExtVectorType::getAccessorIdx(compStr[i]); 1122b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner 11233b8d116703db8018f855cbb4733ace426422623bNate Begeman Elts.push_back(Index); 1124b8f849da3cedee2f61ad98389115ddd04e439d60Chris Lattner } 11258a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman} 11268a99764f9b778a54e7440b1ee06a1e48f25d76d8Nate Begeman 112768d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for instance messages. 1128bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo, 1129a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1130db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 113149f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1132db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1133ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 113449f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 11355549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 113668d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[RECEIVER] = receiver; 113749f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 113849f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 113968d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 114068d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1141563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1142563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1143563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1144563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 114568d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// constructor for class messages. 114668d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff// FIXME: clsName should be typed to ObjCInterfaceType 1147bcfb06ac6da1aa3c74ac1ef7a49c2807522366e7Steve NaroffObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo, 1148a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek QualType retType, ObjCMethodDecl *mproto, 1149db611d556f71f98b66b69514d45958d76e5727abSteve Naroff SourceLocation LBrac, SourceLocation RBrac, 115049f109c786f99eb7468dac3976db083a65493444Steve Naroff Expr **ArgExprs, unsigned nargs) 1151db611d556f71f98b66b69514d45958d76e5727abSteve Naroff : Expr(ObjCMessageExprClass, retType), SelName(selInfo), 1152ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted Kremenek MethodProto(mproto) { 115349f109c786f99eb7468dac3976db083a65493444Steve Naroff NumArgs = nargs; 11545549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 11554df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown); 115649f109c786f99eb7468dac3976db083a65493444Steve Naroff if (NumArgs) { 115749f109c786f99eb7468dac3976db083a65493444Steve Naroff for (unsigned i = 0; i != NumArgs; ++i) 115868d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 115968d331a78e655d97294e94fcfa63f92cc1f40578Steve Naroff } 1160563477da25f824e37c535131695dc4dc9b68c465Steve Naroff LBracloc = LBrac; 1161563477da25f824e37c535131695dc4dc9b68c465Steve Naroff RBracloc = RBrac; 1162563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1163563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 11644df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek// constructor for class messages. 11654df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo, 11664df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek QualType retType, ObjCMethodDecl *mproto, 11674df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SourceLocation LBrac, SourceLocation RBrac, 11684df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek Expr **ArgExprs, unsigned nargs) 11694df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek: Expr(ObjCMessageExprClass, retType), SelName(selInfo), 11704df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekMethodProto(mproto) { 11714df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek NumArgs = nargs; 11724df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs = new Stmt*[NumArgs+1]; 11734df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown); 11744df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek if (NumArgs) { 11754df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek for (unsigned i = 0; i != NumArgs; ++i) 11764df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]); 11774df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 11784df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek LBracloc = LBrac; 11794df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek RBracloc = RBrac; 11804df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 11814df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 11824df728e368fa1f65ffc57572fed613dcca5b4fe8Ted KremenekObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const { 11834df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek uintptr_t x = (uintptr_t) SubExprs[RECEIVER]; 11844df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek switch (x & Flags) { 11854df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek default: 11864df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek assert(false && "Invalid ObjCMessageExpr."); 11874df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsInstMeth: 11884df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, 0); 11894df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclUnknown: 11904df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(0, (IdentifierInfo*) (x & ~Flags)); 11914df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek case IsClsMethDeclKnown: { 11924df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags); 11934df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek return ClassInfo(D, D->getIdentifier()); 11944df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 11954df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek } 11964df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek} 11974df728e368fa1f65ffc57572fed613dcca5b4fe8Ted Kremenek 119827437caadea35f84d550cd29f024fcf3ea240eecChris Lattnerbool ChooseExpr::isConditionTrue(ASTContext &C) const { 119927437caadea35f84d550cd29f024fcf3ea240eecChris Lattner llvm::APSInt CondVal(32); 120027437caadea35f84d550cd29f024fcf3ea240eecChris Lattner bool IsConst = getCond()->isIntegerConstantExpr(CondVal, C); 120127437caadea35f84d550cd29f024fcf3ea240eecChris Lattner assert(IsConst && "Condition of choose expr must be i-c-e"); IsConst=IsConst; 120227437caadea35f84d550cd29f024fcf3ea240eecChris Lattner return CondVal != 0; 120327437caadea35f84d550cd29f024fcf3ea240eecChris Lattner} 120427437caadea35f84d550cd29f024fcf3ea240eecChris Lattner 12055a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlssonstatic int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) 12065a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson{ 12075a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 12085a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson QualType Ty = ME->getBase()->getType(); 12095a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12105a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson RecordDecl *RD = Ty->getAsRecordType()->getDecl(); 121198be4943e8dc4f3905629a7102668960873cf863Chris Lattner const ASTRecordLayout &RL = C.getASTRecordLayout(RD); 12125a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson FieldDecl *FD = ME->getMemberDecl(); 12135a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12145a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson // FIXME: This is linear time. 12155a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson unsigned i = 0, e = 0; 12165a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson for (i = 0, e = RD->getNumMembers(); i != e; i++) { 12175a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson if (RD->getMember(i) == FD) 12185a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson break; 12195a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } 12205a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12215a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase()); 12225a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) { 12235a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson const Expr *Base = ASE->getBase(); 12245a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson llvm::APSInt Idx(32); 12255a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson bool ICE = ASE->getIdx()->isIntegerConstantExpr(Idx, C); 12265a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson assert(ICE && "Array index is not a constant integer!"); 12275a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 122898be4943e8dc4f3905629a7102668960873cf863Chris Lattner int64_t size = C.getTypeSize(ASE->getType()); 12295a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson size *= Idx.getSExtValue(); 12305a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12315a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return size + evaluateOffsetOf(C, Base); 12325a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson } else if (isa<CompoundLiteralExpr>(E)) 12335a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return 0; 12345a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12355a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson assert(0 && "Unknown offsetof subexpression!"); 12365a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson return 0; 12375a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 12385a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 12395a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlssonint64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const 12405a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson{ 12415a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson assert(Opc == OffsetOf && "Unary operator not offsetof!"); 12425a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 124398be4943e8dc4f3905629a7102668960873cf863Chris Lattner unsigned CharSize = C.Target.getCharWidth(); 12445549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize; 12455a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 12465a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 124777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 124877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// Child Iterators for iterating over subexpressions/substatements 124977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek//===----------------------------------------------------------------------===// 125077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 125177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// DeclRefExpr 12529ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); } 12539ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); } 125477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 12557779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff// ObjCIvarRefExpr 12565549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; } 12575549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; } 12587779db42c94405ecbd6ee45efb293483fa6cbeffSteve Naroff 1259e3e9add4fd788927df6f545570e7838db59c01d7Steve Naroff// ObjCPropertyRefExpr 12605549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; } 12615549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; } 1262ae7840776d6cd31b4d7a4a345b61bcbb3744df6cSteve Naroff 1263d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner// PredefinedExpr 1264d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); } 1265d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris LattnerStmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); } 126677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 126777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// IntegerLiteral 12689ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); } 12699ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); } 127077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 127177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CharacterLiteral 12729ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator CharacterLiteral::child_begin() { return child_iterator(); } 12739ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); } 127477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 127577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// FloatingLiteral 12769ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); } 12779ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); } 127877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 12795d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner// ImaginaryLiteral 12805549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; } 12815549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; } 12825d66145eed1c319df5a69977cb8ff74f597ea544Chris Lattner 128377ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// StringLiteral 12849ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_begin() { return child_iterator(); } 12859ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator StringLiteral::child_end() { return child_iterator(); } 128677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 128777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ParenExpr 12885549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_begin() { return &Val; } 12895549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ParenExpr::child_end() { return &Val+1; } 129077ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 129177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// UnaryOperator 12925549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_begin() { return &Val; } 12935549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator UnaryOperator::child_end() { return &Val+1; } 129477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 129577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// SizeOfAlignOfTypeExpr 12969ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator SizeOfAlignOfTypeExpr::child_begin() { 1297699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek // If the type is a VLA type (and not a typedef), the size expression of the 1298699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek // VLA needs to be treated as an executable expression. 1299699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek if (VariableArrayType* T = dyn_cast<VariableArrayType>(Ty.getTypePtr())) 1300699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek return child_iterator(T); 1301699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek else 1302699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek return child_iterator(); 13039ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 13049ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator SizeOfAlignOfTypeExpr::child_end() { 1305699e9fbeae34cdd651b8e6308649c8939f090cbdTed Kremenek return child_iterator(); 13069ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 130777ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 130877ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// ArraySubscriptExpr 13091237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_begin() { 13105549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 131177ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 13121237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ArraySubscriptExpr::child_end() { 13135549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 131477ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 131577ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek 131677ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek// CallExpr 13171237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_begin() { 13185549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 131977ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 13201237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator CallExpr::child_end() { 13215549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumArgs+ARGS_START; 132277ed8e4edf6ed78c53fb20ec3210aff2a59c9d87Ted Kremenek} 13231237c673c07f9d827129ba02720108816abde562Ted Kremenek 13241237c673c07f9d827129ba02720108816abde562Ted Kremenek// MemberExpr 13255549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_begin() { return &Base; } 13265549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator MemberExpr::child_end() { return &Base+1; } 13271237c673c07f9d827129ba02720108816abde562Ted Kremenek 1328213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman// ExtVectorElementExpr 13295549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; } 13305549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; } 13311237c673c07f9d827129ba02720108816abde562Ted Kremenek 13321237c673c07f9d827129ba02720108816abde562Ted Kremenek// CompoundLiteralExpr 13335549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; } 13345549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; } 13351237c673c07f9d827129ba02720108816abde562Ted Kremenek 13361237c673c07f9d827129ba02720108816abde562Ted Kremenek// ImplicitCastExpr 13375549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImplicitCastExpr::child_begin() { return &Op; } 13385549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ImplicitCastExpr::child_end() { return &Op+1; } 13391237c673c07f9d827129ba02720108816abde562Ted Kremenek 13401237c673c07f9d827129ba02720108816abde562Ted Kremenek// CastExpr 13415549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_begin() { return &Op; } 13425549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator CastExpr::child_end() { return &Op+1; } 13431237c673c07f9d827129ba02720108816abde562Ted Kremenek 13441237c673c07f9d827129ba02720108816abde562Ted Kremenek// BinaryOperator 13451237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_begin() { 13465549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 13471237c673c07f9d827129ba02720108816abde562Ted Kremenek} 13481237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator BinaryOperator::child_end() { 13495549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 13501237c673c07f9d827129ba02720108816abde562Ted Kremenek} 13511237c673c07f9d827129ba02720108816abde562Ted Kremenek 13521237c673c07f9d827129ba02720108816abde562Ted Kremenek// ConditionalOperator 13531237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_begin() { 13545549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 13551237c673c07f9d827129ba02720108816abde562Ted Kremenek} 13561237c673c07f9d827129ba02720108816abde562Ted KremenekStmt::child_iterator ConditionalOperator::child_end() { 13575549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+END_EXPR; 13581237c673c07f9d827129ba02720108816abde562Ted Kremenek} 13591237c673c07f9d827129ba02720108816abde562Ted Kremenek 13601237c673c07f9d827129ba02720108816abde562Ted Kremenek// AddrLabelExpr 13619ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); } 13629ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); } 13631237c673c07f9d827129ba02720108816abde562Ted Kremenek 13641237c673c07f9d827129ba02720108816abde562Ted Kremenek// StmtExpr 13655549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_begin() { return &SubStmt; } 13665549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; } 13671237c673c07f9d827129ba02720108816abde562Ted Kremenek 13681237c673c07f9d827129ba02720108816abde562Ted Kremenek// TypesCompatibleExpr 13699ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_begin() { 13709ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 13719ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 13729ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek 13739ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator TypesCompatibleExpr::child_end() { 13749ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 13759ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 13761237c673c07f9d827129ba02720108816abde562Ted Kremenek 13771237c673c07f9d827129ba02720108816abde562Ted Kremenek// ChooseExpr 13785549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; } 13795549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; } 13801237c673c07f9d827129ba02720108816abde562Ted Kremenek 1381e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman// OverloadExpr 13825549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator OverloadExpr::child_begin() { return &SubExprs[0]; } 13835549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator OverloadExpr::child_end() { return &SubExprs[0]+NumExprs; } 1384e2ce1d9440186cf3332368291cd884a6e3ae8946Nate Begeman 1385d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman// ShuffleVectorExpr 1386d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_begin() { 13875549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]; 1388d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1389d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanStmt::child_iterator ShuffleVectorExpr::child_end() { 13905549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+NumExprs; 1391d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 1392d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 13937c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson// VAArgExpr 13945549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_begin() { return &Val; } 13955549976193e34417d4474a5f4a514268ef6666c7Ted KremenekStmt::child_iterator VAArgExpr::child_end() { return &Val+1; } 13967c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 139766b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson// InitListExpr 139866b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_begin() { 13995549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] : 0; 140066b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 140166b5a8a39088598c01a9fa6f032dc908612dc8ecAnders CarlssonStmt::child_iterator InitListExpr::child_end() { 14025549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0; 140366b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson} 140466b5a8a39088598c01a9fa6f032dc908612dc8ecAnders Carlsson 14051237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCStringLiteral 14069ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_begin() { 14079ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14089ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 14099ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCStringLiteral::child_end() { 14109ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14119ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 14121237c673c07f9d827129ba02720108816abde562Ted Kremenek 14131237c673c07f9d827129ba02720108816abde562Ted Kremenek// ObjCEncodeExpr 14149ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); } 14159ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); } 14161237c673c07f9d827129ba02720108816abde562Ted Kremenek 1417b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian// ObjCSelectorExpr 14189ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_begin() { 14199ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14209ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 14219ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCSelectorExpr::child_end() { 14229ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14239ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1424b62f6813406a03bf8a371c4e46c9fad51d102121Fariborz Jahanian 1425390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian// ObjCProtocolExpr 14269ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_begin() { 14279ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14289ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 14299ac5928abeb3a47592201e1c30fe2930c20a507eTed KremenekStmt::child_iterator ObjCProtocolExpr::child_end() { 14309ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek return child_iterator(); 14319ac5928abeb3a47592201e1c30fe2930c20a507eTed Kremenek} 1432390d50a725497e99247dc104a7d2c2a255d3af14Fariborz Jahanian 1433563477da25f824e37c535131695dc4dc9b68c465Steve Naroff// ObjCMessageExpr 1434ea958e57a370b641c5a69347b75e9f8e3b5a41a2Ted KremenekStmt::child_iterator ObjCMessageExpr::child_begin() { 14355549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START; 1436563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1437563477da25f824e37c535131695dc4dc9b68c465Steve NaroffStmt::child_iterator ObjCMessageExpr::child_end() { 14385549976193e34417d4474a5f4a514268ef6666c7Ted Kremenek return &SubExprs[0]+ARGS_START+getNumArgs(); 1439563477da25f824e37c535131695dc4dc9b68c465Steve Naroff} 1440563477da25f824e37c535131695dc4dc9b68c465Steve Naroff 1441