blob: f93ce72d254d6e545674a65124b8c173037d3db6 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Expr.cpp - Expression AST Node Implementation --------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Expr class and subclasses.
11//
12//===----------------------------------------------------------------------===//
13
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000014#include "clang/AST/Expr.h"
Douglas Gregor0979c802009-08-31 21:41:48 +000015#include "clang/AST/ExprCXX.h"
Chris Lattnera4d55d82008-10-06 06:40:35 +000016#include "clang/AST/APValue.h"
Chris Lattner2eadfb62007-07-15 23:32:58 +000017#include "clang/AST/ASTContext.h"
Chris Lattnera4d55d82008-10-06 06:40:35 +000018#include "clang/AST/DeclObjC.h"
Douglas Gregor98cd5992008-10-21 23:43:52 +000019#include "clang/AST/DeclCXX.h"
Douglas Gregoraaba5e32009-02-04 19:02:06 +000020#include "clang/AST/DeclTemplate.h"
Anders Carlsson19cc4ab2009-07-18 19:43:29 +000021#include "clang/AST/RecordLayout.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000022#include "clang/AST/StmtVisitor.h"
Chris Lattner08f92e32010-11-17 07:37:15 +000023#include "clang/Lex/LiteralSupport.h"
24#include "clang/Lex/Lexer.h"
Richard Smith7a614d82011-06-11 17:19:42 +000025#include "clang/Sema/SemaDiagnostic.h"
Chris Lattner1b63e4f2009-06-14 01:54:56 +000026#include "clang/Basic/Builtins.h"
Chris Lattner08f92e32010-11-17 07:37:15 +000027#include "clang/Basic/SourceManager.h"
Chris Lattnerda5a6b62007-11-27 18:22:04 +000028#include "clang/Basic/TargetInfo.h"
Douglas Gregorcf3293e2009-11-01 20:32:48 +000029#include "llvm/Support/ErrorHandling.h"
Anders Carlsson3a082d82009-09-08 18:24:21 +000030#include "llvm/Support/raw_ostream.h"
Douglas Gregorffb4b6e2009-04-15 06:41:24 +000031#include <algorithm>
Reid Spencer5f016e22007-07-11 17:01:13 +000032using namespace clang;
33
Chris Lattner2b334bb2010-04-16 23:34:13 +000034/// isKnownToHaveBooleanValue - Return true if this is an integer expression
35/// that is known to return 0 or 1. This happens for _Bool/bool expressions
36/// but also int expressions which are produced by things like comparisons in
37/// C.
38bool Expr::isKnownToHaveBooleanValue() const {
Peter Collingbournef111d932011-04-15 00:35:48 +000039 const Expr *E = IgnoreParens();
40
Chris Lattner2b334bb2010-04-16 23:34:13 +000041 // If this value has _Bool type, it is obvious 0/1.
Peter Collingbournef111d932011-04-15 00:35:48 +000042 if (E->getType()->isBooleanType()) return true;
Sean Huntc3021132010-05-05 15:23:54 +000043 // If this is a non-scalar-integer type, we don't care enough to try.
Peter Collingbournef111d932011-04-15 00:35:48 +000044 if (!E->getType()->isIntegralOrEnumerationType()) return false;
Sean Huntc3021132010-05-05 15:23:54 +000045
Peter Collingbournef111d932011-04-15 00:35:48 +000046 if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
Chris Lattner2b334bb2010-04-16 23:34:13 +000047 switch (UO->getOpcode()) {
John McCall2de56d12010-08-25 11:45:40 +000048 case UO_Plus:
Chris Lattner2b334bb2010-04-16 23:34:13 +000049 return UO->getSubExpr()->isKnownToHaveBooleanValue();
50 default:
51 return false;
52 }
53 }
Sean Huntc3021132010-05-05 15:23:54 +000054
John McCall6907fbe2010-06-12 01:56:02 +000055 // Only look through implicit casts. If the user writes
56 // '(int) (a && b)' treat it as an arbitrary int.
Peter Collingbournef111d932011-04-15 00:35:48 +000057 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
Chris Lattner2b334bb2010-04-16 23:34:13 +000058 return CE->getSubExpr()->isKnownToHaveBooleanValue();
Sean Huntc3021132010-05-05 15:23:54 +000059
Peter Collingbournef111d932011-04-15 00:35:48 +000060 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
Chris Lattner2b334bb2010-04-16 23:34:13 +000061 switch (BO->getOpcode()) {
62 default: return false;
John McCall2de56d12010-08-25 11:45:40 +000063 case BO_LT: // Relational operators.
64 case BO_GT:
65 case BO_LE:
66 case BO_GE:
67 case BO_EQ: // Equality operators.
68 case BO_NE:
69 case BO_LAnd: // AND operator.
70 case BO_LOr: // Logical OR operator.
Chris Lattner2b334bb2010-04-16 23:34:13 +000071 return true;
Sean Huntc3021132010-05-05 15:23:54 +000072
John McCall2de56d12010-08-25 11:45:40 +000073 case BO_And: // Bitwise AND operator.
74 case BO_Xor: // Bitwise XOR operator.
75 case BO_Or: // Bitwise OR operator.
Chris Lattner2b334bb2010-04-16 23:34:13 +000076 // Handle things like (x==2)|(y==12).
77 return BO->getLHS()->isKnownToHaveBooleanValue() &&
78 BO->getRHS()->isKnownToHaveBooleanValue();
Sean Huntc3021132010-05-05 15:23:54 +000079
John McCall2de56d12010-08-25 11:45:40 +000080 case BO_Comma:
81 case BO_Assign:
Chris Lattner2b334bb2010-04-16 23:34:13 +000082 return BO->getRHS()->isKnownToHaveBooleanValue();
83 }
84 }
Sean Huntc3021132010-05-05 15:23:54 +000085
Peter Collingbournef111d932011-04-15 00:35:48 +000086 if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
Chris Lattner2b334bb2010-04-16 23:34:13 +000087 return CO->getTrueExpr()->isKnownToHaveBooleanValue() &&
88 CO->getFalseExpr()->isKnownToHaveBooleanValue();
Sean Huntc3021132010-05-05 15:23:54 +000089
Chris Lattner2b334bb2010-04-16 23:34:13 +000090 return false;
91}
92
John McCall63c00d72011-02-09 08:16:59 +000093// Amusing macro metaprogramming hack: check whether a class provides
94// a more specific implementation of getExprLoc().
95namespace {
96 /// This implementation is used when a class provides a custom
97 /// implementation of getExprLoc.
98 template <class E, class T>
99 SourceLocation getExprLocImpl(const Expr *expr,
100 SourceLocation (T::*v)() const) {
101 return static_cast<const E*>(expr)->getExprLoc();
102 }
103
104 /// This implementation is used when a class doesn't provide
105 /// a custom implementation of getExprLoc. Overload resolution
106 /// should pick it over the implementation above because it's
107 /// more specialized according to function template partial ordering.
108 template <class E>
109 SourceLocation getExprLocImpl(const Expr *expr,
110 SourceLocation (Expr::*v)() const) {
111 return static_cast<const E*>(expr)->getSourceRange().getBegin();
112 }
113}
114
115SourceLocation Expr::getExprLoc() const {
116 switch (getStmtClass()) {
117 case Stmt::NoStmtClass: llvm_unreachable("statement without class");
118#define ABSTRACT_STMT(type)
119#define STMT(type, base) \
120 case Stmt::type##Class: llvm_unreachable(#type " is not an Expr"); break;
121#define EXPR(type, base) \
122 case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc);
123#include "clang/AST/StmtNodes.inc"
124 }
125 llvm_unreachable("unknown statement kind");
126 return SourceLocation();
127}
128
Reid Spencer5f016e22007-07-11 17:01:13 +0000129//===----------------------------------------------------------------------===//
130// Primary Expressions.
131//===----------------------------------------------------------------------===//
132
Douglas Gregor561f8122011-07-01 01:22:09 +0000133/// \brief Compute the type-, value-, and instantiation-dependence of a
134/// declaration reference
Douglas Gregord967e312011-01-19 21:52:31 +0000135/// based on the declaration being referenced.
136static void computeDeclRefDependence(NamedDecl *D, QualType T,
137 bool &TypeDependent,
Douglas Gregor561f8122011-07-01 01:22:09 +0000138 bool &ValueDependent,
139 bool &InstantiationDependent) {
Douglas Gregord967e312011-01-19 21:52:31 +0000140 TypeDependent = false;
141 ValueDependent = false;
Douglas Gregor561f8122011-07-01 01:22:09 +0000142 InstantiationDependent = false;
Douglas Gregor0da76df2009-11-23 11:41:28 +0000143
144 // (TD) C++ [temp.dep.expr]p3:
145 // An id-expression is type-dependent if it contains:
146 //
Sean Huntc3021132010-05-05 15:23:54 +0000147 // and
Douglas Gregor0da76df2009-11-23 11:41:28 +0000148 //
149 // (VD) C++ [temp.dep.constexpr]p2:
150 // An identifier is value-dependent if it is:
Douglas Gregord967e312011-01-19 21:52:31 +0000151
Douglas Gregor0da76df2009-11-23 11:41:28 +0000152 // (TD) - an identifier that was declared with dependent type
153 // (VD) - a name declared with a dependent type,
Douglas Gregord967e312011-01-19 21:52:31 +0000154 if (T->isDependentType()) {
155 TypeDependent = true;
156 ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +0000157 InstantiationDependent = true;
Douglas Gregord967e312011-01-19 21:52:31 +0000158 return;
Douglas Gregor561f8122011-07-01 01:22:09 +0000159 } else if (T->isInstantiationDependentType()) {
160 InstantiationDependent = true;
Douglas Gregor0da76df2009-11-23 11:41:28 +0000161 }
Douglas Gregord967e312011-01-19 21:52:31 +0000162
Douglas Gregor0da76df2009-11-23 11:41:28 +0000163 // (TD) - a conversion-function-id that specifies a dependent type
Douglas Gregord967e312011-01-19 21:52:31 +0000164 if (D->getDeclName().getNameKind()
Douglas Gregor561f8122011-07-01 01:22:09 +0000165 == DeclarationName::CXXConversionFunctionName) {
166 QualType T = D->getDeclName().getCXXNameType();
167 if (T->isDependentType()) {
168 TypeDependent = true;
169 ValueDependent = true;
170 InstantiationDependent = true;
171 return;
172 }
173
174 if (T->isInstantiationDependentType())
175 InstantiationDependent = true;
Douglas Gregor0da76df2009-11-23 11:41:28 +0000176 }
Douglas Gregor561f8122011-07-01 01:22:09 +0000177
Douglas Gregor0da76df2009-11-23 11:41:28 +0000178 // (VD) - the name of a non-type template parameter,
Douglas Gregord967e312011-01-19 21:52:31 +0000179 if (isa<NonTypeTemplateParmDecl>(D)) {
180 ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +0000181 InstantiationDependent = true;
Douglas Gregord967e312011-01-19 21:52:31 +0000182 return;
183 }
184
Douglas Gregor0da76df2009-11-23 11:41:28 +0000185 // (VD) - a constant with integral or enumeration type and is
186 // initialized with an expression that is value-dependent.
Douglas Gregord967e312011-01-19 21:52:31 +0000187 if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
Douglas Gregor2ade35e2010-06-16 00:17:44 +0000188 if (Var->getType()->isIntegralOrEnumerationType() &&
Douglas Gregor501edb62010-01-15 16:21:02 +0000189 Var->getType().getCVRQualifiers() == Qualifiers::Const) {
Sebastian Redl31310a22010-02-01 20:16:42 +0000190 if (const Expr *Init = Var->getAnyInitializer())
Douglas Gregor561f8122011-07-01 01:22:09 +0000191 if (Init->isValueDependent()) {
Douglas Gregord967e312011-01-19 21:52:31 +0000192 ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +0000193 InstantiationDependent = true;
194 }
Douglas Gregorbb6e73f2010-05-11 08:41:30 +0000195 }
Douglas Gregord967e312011-01-19 21:52:31 +0000196
Douglas Gregorbb6e73f2010-05-11 08:41:30 +0000197 // (VD) - FIXME: Missing from the standard:
198 // - a member function or a static data member of the current
199 // instantiation
200 else if (Var->isStaticDataMember() &&
Douglas Gregor561f8122011-07-01 01:22:09 +0000201 Var->getDeclContext()->isDependentContext()) {
Douglas Gregord967e312011-01-19 21:52:31 +0000202 ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +0000203 InstantiationDependent = true;
204 }
Douglas Gregord967e312011-01-19 21:52:31 +0000205
206 return;
207 }
208
Douglas Gregorbb6e73f2010-05-11 08:41:30 +0000209 // (VD) - FIXME: Missing from the standard:
210 // - a member function or a static data member of the current
211 // instantiation
Douglas Gregord967e312011-01-19 21:52:31 +0000212 if (isa<CXXMethodDecl>(D) && D->getDeclContext()->isDependentContext()) {
213 ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +0000214 InstantiationDependent = true;
Douglas Gregord967e312011-01-19 21:52:31 +0000215 return;
216 }
217}
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000218
Douglas Gregord967e312011-01-19 21:52:31 +0000219void DeclRefExpr::computeDependence() {
220 bool TypeDependent = false;
221 bool ValueDependent = false;
Douglas Gregor561f8122011-07-01 01:22:09 +0000222 bool InstantiationDependent = false;
223 computeDeclRefDependence(getDecl(), getType(), TypeDependent, ValueDependent,
224 InstantiationDependent);
Douglas Gregord967e312011-01-19 21:52:31 +0000225
226 // (TD) C++ [temp.dep.expr]p3:
227 // An id-expression is type-dependent if it contains:
228 //
229 // and
230 //
231 // (VD) C++ [temp.dep.constexpr]p2:
232 // An identifier is value-dependent if it is:
233 if (!TypeDependent && !ValueDependent &&
234 hasExplicitTemplateArgs() &&
235 TemplateSpecializationType::anyDependentTemplateArguments(
236 getTemplateArgs(),
Douglas Gregor561f8122011-07-01 01:22:09 +0000237 getNumTemplateArgs(),
238 InstantiationDependent)) {
Douglas Gregord967e312011-01-19 21:52:31 +0000239 TypeDependent = true;
240 ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +0000241 InstantiationDependent = true;
Douglas Gregord967e312011-01-19 21:52:31 +0000242 }
243
244 ExprBits.TypeDependent = TypeDependent;
245 ExprBits.ValueDependent = ValueDependent;
Douglas Gregor561f8122011-07-01 01:22:09 +0000246 ExprBits.InstantiationDependent = InstantiationDependent;
Douglas Gregord967e312011-01-19 21:52:31 +0000247
Douglas Gregor10738d32010-12-23 23:51:58 +0000248 // Is the declaration a parameter pack?
Douglas Gregord967e312011-01-19 21:52:31 +0000249 if (getDecl()->isParameterPack())
Douglas Gregor1fe85ea2011-01-05 21:11:38 +0000250 ExprBits.ContainsUnexpandedParameterPack = true;
Douglas Gregor0da76df2009-11-23 11:41:28 +0000251}
252
Chandler Carruth3aa81402011-05-01 23:48:14 +0000253DeclRefExpr::DeclRefExpr(NestedNameSpecifierLoc QualifierLoc,
Abramo Bagnara25777432010-08-11 22:01:17 +0000254 ValueDecl *D, const DeclarationNameInfo &NameInfo,
Chandler Carruth3aa81402011-05-01 23:48:14 +0000255 NamedDecl *FoundD,
Abramo Bagnara25777432010-08-11 22:01:17 +0000256 const TemplateArgumentListInfo *TemplateArgs,
John McCallf89e55a2010-11-18 06:31:45 +0000257 QualType T, ExprValueKind VK)
Douglas Gregor561f8122011-07-01 01:22:09 +0000258 : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false),
Chandler Carruthcb66cff2011-05-01 21:29:53 +0000259 D(D), Loc(NameInfo.getLoc()), DNLoc(NameInfo.getInfo()) {
260 DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0;
Chandler Carruth7e740bd2011-05-01 21:55:21 +0000261 if (QualifierLoc)
Chandler Carruth6857c3e2011-05-01 22:14:37 +0000262 getInternalQualifierLoc() = QualifierLoc;
Chandler Carruth3aa81402011-05-01 23:48:14 +0000263 DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0;
264 if (FoundD)
265 getInternalFoundDecl() = FoundD;
Chandler Carruthcb66cff2011-05-01 21:29:53 +0000266 DeclRefExprBits.HasExplicitTemplateArgs = TemplateArgs ? 1 : 0;
Douglas Gregor561f8122011-07-01 01:22:09 +0000267 if (TemplateArgs) {
268 bool Dependent = false;
269 bool InstantiationDependent = false;
270 bool ContainsUnexpandedParameterPack = false;
271 getExplicitTemplateArgs().initializeFrom(*TemplateArgs, Dependent,
272 InstantiationDependent,
273 ContainsUnexpandedParameterPack);
274 if (InstantiationDependent)
275 setInstantiationDependent(true);
276 }
277
Abramo Bagnara25777432010-08-11 22:01:17 +0000278 computeDependence();
279}
280
Douglas Gregora2813ce2009-10-23 18:54:35 +0000281DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
Douglas Gregor40d96a62011-02-28 21:54:11 +0000282 NestedNameSpecifierLoc QualifierLoc,
John McCalldbd872f2009-12-08 09:08:17 +0000283 ValueDecl *D,
Douglas Gregora2813ce2009-10-23 18:54:35 +0000284 SourceLocation NameLoc,
Douglas Gregor0da76df2009-11-23 11:41:28 +0000285 QualType T,
John McCallf89e55a2010-11-18 06:31:45 +0000286 ExprValueKind VK,
Chandler Carruth3aa81402011-05-01 23:48:14 +0000287 NamedDecl *FoundD,
Douglas Gregor0da76df2009-11-23 11:41:28 +0000288 const TemplateArgumentListInfo *TemplateArgs) {
Douglas Gregor40d96a62011-02-28 21:54:11 +0000289 return Create(Context, QualifierLoc, D,
Abramo Bagnara25777432010-08-11 22:01:17 +0000290 DeclarationNameInfo(D->getDeclName(), NameLoc),
Chandler Carruth3aa81402011-05-01 23:48:14 +0000291 T, VK, FoundD, TemplateArgs);
Abramo Bagnara25777432010-08-11 22:01:17 +0000292}
293
294DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
Douglas Gregor40d96a62011-02-28 21:54:11 +0000295 NestedNameSpecifierLoc QualifierLoc,
Abramo Bagnara25777432010-08-11 22:01:17 +0000296 ValueDecl *D,
297 const DeclarationNameInfo &NameInfo,
298 QualType T,
John McCallf89e55a2010-11-18 06:31:45 +0000299 ExprValueKind VK,
Chandler Carruth3aa81402011-05-01 23:48:14 +0000300 NamedDecl *FoundD,
Abramo Bagnara25777432010-08-11 22:01:17 +0000301 const TemplateArgumentListInfo *TemplateArgs) {
Chandler Carruth3aa81402011-05-01 23:48:14 +0000302 // Filter out cases where the found Decl is the same as the value refenenced.
303 if (D == FoundD)
304 FoundD = 0;
305
Douglas Gregora2813ce2009-10-23 18:54:35 +0000306 std::size_t Size = sizeof(DeclRefExpr);
Douglas Gregor40d96a62011-02-28 21:54:11 +0000307 if (QualifierLoc != 0)
Chandler Carruth6857c3e2011-05-01 22:14:37 +0000308 Size += sizeof(NestedNameSpecifierLoc);
Chandler Carruth3aa81402011-05-01 23:48:14 +0000309 if (FoundD)
310 Size += sizeof(NamedDecl *);
John McCalld5532b62009-11-23 01:53:49 +0000311 if (TemplateArgs)
Argyrios Kyrtzidisb0c3e092011-09-22 20:07:03 +0000312 Size += ASTTemplateArgumentListInfo::sizeFor(*TemplateArgs);
Chandler Carruth3aa81402011-05-01 23:48:14 +0000313
Chris Lattner32488542010-10-30 05:14:06 +0000314 void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
Chandler Carruth3aa81402011-05-01 23:48:14 +0000315 return new (Mem) DeclRefExpr(QualifierLoc, D, NameInfo, FoundD, TemplateArgs,
316 T, VK);
Douglas Gregora2813ce2009-10-23 18:54:35 +0000317}
318
Chandler Carruth3aa81402011-05-01 23:48:14 +0000319DeclRefExpr *DeclRefExpr::CreateEmpty(ASTContext &Context,
Douglas Gregordef03542011-02-04 12:01:24 +0000320 bool HasQualifier,
Chandler Carruth3aa81402011-05-01 23:48:14 +0000321 bool HasFoundDecl,
Douglas Gregordef03542011-02-04 12:01:24 +0000322 bool HasExplicitTemplateArgs,
Argyrios Kyrtzidis663e3802010-07-08 13:09:47 +0000323 unsigned NumTemplateArgs) {
324 std::size_t Size = sizeof(DeclRefExpr);
325 if (HasQualifier)
Chandler Carruth6857c3e2011-05-01 22:14:37 +0000326 Size += sizeof(NestedNameSpecifierLoc);
Chandler Carruth3aa81402011-05-01 23:48:14 +0000327 if (HasFoundDecl)
328 Size += sizeof(NamedDecl *);
Douglas Gregordef03542011-02-04 12:01:24 +0000329 if (HasExplicitTemplateArgs)
Argyrios Kyrtzidisb0c3e092011-09-22 20:07:03 +0000330 Size += ASTTemplateArgumentListInfo::sizeFor(NumTemplateArgs);
Chandler Carruth3aa81402011-05-01 23:48:14 +0000331
Chris Lattner32488542010-10-30 05:14:06 +0000332 void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
Argyrios Kyrtzidis663e3802010-07-08 13:09:47 +0000333 return new (Mem) DeclRefExpr(EmptyShell());
334}
335
Douglas Gregora2813ce2009-10-23 18:54:35 +0000336SourceRange DeclRefExpr::getSourceRange() const {
Abramo Bagnara25777432010-08-11 22:01:17 +0000337 SourceRange R = getNameInfo().getSourceRange();
Douglas Gregora2813ce2009-10-23 18:54:35 +0000338 if (hasQualifier())
Douglas Gregor40d96a62011-02-28 21:54:11 +0000339 R.setBegin(getQualifierLoc().getBeginLoc());
John McCall096832c2010-08-19 23:49:38 +0000340 if (hasExplicitTemplateArgs())
Douglas Gregora2813ce2009-10-23 18:54:35 +0000341 R.setEnd(getRAngleLoc());
342 return R;
343}
344
Anders Carlsson3a082d82009-09-08 18:24:21 +0000345// FIXME: Maybe this should use DeclPrinter with a special "print predefined
346// expr" policy instead.
Anders Carlsson848fa642010-02-11 18:20:28 +0000347std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) {
348 ASTContext &Context = CurrentDecl->getASTContext();
349
Anders Carlsson3a082d82009-09-08 18:24:21 +0000350 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
Anders Carlsson848fa642010-02-11 18:20:28 +0000351 if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual)
Anders Carlsson3a082d82009-09-08 18:24:21 +0000352 return FD->getNameAsString();
353
354 llvm::SmallString<256> Name;
355 llvm::raw_svector_ostream Out(Name);
356
357 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
Anders Carlsson848fa642010-02-11 18:20:28 +0000358 if (MD->isVirtual() && IT != PrettyFunctionNoVirtual)
Anders Carlsson3a082d82009-09-08 18:24:21 +0000359 Out << "virtual ";
Sam Weinig4eadcc52009-12-27 01:38:20 +0000360 if (MD->isStatic())
361 Out << "static ";
Anders Carlsson3a082d82009-09-08 18:24:21 +0000362 }
363
364 PrintingPolicy Policy(Context.getLangOptions());
Anders Carlsson3a082d82009-09-08 18:24:21 +0000365
366 std::string Proto = FD->getQualifiedNameAsString(Policy);
367
John McCall183700f2009-09-21 23:43:11 +0000368 const FunctionType *AFT = FD->getType()->getAs<FunctionType>();
Anders Carlsson3a082d82009-09-08 18:24:21 +0000369 const FunctionProtoType *FT = 0;
370 if (FD->hasWrittenPrototype())
371 FT = dyn_cast<FunctionProtoType>(AFT);
372
373 Proto += "(";
374 if (FT) {
375 llvm::raw_string_ostream POut(Proto);
376 for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
377 if (i) POut << ", ";
378 std::string Param;
379 FD->getParamDecl(i)->getType().getAsStringInternal(Param, Policy);
380 POut << Param;
381 }
382
383 if (FT->isVariadic()) {
384 if (FD->getNumParams()) POut << ", ";
385 POut << "...";
386 }
387 }
388 Proto += ")";
389
Sam Weinig4eadcc52009-12-27 01:38:20 +0000390 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
391 Qualifiers ThisQuals = Qualifiers::fromCVRMask(MD->getTypeQualifiers());
392 if (ThisQuals.hasConst())
393 Proto += " const";
394 if (ThisQuals.hasVolatile())
395 Proto += " volatile";
396 }
397
Sam Weinig3a1ce1e2009-12-06 23:55:13 +0000398 if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
399 AFT->getResultType().getAsStringInternal(Proto, Policy);
Anders Carlsson3a082d82009-09-08 18:24:21 +0000400
401 Out << Proto;
402
403 Out.flush();
404 return Name.str().str();
405 }
406 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
407 llvm::SmallString<256> Name;
408 llvm::raw_svector_ostream Out(Name);
409 Out << (MD->isInstanceMethod() ? '-' : '+');
410 Out << '[';
Ted Kremenekb03d33e2010-03-18 21:23:08 +0000411
412 // For incorrect code, there might not be an ObjCInterfaceDecl. Do
413 // a null check to avoid a crash.
414 if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
Benjamin Kramer900fc632010-04-17 09:33:03 +0000415 Out << ID;
Ted Kremenekb03d33e2010-03-18 21:23:08 +0000416
Anders Carlsson3a082d82009-09-08 18:24:21 +0000417 if (const ObjCCategoryImplDecl *CID =
Benjamin Kramer900fc632010-04-17 09:33:03 +0000418 dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
419 Out << '(' << CID << ')';
420
Anders Carlsson3a082d82009-09-08 18:24:21 +0000421 Out << ' ';
422 Out << MD->getSelector().getAsString();
423 Out << ']';
424
425 Out.flush();
426 return Name.str().str();
427 }
428 if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) {
429 // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
430 return "top level";
431 }
432 return "";
433}
434
Argyrios Kyrtzidis9996a7f2010-08-28 09:06:06 +0000435void APNumericStorage::setIntValue(ASTContext &C, const llvm::APInt &Val) {
436 if (hasAllocation())
437 C.Deallocate(pVal);
438
439 BitWidth = Val.getBitWidth();
440 unsigned NumWords = Val.getNumWords();
441 const uint64_t* Words = Val.getRawData();
442 if (NumWords > 1) {
443 pVal = new (C) uint64_t[NumWords];
444 std::copy(Words, Words + NumWords, pVal);
445 } else if (NumWords == 1)
446 VAL = Words[0];
447 else
448 VAL = 0;
449}
450
451IntegerLiteral *
452IntegerLiteral::Create(ASTContext &C, const llvm::APInt &V,
453 QualType type, SourceLocation l) {
454 return new (C) IntegerLiteral(C, V, type, l);
455}
456
457IntegerLiteral *
458IntegerLiteral::Create(ASTContext &C, EmptyShell Empty) {
459 return new (C) IntegerLiteral(Empty);
460}
461
462FloatingLiteral *
463FloatingLiteral::Create(ASTContext &C, const llvm::APFloat &V,
464 bool isexact, QualType Type, SourceLocation L) {
465 return new (C) FloatingLiteral(C, V, isexact, Type, L);
466}
467
468FloatingLiteral *
469FloatingLiteral::Create(ASTContext &C, EmptyShell Empty) {
470 return new (C) FloatingLiteral(Empty);
471}
472
Chris Lattnerda8249e2008-06-07 22:13:43 +0000473/// getValueAsApproximateDouble - This returns the value as an inaccurate
474/// double. Note that this may cause loss of precision, but is useful for
475/// debugging dumps, etc.
476double FloatingLiteral::getValueAsApproximateDouble() const {
477 llvm::APFloat V = getValue();
Dale Johannesenee5a7002008-10-09 23:02:32 +0000478 bool ignored;
479 V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
480 &ignored);
Chris Lattnerda8249e2008-06-07 22:13:43 +0000481 return V.convertToDouble();
482}
483
Chris Lattner5f9e2722011-07-23 10:55:15 +0000484StringLiteral *StringLiteral::Create(ASTContext &C, StringRef Str,
Douglas Gregor5cee1192011-07-27 05:40:30 +0000485 StringKind Kind, bool Pascal, QualType Ty,
Mike Stump1eb44332009-09-09 15:08:12 +0000486 const SourceLocation *Loc,
Anders Carlssona135fb42009-03-15 18:34:13 +0000487 unsigned NumStrs) {
Chris Lattner2085fd62009-02-18 06:40:38 +0000488 // Allocate enough space for the StringLiteral plus an array of locations for
489 // any concatenated string tokens.
490 void *Mem = C.Allocate(sizeof(StringLiteral)+
491 sizeof(SourceLocation)*(NumStrs-1),
Chris Lattner32488542010-10-30 05:14:06 +0000492 llvm::alignOf<StringLiteral>());
Chris Lattner2085fd62009-02-18 06:40:38 +0000493 StringLiteral *SL = new (Mem) StringLiteral(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000494
Reid Spencer5f016e22007-07-11 17:01:13 +0000495 // OPTIMIZE: could allocate this appended to the StringLiteral.
Jay Foad65aa6882011-06-21 15:13:30 +0000496 char *AStrData = new (C, 1) char[Str.size()];
497 memcpy(AStrData, Str.data(), Str.size());
Chris Lattner2085fd62009-02-18 06:40:38 +0000498 SL->StrData = AStrData;
Jay Foad65aa6882011-06-21 15:13:30 +0000499 SL->ByteLength = Str.size();
Douglas Gregor5cee1192011-07-27 05:40:30 +0000500 SL->Kind = Kind;
Anders Carlsson3e2193c2011-04-14 00:40:03 +0000501 SL->IsPascal = Pascal;
Chris Lattner2085fd62009-02-18 06:40:38 +0000502 SL->TokLocs[0] = Loc[0];
503 SL->NumConcatenated = NumStrs;
Reid Spencer5f016e22007-07-11 17:01:13 +0000504
Chris Lattner726e1682009-02-18 05:49:11 +0000505 if (NumStrs != 1)
Chris Lattner2085fd62009-02-18 06:40:38 +0000506 memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1));
507 return SL;
Chris Lattner726e1682009-02-18 05:49:11 +0000508}
509
Douglas Gregor673ecd62009-04-15 16:35:07 +0000510StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) {
511 void *Mem = C.Allocate(sizeof(StringLiteral)+
512 sizeof(SourceLocation)*(NumStrs-1),
Chris Lattner32488542010-10-30 05:14:06 +0000513 llvm::alignOf<StringLiteral>());
Douglas Gregor673ecd62009-04-15 16:35:07 +0000514 StringLiteral *SL = new (Mem) StringLiteral(QualType());
515 SL->StrData = 0;
516 SL->ByteLength = 0;
517 SL->NumConcatenated = NumStrs;
518 return SL;
519}
520
Chris Lattner5f9e2722011-07-23 10:55:15 +0000521void StringLiteral::setString(ASTContext &C, StringRef Str) {
Daniel Dunbarb6480232009-09-22 03:27:33 +0000522 char *AStrData = new (C, 1) char[Str.size()];
523 memcpy(AStrData, Str.data(), Str.size());
Douglas Gregor673ecd62009-04-15 16:35:07 +0000524 StrData = AStrData;
Daniel Dunbarb6480232009-09-22 03:27:33 +0000525 ByteLength = Str.size();
Douglas Gregor673ecd62009-04-15 16:35:07 +0000526}
527
Chris Lattner08f92e32010-11-17 07:37:15 +0000528/// getLocationOfByte - Return a source location that points to the specified
529/// byte of this string literal.
530///
531/// Strings are amazingly complex. They can be formed from multiple tokens and
532/// can have escape sequences in them in addition to the usual trigraph and
533/// escaped newline business. This routine handles this complexity.
534///
535SourceLocation StringLiteral::
536getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
537 const LangOptions &Features, const TargetInfo &Target) const {
Douglas Gregor5cee1192011-07-27 05:40:30 +0000538 assert(Kind == StringLiteral::Ascii && "This only works for ASCII strings");
539
Chris Lattner08f92e32010-11-17 07:37:15 +0000540 // Loop over all of the tokens in this string until we find the one that
541 // contains the byte we're looking for.
542 unsigned TokNo = 0;
543 while (1) {
544 assert(TokNo < getNumConcatenated() && "Invalid byte number!");
545 SourceLocation StrTokLoc = getStrTokenLoc(TokNo);
546
547 // Get the spelling of the string so that we can get the data that makes up
548 // the string literal, not the identifier for the macro it is potentially
549 // expanded through.
550 SourceLocation StrTokSpellingLoc = SM.getSpellingLoc(StrTokLoc);
551
552 // Re-lex the token to get its length and original spelling.
553 std::pair<FileID, unsigned> LocInfo =SM.getDecomposedLoc(StrTokSpellingLoc);
554 bool Invalid = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000555 StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid);
Chris Lattner08f92e32010-11-17 07:37:15 +0000556 if (Invalid)
557 return StrTokSpellingLoc;
558
559 const char *StrData = Buffer.data()+LocInfo.second;
560
561 // Create a langops struct and enable trigraphs. This is sufficient for
562 // relexing tokens.
563 LangOptions LangOpts;
564 LangOpts.Trigraphs = true;
565
566 // Create a lexer starting at the beginning of this token.
567 Lexer TheLexer(StrTokSpellingLoc, Features, Buffer.begin(), StrData,
568 Buffer.end());
569 Token TheTok;
570 TheLexer.LexFromRawLexer(TheTok);
571
572 // Use the StringLiteralParser to compute the length of the string in bytes.
573 StringLiteralParser SLP(&TheTok, 1, SM, Features, Target);
574 unsigned TokNumBytes = SLP.GetStringLength();
575
576 // If the byte is in this token, return the location of the byte.
577 if (ByteNo < TokNumBytes ||
Hans Wennborg935a70c2011-06-30 20:17:41 +0000578 (ByteNo == TokNumBytes && TokNo == getNumConcatenated() - 1)) {
Chris Lattner08f92e32010-11-17 07:37:15 +0000579 unsigned Offset = SLP.getOffsetOfStringByte(TheTok, ByteNo);
580
581 // Now that we know the offset of the token in the spelling, use the
582 // preprocessor to get the offset in the original source.
583 return Lexer::AdvanceToTokenCharacter(StrTokLoc, Offset, SM, Features);
584 }
585
586 // Move to the next string token.
587 ++TokNo;
588 ByteNo -= TokNumBytes;
589 }
590}
591
592
593
Reid Spencer5f016e22007-07-11 17:01:13 +0000594/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
595/// corresponds to, e.g. "sizeof" or "[pre]++".
596const char *UnaryOperator::getOpcodeStr(Opcode Op) {
597 switch (Op) {
David Blaikieb219cfc2011-09-23 05:06:16 +0000598 default: llvm_unreachable("Unknown unary operator");
John McCall2de56d12010-08-25 11:45:40 +0000599 case UO_PostInc: return "++";
600 case UO_PostDec: return "--";
601 case UO_PreInc: return "++";
602 case UO_PreDec: return "--";
603 case UO_AddrOf: return "&";
604 case UO_Deref: return "*";
605 case UO_Plus: return "+";
606 case UO_Minus: return "-";
607 case UO_Not: return "~";
608 case UO_LNot: return "!";
609 case UO_Real: return "__real";
610 case UO_Imag: return "__imag";
611 case UO_Extension: return "__extension__";
Reid Spencer5f016e22007-07-11 17:01:13 +0000612 }
613}
614
John McCall2de56d12010-08-25 11:45:40 +0000615UnaryOperatorKind
Douglas Gregorbc736fc2009-03-13 23:49:33 +0000616UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) {
617 switch (OO) {
David Blaikieb219cfc2011-09-23 05:06:16 +0000618 default: llvm_unreachable("No unary operator for overloaded function");
John McCall2de56d12010-08-25 11:45:40 +0000619 case OO_PlusPlus: return Postfix ? UO_PostInc : UO_PreInc;
620 case OO_MinusMinus: return Postfix ? UO_PostDec : UO_PreDec;
621 case OO_Amp: return UO_AddrOf;
622 case OO_Star: return UO_Deref;
623 case OO_Plus: return UO_Plus;
624 case OO_Minus: return UO_Minus;
625 case OO_Tilde: return UO_Not;
626 case OO_Exclaim: return UO_LNot;
Douglas Gregorbc736fc2009-03-13 23:49:33 +0000627 }
628}
629
630OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) {
631 switch (Opc) {
John McCall2de56d12010-08-25 11:45:40 +0000632 case UO_PostInc: case UO_PreInc: return OO_PlusPlus;
633 case UO_PostDec: case UO_PreDec: return OO_MinusMinus;
634 case UO_AddrOf: return OO_Amp;
635 case UO_Deref: return OO_Star;
636 case UO_Plus: return OO_Plus;
637 case UO_Minus: return OO_Minus;
638 case UO_Not: return OO_Tilde;
639 case UO_LNot: return OO_Exclaim;
Douglas Gregorbc736fc2009-03-13 23:49:33 +0000640 default: return OO_None;
641 }
642}
643
644
Reid Spencer5f016e22007-07-11 17:01:13 +0000645//===----------------------------------------------------------------------===//
646// Postfix Operators.
647//===----------------------------------------------------------------------===//
648
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000649CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, unsigned NumPreArgs,
650 Expr **args, unsigned numargs, QualType t, ExprValueKind VK,
John McCallf89e55a2010-11-18 06:31:45 +0000651 SourceLocation rparenloc)
652 : Expr(SC, t, VK, OK_Ordinary,
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000653 fn->isTypeDependent(),
654 fn->isValueDependent(),
Douglas Gregor561f8122011-07-01 01:22:09 +0000655 fn->isInstantiationDependent(),
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000656 fn->containsUnexpandedParameterPack()),
Douglas Gregor898574e2008-12-05 23:32:09 +0000657 NumArgs(numargs) {
Mike Stump1eb44332009-09-09 15:08:12 +0000658
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000659 SubExprs = new (C) Stmt*[numargs+PREARGS_START+NumPreArgs];
Douglas Gregorb4609802008-11-14 16:09:21 +0000660 SubExprs[FN] = fn;
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000661 for (unsigned i = 0; i != numargs; ++i) {
662 if (args[i]->isTypeDependent())
663 ExprBits.TypeDependent = true;
664 if (args[i]->isValueDependent())
665 ExprBits.ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +0000666 if (args[i]->isInstantiationDependent())
667 ExprBits.InstantiationDependent = true;
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000668 if (args[i]->containsUnexpandedParameterPack())
669 ExprBits.ContainsUnexpandedParameterPack = true;
670
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000671 SubExprs[i+PREARGS_START+NumPreArgs] = args[i];
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000672 }
Ted Kremenek668bf912009-02-09 20:51:47 +0000673
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000674 CallExprBits.NumPreArgs = NumPreArgs;
Douglas Gregorb4609802008-11-14 16:09:21 +0000675 RParenLoc = rparenloc;
676}
Nate Begemane2ce1d92008-01-17 17:46:27 +0000677
Ted Kremenek668bf912009-02-09 20:51:47 +0000678CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs,
John McCallf89e55a2010-11-18 06:31:45 +0000679 QualType t, ExprValueKind VK, SourceLocation rparenloc)
680 : Expr(CallExprClass, t, VK, OK_Ordinary,
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000681 fn->isTypeDependent(),
682 fn->isValueDependent(),
Douglas Gregor561f8122011-07-01 01:22:09 +0000683 fn->isInstantiationDependent(),
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000684 fn->containsUnexpandedParameterPack()),
Douglas Gregor898574e2008-12-05 23:32:09 +0000685 NumArgs(numargs) {
Ted Kremenek668bf912009-02-09 20:51:47 +0000686
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000687 SubExprs = new (C) Stmt*[numargs+PREARGS_START];
Ted Kremenek77ed8e42007-08-24 18:13:47 +0000688 SubExprs[FN] = fn;
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000689 for (unsigned i = 0; i != numargs; ++i) {
690 if (args[i]->isTypeDependent())
691 ExprBits.TypeDependent = true;
692 if (args[i]->isValueDependent())
693 ExprBits.ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +0000694 if (args[i]->isInstantiationDependent())
695 ExprBits.InstantiationDependent = true;
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000696 if (args[i]->containsUnexpandedParameterPack())
697 ExprBits.ContainsUnexpandedParameterPack = true;
698
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000699 SubExprs[i+PREARGS_START] = args[i];
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000700 }
Ted Kremenek668bf912009-02-09 20:51:47 +0000701
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000702 CallExprBits.NumPreArgs = 0;
Reid Spencer5f016e22007-07-11 17:01:13 +0000703 RParenLoc = rparenloc;
704}
705
Mike Stump1eb44332009-09-09 15:08:12 +0000706CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty)
707 : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000708 // FIXME: Why do we allocate this?
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000709 SubExprs = new (C) Stmt*[PREARGS_START];
710 CallExprBits.NumPreArgs = 0;
711}
712
713CallExpr::CallExpr(ASTContext &C, StmtClass SC, unsigned NumPreArgs,
714 EmptyShell Empty)
715 : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
716 // FIXME: Why do we allocate this?
717 SubExprs = new (C) Stmt*[PREARGS_START+NumPreArgs];
718 CallExprBits.NumPreArgs = NumPreArgs;
Douglas Gregor1f0d0132009-04-15 17:43:59 +0000719}
720
Nuno Lopesd20254f2009-12-20 23:11:08 +0000721Decl *CallExpr::getCalleeDecl() {
John McCalle8683d62011-09-13 23:08:34 +0000722 Expr *CEE = getCallee()->IgnoreParenImpCasts();
Douglas Gregor1ddc9c42011-09-06 21:41:04 +0000723
724 while (SubstNonTypeTemplateParmExpr *NTTP
725 = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE)) {
726 CEE = NTTP->getReplacement()->IgnoreParenCasts();
727 }
728
Sebastian Redl20012152010-09-10 20:55:30 +0000729 // If we're calling a dereference, look at the pointer instead.
730 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CEE)) {
731 if (BO->isPtrMemOp())
732 CEE = BO->getRHS()->IgnoreParenCasts();
733 } else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(CEE)) {
734 if (UO->getOpcode() == UO_Deref)
735 CEE = UO->getSubExpr()->IgnoreParenCasts();
736 }
Chris Lattner6346f962009-07-17 15:46:27 +0000737 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
Nuno Lopesd20254f2009-12-20 23:11:08 +0000738 return DRE->getDecl();
Nuno Lopescb1c77f2009-12-24 00:28:18 +0000739 if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
740 return ME->getMemberDecl();
Zhongxing Xua0042542009-07-17 07:29:51 +0000741
742 return 0;
743}
744
Nuno Lopesd20254f2009-12-20 23:11:08 +0000745FunctionDecl *CallExpr::getDirectCallee() {
Chris Lattnercaabf9b2009-12-21 01:10:56 +0000746 return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
Nuno Lopesd20254f2009-12-20 23:11:08 +0000747}
748
Chris Lattnerd18b3292007-12-28 05:25:02 +0000749/// setNumArgs - This changes the number of arguments present in this call.
750/// Any orphaned expressions are deleted by this, and any new operands are set
751/// to null.
Ted Kremenek8189cde2009-02-07 01:47:29 +0000752void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) {
Chris Lattnerd18b3292007-12-28 05:25:02 +0000753 // No change, just return.
754 if (NumArgs == getNumArgs()) return;
Mike Stump1eb44332009-09-09 15:08:12 +0000755
Chris Lattnerd18b3292007-12-28 05:25:02 +0000756 // If shrinking # arguments, just delete the extras and forgot them.
757 if (NumArgs < getNumArgs()) {
Chris Lattnerd18b3292007-12-28 05:25:02 +0000758 this->NumArgs = NumArgs;
759 return;
760 }
761
762 // Otherwise, we are growing the # arguments. New an bigger argument array.
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000763 unsigned NumPreArgs = getNumPreArgs();
764 Stmt **NewSubExprs = new (C) Stmt*[NumArgs+PREARGS_START+NumPreArgs];
Chris Lattnerd18b3292007-12-28 05:25:02 +0000765 // Copy over args.
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000766 for (unsigned i = 0; i != getNumArgs()+PREARGS_START+NumPreArgs; ++i)
Chris Lattnerd18b3292007-12-28 05:25:02 +0000767 NewSubExprs[i] = SubExprs[i];
768 // Null out new args.
Peter Collingbournecc324ad2011-02-08 21:18:02 +0000769 for (unsigned i = getNumArgs()+PREARGS_START+NumPreArgs;
770 i != NumArgs+PREARGS_START+NumPreArgs; ++i)
Chris Lattnerd18b3292007-12-28 05:25:02 +0000771 NewSubExprs[i] = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000772
Douglas Gregor88c9a462009-04-17 21:46:47 +0000773 if (SubExprs) C.Deallocate(SubExprs);
Chris Lattnerd18b3292007-12-28 05:25:02 +0000774 SubExprs = NewSubExprs;
775 this->NumArgs = NumArgs;
776}
777
Chris Lattnercb888962008-10-06 05:00:53 +0000778/// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If
779/// not, return 0.
Jay Foad4ba2a172011-01-12 09:06:06 +0000780unsigned CallExpr::isBuiltinCall(const ASTContext &Context) const {
Steve Naroffc4f8e8b2008-01-31 01:07:12 +0000781 // All simple function calls (e.g. func()) are implicitly cast to pointer to
Mike Stump1eb44332009-09-09 15:08:12 +0000782 // function. As a result, we try and obtain the DeclRefExpr from the
Steve Naroffc4f8e8b2008-01-31 01:07:12 +0000783 // ImplicitCastExpr.
784 const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
785 if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
Chris Lattnercb888962008-10-06 05:00:53 +0000786 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000787
Steve Naroffc4f8e8b2008-01-31 01:07:12 +0000788 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
789 if (!DRE)
Chris Lattnercb888962008-10-06 05:00:53 +0000790 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000791
Anders Carlssonbcba2012008-01-31 02:13:57 +0000792 const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
793 if (!FDecl)
Chris Lattnercb888962008-10-06 05:00:53 +0000794 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000795
Douglas Gregor4fcd3992008-11-21 15:30:19 +0000796 if (!FDecl->getIdentifier())
797 return 0;
798
Douglas Gregor7814e6d2009-09-12 00:22:50 +0000799 return FDecl->getBuiltinID();
Chris Lattnercb888962008-10-06 05:00:53 +0000800}
Anders Carlssonbcba2012008-01-31 02:13:57 +0000801
Anders Carlsson6dde78f2009-05-26 04:57:27 +0000802QualType CallExpr::getCallReturnType() const {
803 QualType CalleeType = getCallee()->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +0000804 if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>())
Anders Carlsson6dde78f2009-05-26 04:57:27 +0000805 CalleeType = FnTypePtr->getPointeeType();
Ted Kremenek6217b802009-07-29 21:53:49 +0000806 else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>())
Anders Carlsson6dde78f2009-05-26 04:57:27 +0000807 CalleeType = BPT->getPointeeType();
John McCall864c0412011-04-26 20:42:42 +0000808 else if (CalleeType->isSpecificPlaceholderType(BuiltinType::BoundMember))
809 // This should never be overloaded and so should never return null.
810 CalleeType = Expr::findBoundMemberType(getCallee());
Douglas Gregor5291c3c2010-07-13 08:18:22 +0000811
John McCall864c0412011-04-26 20:42:42 +0000812 const FunctionType *FnType = CalleeType->castAs<FunctionType>();
Anders Carlsson6dde78f2009-05-26 04:57:27 +0000813 return FnType->getResultType();
814}
Chris Lattnercb888962008-10-06 05:00:53 +0000815
John McCall2882eca2011-02-21 06:23:05 +0000816SourceRange CallExpr::getSourceRange() const {
817 if (isa<CXXOperatorCallExpr>(this))
818 return cast<CXXOperatorCallExpr>(this)->getSourceRange();
819
820 SourceLocation begin = getCallee()->getLocStart();
821 if (begin.isInvalid() && getNumArgs() > 0)
822 begin = getArg(0)->getLocStart();
823 SourceLocation end = getRParenLoc();
824 if (end.isInvalid() && getNumArgs() > 0)
825 end = getArg(getNumArgs() - 1)->getLocEnd();
826 return SourceRange(begin, end);
827}
828
Sean Huntc3021132010-05-05 15:23:54 +0000829OffsetOfExpr *OffsetOfExpr::Create(ASTContext &C, QualType type,
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000830 SourceLocation OperatorLoc,
Sean Huntc3021132010-05-05 15:23:54 +0000831 TypeSourceInfo *tsi,
832 OffsetOfNode* compsPtr, unsigned numComps,
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000833 Expr** exprsPtr, unsigned numExprs,
834 SourceLocation RParenLoc) {
835 void *Mem = C.Allocate(sizeof(OffsetOfExpr) +
Sean Huntc3021132010-05-05 15:23:54 +0000836 sizeof(OffsetOfNode) * numComps +
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000837 sizeof(Expr*) * numExprs);
838
839 return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, compsPtr, numComps,
840 exprsPtr, numExprs, RParenLoc);
841}
842
843OffsetOfExpr *OffsetOfExpr::CreateEmpty(ASTContext &C,
844 unsigned numComps, unsigned numExprs) {
845 void *Mem = C.Allocate(sizeof(OffsetOfExpr) +
846 sizeof(OffsetOfNode) * numComps +
847 sizeof(Expr*) * numExprs);
848 return new (Mem) OffsetOfExpr(numComps, numExprs);
849}
850
Sean Huntc3021132010-05-05 15:23:54 +0000851OffsetOfExpr::OffsetOfExpr(ASTContext &C, QualType type,
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000852 SourceLocation OperatorLoc, TypeSourceInfo *tsi,
Sean Huntc3021132010-05-05 15:23:54 +0000853 OffsetOfNode* compsPtr, unsigned numComps,
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000854 Expr** exprsPtr, unsigned numExprs,
855 SourceLocation RParenLoc)
John McCallf89e55a2010-11-18 06:31:45 +0000856 : Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary,
857 /*TypeDependent=*/false,
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000858 /*ValueDependent=*/tsi->getType()->isDependentType(),
Douglas Gregor561f8122011-07-01 01:22:09 +0000859 tsi->getType()->isInstantiationDependentType(),
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000860 tsi->getType()->containsUnexpandedParameterPack()),
Sean Huntc3021132010-05-05 15:23:54 +0000861 OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
862 NumComps(numComps), NumExprs(numExprs)
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000863{
864 for(unsigned i = 0; i < numComps; ++i) {
865 setComponent(i, compsPtr[i]);
866 }
Sean Huntc3021132010-05-05 15:23:54 +0000867
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000868 for(unsigned i = 0; i < numExprs; ++i) {
Douglas Gregorbebbe0d2010-12-15 01:34:56 +0000869 if (exprsPtr[i]->isTypeDependent() || exprsPtr[i]->isValueDependent())
870 ExprBits.ValueDependent = true;
871 if (exprsPtr[i]->containsUnexpandedParameterPack())
872 ExprBits.ContainsUnexpandedParameterPack = true;
873
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000874 setIndexExpr(i, exprsPtr[i]);
875 }
876}
877
878IdentifierInfo *OffsetOfExpr::OffsetOfNode::getFieldName() const {
879 assert(getKind() == Field || getKind() == Identifier);
880 if (getKind() == Field)
881 return getField()->getIdentifier();
Sean Huntc3021132010-05-05 15:23:54 +0000882
Douglas Gregor8ecdb652010-04-28 22:16:22 +0000883 return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask);
884}
885
Mike Stump1eb44332009-09-09 15:08:12 +0000886MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow,
Douglas Gregor40d96a62011-02-28 21:54:11 +0000887 NestedNameSpecifierLoc QualifierLoc,
Eli Friedmanf595cc42009-12-04 06:40:45 +0000888 ValueDecl *memberdecl,
John McCall161755a2010-04-06 21:38:20 +0000889 DeclAccessPair founddecl,
Abramo Bagnara25777432010-08-11 22:01:17 +0000890 DeclarationNameInfo nameinfo,
John McCalld5532b62009-11-23 01:53:49 +0000891 const TemplateArgumentListInfo *targs,
John McCallf89e55a2010-11-18 06:31:45 +0000892 QualType ty,
893 ExprValueKind vk,
894 ExprObjectKind ok) {
Douglas Gregor83f6faf2009-08-31 23:41:50 +0000895 std::size_t Size = sizeof(MemberExpr);
John McCall6bb80172010-03-30 21:47:33 +0000896
Douglas Gregor40d96a62011-02-28 21:54:11 +0000897 bool hasQualOrFound = (QualifierLoc ||
John McCall161755a2010-04-06 21:38:20 +0000898 founddecl.getDecl() != memberdecl ||
899 founddecl.getAccess() != memberdecl->getAccess());
John McCall6bb80172010-03-30 21:47:33 +0000900 if (hasQualOrFound)
901 Size += sizeof(MemberNameQualifier);
Mike Stump1eb44332009-09-09 15:08:12 +0000902
John McCalld5532b62009-11-23 01:53:49 +0000903 if (targs)
Argyrios Kyrtzidisb0c3e092011-09-22 20:07:03 +0000904 Size += ASTTemplateArgumentListInfo::sizeFor(*targs);
Mike Stump1eb44332009-09-09 15:08:12 +0000905
Chris Lattner32488542010-10-30 05:14:06 +0000906 void *Mem = C.Allocate(Size, llvm::alignOf<MemberExpr>());
John McCallf89e55a2010-11-18 06:31:45 +0000907 MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, nameinfo,
908 ty, vk, ok);
John McCall6bb80172010-03-30 21:47:33 +0000909
910 if (hasQualOrFound) {
Douglas Gregor40d96a62011-02-28 21:54:11 +0000911 // FIXME: Wrong. We should be looking at the member declaration we found.
912 if (QualifierLoc && QualifierLoc.getNestedNameSpecifier()->isDependent()) {
John McCall6bb80172010-03-30 21:47:33 +0000913 E->setValueDependent(true);
914 E->setTypeDependent(true);
Douglas Gregor561f8122011-07-01 01:22:09 +0000915 E->setInstantiationDependent(true);
916 }
917 else if (QualifierLoc &&
918 QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())
919 E->setInstantiationDependent(true);
920
John McCall6bb80172010-03-30 21:47:33 +0000921 E->HasQualifierOrFoundDecl = true;
922
923 MemberNameQualifier *NQ = E->getMemberQualifier();
Douglas Gregor40d96a62011-02-28 21:54:11 +0000924 NQ->QualifierLoc = QualifierLoc;
John McCall6bb80172010-03-30 21:47:33 +0000925 NQ->FoundDecl = founddecl;
926 }
927
928 if (targs) {
Douglas Gregor561f8122011-07-01 01:22:09 +0000929 bool Dependent = false;
930 bool InstantiationDependent = false;
931 bool ContainsUnexpandedParameterPack = false;
John McCall6bb80172010-03-30 21:47:33 +0000932 E->HasExplicitTemplateArgumentList = true;
Douglas Gregor561f8122011-07-01 01:22:09 +0000933 E->getExplicitTemplateArgs().initializeFrom(*targs, Dependent,
934 InstantiationDependent,
935 ContainsUnexpandedParameterPack);
936 if (InstantiationDependent)
937 E->setInstantiationDependent(true);
John McCall6bb80172010-03-30 21:47:33 +0000938 }
939
940 return E;
Douglas Gregor83f6faf2009-08-31 23:41:50 +0000941}
942
Douglas Gregor75e85042011-03-02 21:06:53 +0000943SourceRange MemberExpr::getSourceRange() const {
944 SourceLocation StartLoc;
945 if (isImplicitAccess()) {
946 if (hasQualifier())
947 StartLoc = getQualifierLoc().getBeginLoc();
948 else
949 StartLoc = MemberLoc;
950 } else {
951 // FIXME: We don't want this to happen. Rather, we should be able to
952 // detect all kinds of implicit accesses more cleanly.
953 StartLoc = getBase()->getLocStart();
954 if (StartLoc.isInvalid())
955 StartLoc = MemberLoc;
956 }
957
958 SourceLocation EndLoc =
959 HasExplicitTemplateArgumentList? getRAngleLoc()
960 : getMemberNameInfo().getEndLoc();
961
962 return SourceRange(StartLoc, EndLoc);
963}
964
John McCall1d9b3b22011-09-09 05:25:32 +0000965void CastExpr::CheckCastConsistency() const {
966 switch (getCastKind()) {
967 case CK_DerivedToBase:
968 case CK_UncheckedDerivedToBase:
969 case CK_DerivedToBaseMemberPointer:
970 case CK_BaseToDerived:
971 case CK_BaseToDerivedMemberPointer:
972 assert(!path_empty() && "Cast kind should have a base path!");
973 break;
974
975 case CK_CPointerToObjCPointerCast:
976 assert(getType()->isObjCObjectPointerType());
977 assert(getSubExpr()->getType()->isPointerType());
978 goto CheckNoBasePath;
979
980 case CK_BlockPointerToObjCPointerCast:
981 assert(getType()->isObjCObjectPointerType());
982 assert(getSubExpr()->getType()->isBlockPointerType());
983 goto CheckNoBasePath;
984
985 case CK_BitCast:
986 // Arbitrary casts to C pointer types count as bitcasts.
987 // Otherwise, we should only have block and ObjC pointer casts
988 // here if they stay within the type kind.
989 if (!getType()->isPointerType()) {
990 assert(getType()->isObjCObjectPointerType() ==
991 getSubExpr()->getType()->isObjCObjectPointerType());
992 assert(getType()->isBlockPointerType() ==
993 getSubExpr()->getType()->isBlockPointerType());
994 }
995 goto CheckNoBasePath;
996
997 case CK_AnyPointerToBlockPointerCast:
998 assert(getType()->isBlockPointerType());
999 assert(getSubExpr()->getType()->isAnyPointerType() &&
1000 !getSubExpr()->getType()->isBlockPointerType());
1001 goto CheckNoBasePath;
1002
1003 // These should not have an inheritance path.
1004 case CK_Dynamic:
1005 case CK_ToUnion:
1006 case CK_ArrayToPointerDecay:
1007 case CK_FunctionToPointerDecay:
1008 case CK_NullToMemberPointer:
1009 case CK_NullToPointer:
1010 case CK_ConstructorConversion:
1011 case CK_IntegralToPointer:
1012 case CK_PointerToIntegral:
1013 case CK_ToVoid:
1014 case CK_VectorSplat:
1015 case CK_IntegralCast:
1016 case CK_IntegralToFloating:
1017 case CK_FloatingToIntegral:
1018 case CK_FloatingCast:
1019 case CK_ObjCObjectLValueCast:
1020 case CK_FloatingRealToComplex:
1021 case CK_FloatingComplexToReal:
1022 case CK_FloatingComplexCast:
1023 case CK_FloatingComplexToIntegralComplex:
1024 case CK_IntegralRealToComplex:
1025 case CK_IntegralComplexToReal:
1026 case CK_IntegralComplexCast:
1027 case CK_IntegralComplexToFloatingComplex:
John McCall33e56f32011-09-10 06:18:15 +00001028 case CK_ARCProduceObject:
1029 case CK_ARCConsumeObject:
1030 case CK_ARCReclaimReturnedObject:
1031 case CK_ARCExtendBlockObject:
John McCall1d9b3b22011-09-09 05:25:32 +00001032 assert(!getType()->isBooleanType() && "unheralded conversion to bool");
1033 goto CheckNoBasePath;
1034
1035 case CK_Dependent:
1036 case CK_LValueToRValue:
1037 case CK_GetObjCProperty:
1038 case CK_NoOp:
1039 case CK_PointerToBoolean:
1040 case CK_IntegralToBoolean:
1041 case CK_FloatingToBoolean:
1042 case CK_MemberPointerToBoolean:
1043 case CK_FloatingComplexToBoolean:
1044 case CK_IntegralComplexToBoolean:
1045 case CK_LValueBitCast: // -> bool&
1046 case CK_UserDefinedConversion: // operator bool()
1047 CheckNoBasePath:
1048 assert(path_empty() && "Cast kind should not have a base path!");
1049 break;
1050 }
1051}
1052
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001053const char *CastExpr::getCastKindName() const {
1054 switch (getCastKind()) {
John McCalldaa8e4e2010-11-15 09:13:47 +00001055 case CK_Dependent:
1056 return "Dependent";
John McCall2de56d12010-08-25 11:45:40 +00001057 case CK_BitCast:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001058 return "BitCast";
John McCall2de56d12010-08-25 11:45:40 +00001059 case CK_LValueBitCast:
Douglas Gregore39a3892010-07-13 23:17:26 +00001060 return "LValueBitCast";
John McCall0ae287a2010-12-01 04:43:34 +00001061 case CK_LValueToRValue:
1062 return "LValueToRValue";
John McCallf6a16482010-12-04 03:47:34 +00001063 case CK_GetObjCProperty:
1064 return "GetObjCProperty";
John McCall2de56d12010-08-25 11:45:40 +00001065 case CK_NoOp:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001066 return "NoOp";
John McCall2de56d12010-08-25 11:45:40 +00001067 case CK_BaseToDerived:
Anders Carlsson11de6de2009-11-12 16:43:42 +00001068 return "BaseToDerived";
John McCall2de56d12010-08-25 11:45:40 +00001069 case CK_DerivedToBase:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001070 return "DerivedToBase";
John McCall2de56d12010-08-25 11:45:40 +00001071 case CK_UncheckedDerivedToBase:
John McCall23cba802010-03-30 23:58:03 +00001072 return "UncheckedDerivedToBase";
John McCall2de56d12010-08-25 11:45:40 +00001073 case CK_Dynamic:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001074 return "Dynamic";
John McCall2de56d12010-08-25 11:45:40 +00001075 case CK_ToUnion:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001076 return "ToUnion";
John McCall2de56d12010-08-25 11:45:40 +00001077 case CK_ArrayToPointerDecay:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001078 return "ArrayToPointerDecay";
John McCall2de56d12010-08-25 11:45:40 +00001079 case CK_FunctionToPointerDecay:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001080 return "FunctionToPointerDecay";
John McCall2de56d12010-08-25 11:45:40 +00001081 case CK_NullToMemberPointer:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001082 return "NullToMemberPointer";
John McCall404cd162010-11-13 01:35:44 +00001083 case CK_NullToPointer:
1084 return "NullToPointer";
John McCall2de56d12010-08-25 11:45:40 +00001085 case CK_BaseToDerivedMemberPointer:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001086 return "BaseToDerivedMemberPointer";
John McCall2de56d12010-08-25 11:45:40 +00001087 case CK_DerivedToBaseMemberPointer:
Anders Carlsson1a31a182009-10-30 00:46:35 +00001088 return "DerivedToBaseMemberPointer";
John McCall2de56d12010-08-25 11:45:40 +00001089 case CK_UserDefinedConversion:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001090 return "UserDefinedConversion";
John McCall2de56d12010-08-25 11:45:40 +00001091 case CK_ConstructorConversion:
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001092 return "ConstructorConversion";
John McCall2de56d12010-08-25 11:45:40 +00001093 case CK_IntegralToPointer:
Anders Carlsson7f9e6462009-09-15 04:48:33 +00001094 return "IntegralToPointer";
John McCall2de56d12010-08-25 11:45:40 +00001095 case CK_PointerToIntegral:
Anders Carlsson7f9e6462009-09-15 04:48:33 +00001096 return "PointerToIntegral";
John McCalldaa8e4e2010-11-15 09:13:47 +00001097 case CK_PointerToBoolean:
1098 return "PointerToBoolean";
John McCall2de56d12010-08-25 11:45:40 +00001099 case CK_ToVoid:
Anders Carlssonebeaf202009-10-16 02:35:04 +00001100 return "ToVoid";
John McCall2de56d12010-08-25 11:45:40 +00001101 case CK_VectorSplat:
Anders Carlsson16a89042009-10-16 05:23:41 +00001102 return "VectorSplat";
John McCall2de56d12010-08-25 11:45:40 +00001103 case CK_IntegralCast:
Anders Carlsson82debc72009-10-18 18:12:03 +00001104 return "IntegralCast";
John McCalldaa8e4e2010-11-15 09:13:47 +00001105 case CK_IntegralToBoolean:
1106 return "IntegralToBoolean";
John McCall2de56d12010-08-25 11:45:40 +00001107 case CK_IntegralToFloating:
Anders Carlsson82debc72009-10-18 18:12:03 +00001108 return "IntegralToFloating";
John McCall2de56d12010-08-25 11:45:40 +00001109 case CK_FloatingToIntegral:
Anders Carlsson82debc72009-10-18 18:12:03 +00001110 return "FloatingToIntegral";
John McCall2de56d12010-08-25 11:45:40 +00001111 case CK_FloatingCast:
Benjamin Kramerc6b29162009-10-18 19:02:15 +00001112 return "FloatingCast";
John McCalldaa8e4e2010-11-15 09:13:47 +00001113 case CK_FloatingToBoolean:
1114 return "FloatingToBoolean";
John McCall2de56d12010-08-25 11:45:40 +00001115 case CK_MemberPointerToBoolean:
Anders Carlssonbc0e0782009-11-23 20:04:44 +00001116 return "MemberPointerToBoolean";
John McCall1d9b3b22011-09-09 05:25:32 +00001117 case CK_CPointerToObjCPointerCast:
1118 return "CPointerToObjCPointerCast";
1119 case CK_BlockPointerToObjCPointerCast:
1120 return "BlockPointerToObjCPointerCast";
John McCall2de56d12010-08-25 11:45:40 +00001121 case CK_AnyPointerToBlockPointerCast:
Fariborz Jahanian3b27f1a2009-12-11 22:40:48 +00001122 return "AnyPointerToBlockPointerCast";
John McCall2de56d12010-08-25 11:45:40 +00001123 case CK_ObjCObjectLValueCast:
Douglas Gregor569c3162010-08-07 11:51:51 +00001124 return "ObjCObjectLValueCast";
John McCall2bb5d002010-11-13 09:02:35 +00001125 case CK_FloatingRealToComplex:
1126 return "FloatingRealToComplex";
John McCallf3ea8cf2010-11-14 08:17:51 +00001127 case CK_FloatingComplexToReal:
1128 return "FloatingComplexToReal";
1129 case CK_FloatingComplexToBoolean:
1130 return "FloatingComplexToBoolean";
John McCall2bb5d002010-11-13 09:02:35 +00001131 case CK_FloatingComplexCast:
1132 return "FloatingComplexCast";
John McCallf3ea8cf2010-11-14 08:17:51 +00001133 case CK_FloatingComplexToIntegralComplex:
1134 return "FloatingComplexToIntegralComplex";
John McCall2bb5d002010-11-13 09:02:35 +00001135 case CK_IntegralRealToComplex:
1136 return "IntegralRealToComplex";
John McCallf3ea8cf2010-11-14 08:17:51 +00001137 case CK_IntegralComplexToReal:
1138 return "IntegralComplexToReal";
1139 case CK_IntegralComplexToBoolean:
1140 return "IntegralComplexToBoolean";
John McCall2bb5d002010-11-13 09:02:35 +00001141 case CK_IntegralComplexCast:
1142 return "IntegralComplexCast";
John McCallf3ea8cf2010-11-14 08:17:51 +00001143 case CK_IntegralComplexToFloatingComplex:
1144 return "IntegralComplexToFloatingComplex";
John McCall33e56f32011-09-10 06:18:15 +00001145 case CK_ARCConsumeObject:
1146 return "ARCConsumeObject";
1147 case CK_ARCProduceObject:
1148 return "ARCProduceObject";
1149 case CK_ARCReclaimReturnedObject:
1150 return "ARCReclaimReturnedObject";
1151 case CK_ARCExtendBlockObject:
1152 return "ARCCExtendBlockObject";
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001153 }
Mike Stump1eb44332009-09-09 15:08:12 +00001154
John McCall2bb5d002010-11-13 09:02:35 +00001155 llvm_unreachable("Unhandled cast kind!");
Anders Carlssonf8ec55a2009-09-03 00:59:21 +00001156 return 0;
1157}
1158
Douglas Gregor6eef5192009-12-14 19:27:10 +00001159Expr *CastExpr::getSubExprAsWritten() {
1160 Expr *SubExpr = 0;
1161 CastExpr *E = this;
1162 do {
1163 SubExpr = E->getSubExpr();
Douglas Gregor03e80032011-06-21 17:03:29 +00001164
1165 // Skip through reference binding to temporary.
1166 if (MaterializeTemporaryExpr *Materialize
1167 = dyn_cast<MaterializeTemporaryExpr>(SubExpr))
1168 SubExpr = Materialize->GetTemporaryExpr();
1169
Douglas Gregor6eef5192009-12-14 19:27:10 +00001170 // Skip any temporary bindings; they're implicit.
1171 if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
1172 SubExpr = Binder->getSubExpr();
Sean Huntc3021132010-05-05 15:23:54 +00001173
Douglas Gregor6eef5192009-12-14 19:27:10 +00001174 // Conversions by constructor and conversion functions have a
1175 // subexpression describing the call; strip it off.
John McCall2de56d12010-08-25 11:45:40 +00001176 if (E->getCastKind() == CK_ConstructorConversion)
Douglas Gregor6eef5192009-12-14 19:27:10 +00001177 SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0);
John McCall2de56d12010-08-25 11:45:40 +00001178 else if (E->getCastKind() == CK_UserDefinedConversion)
Douglas Gregor6eef5192009-12-14 19:27:10 +00001179 SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument();
Sean Huntc3021132010-05-05 15:23:54 +00001180
Douglas Gregor6eef5192009-12-14 19:27:10 +00001181 // If the subexpression we're left with is an implicit cast, look
1182 // through that, too.
Sean Huntc3021132010-05-05 15:23:54 +00001183 } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr)));
1184
Douglas Gregor6eef5192009-12-14 19:27:10 +00001185 return SubExpr;
1186}
1187
John McCallf871d0c2010-08-07 06:22:56 +00001188CXXBaseSpecifier **CastExpr::path_buffer() {
1189 switch (getStmtClass()) {
1190#define ABSTRACT_STMT(x)
1191#define CASTEXPR(Type, Base) \
1192 case Stmt::Type##Class: \
1193 return reinterpret_cast<CXXBaseSpecifier**>(static_cast<Type*>(this)+1);
1194#define STMT(Type, Base)
1195#include "clang/AST/StmtNodes.inc"
1196 default:
1197 llvm_unreachable("non-cast expressions not possible here");
1198 return 0;
1199 }
1200}
1201
1202void CastExpr::setCastPath(const CXXCastPath &Path) {
1203 assert(Path.size() == path_size());
1204 memcpy(path_buffer(), Path.data(), Path.size() * sizeof(CXXBaseSpecifier*));
1205}
1206
1207ImplicitCastExpr *ImplicitCastExpr::Create(ASTContext &C, QualType T,
1208 CastKind Kind, Expr *Operand,
1209 const CXXCastPath *BasePath,
John McCall5baba9d2010-08-25 10:28:54 +00001210 ExprValueKind VK) {
John McCallf871d0c2010-08-07 06:22:56 +00001211 unsigned PathSize = (BasePath ? BasePath->size() : 0);
1212 void *Buffer =
1213 C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1214 ImplicitCastExpr *E =
John McCall5baba9d2010-08-25 10:28:54 +00001215 new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK);
John McCallf871d0c2010-08-07 06:22:56 +00001216 if (PathSize) E->setCastPath(*BasePath);
1217 return E;
1218}
1219
1220ImplicitCastExpr *ImplicitCastExpr::CreateEmpty(ASTContext &C,
1221 unsigned PathSize) {
1222 void *Buffer =
1223 C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1224 return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize);
1225}
1226
1227
1228CStyleCastExpr *CStyleCastExpr::Create(ASTContext &C, QualType T,
John McCallf89e55a2010-11-18 06:31:45 +00001229 ExprValueKind VK, CastKind K, Expr *Op,
John McCallf871d0c2010-08-07 06:22:56 +00001230 const CXXCastPath *BasePath,
1231 TypeSourceInfo *WrittenTy,
1232 SourceLocation L, SourceLocation R) {
1233 unsigned PathSize = (BasePath ? BasePath->size() : 0);
1234 void *Buffer =
1235 C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1236 CStyleCastExpr *E =
John McCallf89e55a2010-11-18 06:31:45 +00001237 new (Buffer) CStyleCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, R);
John McCallf871d0c2010-08-07 06:22:56 +00001238 if (PathSize) E->setCastPath(*BasePath);
1239 return E;
1240}
1241
1242CStyleCastExpr *CStyleCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
1243 void *Buffer =
1244 C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1245 return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize);
1246}
1247
Reid Spencer5f016e22007-07-11 17:01:13 +00001248/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
1249/// corresponds to, e.g. "<<=".
1250const char *BinaryOperator::getOpcodeStr(Opcode Op) {
1251 switch (Op) {
John McCall2de56d12010-08-25 11:45:40 +00001252 case BO_PtrMemD: return ".*";
1253 case BO_PtrMemI: return "->*";
1254 case BO_Mul: return "*";
1255 case BO_Div: return "/";
1256 case BO_Rem: return "%";
1257 case BO_Add: return "+";
1258 case BO_Sub: return "-";
1259 case BO_Shl: return "<<";
1260 case BO_Shr: return ">>";
1261 case BO_LT: return "<";
1262 case BO_GT: return ">";
1263 case BO_LE: return "<=";
1264 case BO_GE: return ">=";
1265 case BO_EQ: return "==";
1266 case BO_NE: return "!=";
1267 case BO_And: return "&";
1268 case BO_Xor: return "^";
1269 case BO_Or: return "|";
1270 case BO_LAnd: return "&&";
1271 case BO_LOr: return "||";
1272 case BO_Assign: return "=";
1273 case BO_MulAssign: return "*=";
1274 case BO_DivAssign: return "/=";
1275 case BO_RemAssign: return "%=";
1276 case BO_AddAssign: return "+=";
1277 case BO_SubAssign: return "-=";
1278 case BO_ShlAssign: return "<<=";
1279 case BO_ShrAssign: return ">>=";
1280 case BO_AndAssign: return "&=";
1281 case BO_XorAssign: return "^=";
1282 case BO_OrAssign: return "|=";
1283 case BO_Comma: return ",";
Reid Spencer5f016e22007-07-11 17:01:13 +00001284 }
Douglas Gregorbaf53482009-03-12 22:51:37 +00001285
1286 return "";
Reid Spencer5f016e22007-07-11 17:01:13 +00001287}
1288
John McCall2de56d12010-08-25 11:45:40 +00001289BinaryOperatorKind
Douglas Gregor063daf62009-03-13 18:40:31 +00001290BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
1291 switch (OO) {
David Blaikieb219cfc2011-09-23 05:06:16 +00001292 default: llvm_unreachable("Not an overloadable binary operator");
John McCall2de56d12010-08-25 11:45:40 +00001293 case OO_Plus: return BO_Add;
1294 case OO_Minus: return BO_Sub;
1295 case OO_Star: return BO_Mul;
1296 case OO_Slash: return BO_Div;
1297 case OO_Percent: return BO_Rem;
1298 case OO_Caret: return BO_Xor;
1299 case OO_Amp: return BO_And;
1300 case OO_Pipe: return BO_Or;
1301 case OO_Equal: return BO_Assign;
1302 case OO_Less: return BO_LT;
1303 case OO_Greater: return BO_GT;
1304 case OO_PlusEqual: return BO_AddAssign;
1305 case OO_MinusEqual: return BO_SubAssign;
1306 case OO_StarEqual: return BO_MulAssign;
1307 case OO_SlashEqual: return BO_DivAssign;
1308 case OO_PercentEqual: return BO_RemAssign;
1309 case OO_CaretEqual: return BO_XorAssign;
1310 case OO_AmpEqual: return BO_AndAssign;
1311 case OO_PipeEqual: return BO_OrAssign;
1312 case OO_LessLess: return BO_Shl;
1313 case OO_GreaterGreater: return BO_Shr;
1314 case OO_LessLessEqual: return BO_ShlAssign;
1315 case OO_GreaterGreaterEqual: return BO_ShrAssign;
1316 case OO_EqualEqual: return BO_EQ;
1317 case OO_ExclaimEqual: return BO_NE;
1318 case OO_LessEqual: return BO_LE;
1319 case OO_GreaterEqual: return BO_GE;
1320 case OO_AmpAmp: return BO_LAnd;
1321 case OO_PipePipe: return BO_LOr;
1322 case OO_Comma: return BO_Comma;
1323 case OO_ArrowStar: return BO_PtrMemI;
Douglas Gregor063daf62009-03-13 18:40:31 +00001324 }
1325}
1326
1327OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
1328 static const OverloadedOperatorKind OverOps[] = {
1329 /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
1330 OO_Star, OO_Slash, OO_Percent,
1331 OO_Plus, OO_Minus,
1332 OO_LessLess, OO_GreaterGreater,
1333 OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
1334 OO_EqualEqual, OO_ExclaimEqual,
1335 OO_Amp,
1336 OO_Caret,
1337 OO_Pipe,
1338 OO_AmpAmp,
1339 OO_PipePipe,
1340 OO_Equal, OO_StarEqual,
1341 OO_SlashEqual, OO_PercentEqual,
1342 OO_PlusEqual, OO_MinusEqual,
1343 OO_LessLessEqual, OO_GreaterGreaterEqual,
1344 OO_AmpEqual, OO_CaretEqual,
1345 OO_PipeEqual,
1346 OO_Comma
1347 };
1348 return OverOps[Opc];
1349}
1350
Ted Kremenek709210f2010-04-13 23:39:13 +00001351InitListExpr::InitListExpr(ASTContext &C, SourceLocation lbraceloc,
Chris Lattner418f6c72008-10-26 23:43:26 +00001352 Expr **initExprs, unsigned numInits,
Douglas Gregor4c678342009-01-28 21:54:33 +00001353 SourceLocation rbraceloc)
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00001354 : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false,
Douglas Gregor561f8122011-07-01 01:22:09 +00001355 false, false),
Ted Kremenek709210f2010-04-13 23:39:13 +00001356 InitExprs(C, numInits),
Mike Stump1eb44332009-09-09 15:08:12 +00001357 LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0),
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +00001358 HadArrayRangeDesignator(false)
Sean Huntc3021132010-05-05 15:23:54 +00001359{
Ted Kremenekba7bc552010-02-19 01:50:18 +00001360 for (unsigned I = 0; I != numInits; ++I) {
1361 if (initExprs[I]->isTypeDependent())
John McCall8e6285a2010-10-26 08:39:16 +00001362 ExprBits.TypeDependent = true;
Ted Kremenekba7bc552010-02-19 01:50:18 +00001363 if (initExprs[I]->isValueDependent())
John McCall8e6285a2010-10-26 08:39:16 +00001364 ExprBits.ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +00001365 if (initExprs[I]->isInstantiationDependent())
1366 ExprBits.InstantiationDependent = true;
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00001367 if (initExprs[I]->containsUnexpandedParameterPack())
1368 ExprBits.ContainsUnexpandedParameterPack = true;
Douglas Gregor73460a32009-11-19 23:25:22 +00001369 }
Sean Huntc3021132010-05-05 15:23:54 +00001370
Ted Kremenek709210f2010-04-13 23:39:13 +00001371 InitExprs.insert(C, InitExprs.end(), initExprs, initExprs+numInits);
Anders Carlsson66b5a8a2007-08-31 04:56:16 +00001372}
Reid Spencer5f016e22007-07-11 17:01:13 +00001373
Ted Kremenek709210f2010-04-13 23:39:13 +00001374void InitListExpr::reserveInits(ASTContext &C, unsigned NumInits) {
Ted Kremenekba7bc552010-02-19 01:50:18 +00001375 if (NumInits > InitExprs.size())
Ted Kremenek709210f2010-04-13 23:39:13 +00001376 InitExprs.reserve(C, NumInits);
Douglas Gregorfa219202009-03-20 23:58:33 +00001377}
1378
Ted Kremenek709210f2010-04-13 23:39:13 +00001379void InitListExpr::resizeInits(ASTContext &C, unsigned NumInits) {
Ted Kremenek709210f2010-04-13 23:39:13 +00001380 InitExprs.resize(C, NumInits, 0);
Douglas Gregor4c678342009-01-28 21:54:33 +00001381}
1382
Ted Kremenek709210f2010-04-13 23:39:13 +00001383Expr *InitListExpr::updateInit(ASTContext &C, unsigned Init, Expr *expr) {
Ted Kremenekba7bc552010-02-19 01:50:18 +00001384 if (Init >= InitExprs.size()) {
Ted Kremenek709210f2010-04-13 23:39:13 +00001385 InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, 0);
Ted Kremenekba7bc552010-02-19 01:50:18 +00001386 InitExprs.back() = expr;
1387 return 0;
Douglas Gregor4c678342009-01-28 21:54:33 +00001388 }
Mike Stump1eb44332009-09-09 15:08:12 +00001389
Douglas Gregor4c678342009-01-28 21:54:33 +00001390 Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
1391 InitExprs[Init] = expr;
1392 return Result;
1393}
1394
Argyrios Kyrtzidis3e8dc2a2011-04-21 20:03:38 +00001395void InitListExpr::setArrayFiller(Expr *filler) {
1396 ArrayFillerOrUnionFieldInit = filler;
1397 // Fill out any "holes" in the array due to designated initializers.
1398 Expr **inits = getInits();
1399 for (unsigned i = 0, e = getNumInits(); i != e; ++i)
1400 if (inits[i] == 0)
1401 inits[i] = filler;
1402}
1403
Ted Kremenekc4ba51f2010-11-09 02:11:40 +00001404SourceRange InitListExpr::getSourceRange() const {
1405 if (SyntacticForm)
1406 return SyntacticForm->getSourceRange();
1407 SourceLocation Beg = LBraceLoc, End = RBraceLoc;
1408 if (Beg.isInvalid()) {
1409 // Find the first non-null initializer.
1410 for (InitExprsTy::const_iterator I = InitExprs.begin(),
1411 E = InitExprs.end();
1412 I != E; ++I) {
1413 if (Stmt *S = *I) {
1414 Beg = S->getLocStart();
1415 break;
1416 }
1417 }
1418 }
1419 if (End.isInvalid()) {
1420 // Find the first non-null initializer from the end.
1421 for (InitExprsTy::const_reverse_iterator I = InitExprs.rbegin(),
1422 E = InitExprs.rend();
1423 I != E; ++I) {
1424 if (Stmt *S = *I) {
1425 End = S->getSourceRange().getEnd();
1426 break;
1427 }
1428 }
1429 }
1430 return SourceRange(Beg, End);
1431}
1432
Steve Naroffbfdcae62008-09-04 15:31:07 +00001433/// getFunctionType - Return the underlying function type for this block.
Steve Naroff4eb206b2008-09-03 18:15:37 +00001434///
1435const FunctionType *BlockExpr::getFunctionType() const {
Ted Kremenek6217b802009-07-29 21:53:49 +00001436 return getType()->getAs<BlockPointerType>()->
John McCall183700f2009-09-21 23:43:11 +00001437 getPointeeType()->getAs<FunctionType>();
Steve Naroff4eb206b2008-09-03 18:15:37 +00001438}
1439
Mike Stump1eb44332009-09-09 15:08:12 +00001440SourceLocation BlockExpr::getCaretLocation() const {
1441 return TheBlock->getCaretLocation();
Steve Naroff56ee6892008-10-08 17:01:13 +00001442}
Mike Stump1eb44332009-09-09 15:08:12 +00001443const Stmt *BlockExpr::getBody() const {
Douglas Gregor72971342009-04-18 00:02:19 +00001444 return TheBlock->getBody();
1445}
Mike Stump1eb44332009-09-09 15:08:12 +00001446Stmt *BlockExpr::getBody() {
1447 return TheBlock->getBody();
Douglas Gregor72971342009-04-18 00:02:19 +00001448}
Steve Naroff56ee6892008-10-08 17:01:13 +00001449
1450
Reid Spencer5f016e22007-07-11 17:01:13 +00001451//===----------------------------------------------------------------------===//
1452// Generic Expression Routines
1453//===----------------------------------------------------------------------===//
1454
Chris Lattner026dc962009-02-14 07:37:35 +00001455/// isUnusedResultAWarning - Return true if this immediate expression should
1456/// be warned about if the result is unused. If so, fill in Loc and Ranges
1457/// with location to warn on and the source range[s] to report with the
1458/// warning.
1459bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1,
Mike Stumpdf317bf2009-11-03 23:25:48 +00001460 SourceRange &R2, ASTContext &Ctx) const {
Anders Carlssonffce2df2009-05-15 23:10:19 +00001461 // Don't warn if the expr is type dependent. The type could end up
1462 // instantiating to void.
1463 if (isTypeDependent())
1464 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001465
Reid Spencer5f016e22007-07-11 17:01:13 +00001466 switch (getStmtClass()) {
1467 default:
John McCall0faede62010-03-12 07:11:26 +00001468 if (getType()->isVoidType())
1469 return false;
Chris Lattner026dc962009-02-14 07:37:35 +00001470 Loc = getExprLoc();
1471 R1 = getSourceRange();
1472 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00001473 case ParenExprClass:
Chris Lattner026dc962009-02-14 07:37:35 +00001474 return cast<ParenExpr>(this)->getSubExpr()->
Mike Stumpdf317bf2009-11-03 23:25:48 +00001475 isUnusedResultAWarning(Loc, R1, R2, Ctx);
Peter Collingbournef111d932011-04-15 00:35:48 +00001476 case GenericSelectionExprClass:
1477 return cast<GenericSelectionExpr>(this)->getResultExpr()->
1478 isUnusedResultAWarning(Loc, R1, R2, Ctx);
Reid Spencer5f016e22007-07-11 17:01:13 +00001479 case UnaryOperatorClass: {
1480 const UnaryOperator *UO = cast<UnaryOperator>(this);
Mike Stump1eb44332009-09-09 15:08:12 +00001481
Reid Spencer5f016e22007-07-11 17:01:13 +00001482 switch (UO->getOpcode()) {
Chris Lattner026dc962009-02-14 07:37:35 +00001483 default: break;
John McCall2de56d12010-08-25 11:45:40 +00001484 case UO_PostInc:
1485 case UO_PostDec:
1486 case UO_PreInc:
1487 case UO_PreDec: // ++/--
Chris Lattner026dc962009-02-14 07:37:35 +00001488 return false; // Not a warning.
John McCall2de56d12010-08-25 11:45:40 +00001489 case UO_Deref:
Reid Spencer5f016e22007-07-11 17:01:13 +00001490 // Dereferencing a volatile pointer is a side-effect.
Mike Stumpdf317bf2009-11-03 23:25:48 +00001491 if (Ctx.getCanonicalType(getType()).isVolatileQualified())
Chris Lattner026dc962009-02-14 07:37:35 +00001492 return false;
1493 break;
John McCall2de56d12010-08-25 11:45:40 +00001494 case UO_Real:
1495 case UO_Imag:
Reid Spencer5f016e22007-07-11 17:01:13 +00001496 // accessing a piece of a volatile complex is a side-effect.
Mike Stumpdf317bf2009-11-03 23:25:48 +00001497 if (Ctx.getCanonicalType(UO->getSubExpr()->getType())
1498 .isVolatileQualified())
Chris Lattner026dc962009-02-14 07:37:35 +00001499 return false;
1500 break;
John McCall2de56d12010-08-25 11:45:40 +00001501 case UO_Extension:
Mike Stumpdf317bf2009-11-03 23:25:48 +00001502 return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
Reid Spencer5f016e22007-07-11 17:01:13 +00001503 }
Chris Lattner026dc962009-02-14 07:37:35 +00001504 Loc = UO->getOperatorLoc();
1505 R1 = UO->getSubExpr()->getSourceRange();
1506 return true;
Reid Spencer5f016e22007-07-11 17:01:13 +00001507 }
Chris Lattnere7716e62007-12-01 06:07:34 +00001508 case BinaryOperatorClass: {
Chris Lattner026dc962009-02-14 07:37:35 +00001509 const BinaryOperator *BO = cast<BinaryOperator>(this);
Ted Kremenekc46a2462010-04-07 18:49:21 +00001510 switch (BO->getOpcode()) {
1511 default:
1512 break;
Argyrios Kyrtzidis25973452010-06-30 10:53:14 +00001513 // Consider the RHS of comma for side effects. LHS was checked by
1514 // Sema::CheckCommaOperands.
John McCall2de56d12010-08-25 11:45:40 +00001515 case BO_Comma:
Ted Kremenekc46a2462010-04-07 18:49:21 +00001516 // ((foo = <blah>), 0) is an idiom for hiding the result (and
1517 // lvalue-ness) of an assignment written in a macro.
1518 if (IntegerLiteral *IE =
1519 dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens()))
1520 if (IE->getValue() == 0)
1521 return false;
Argyrios Kyrtzidis25973452010-06-30 10:53:14 +00001522 return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1523 // Consider '||', '&&' to have side effects if the LHS or RHS does.
John McCall2de56d12010-08-25 11:45:40 +00001524 case BO_LAnd:
1525 case BO_LOr:
Argyrios Kyrtzidis25973452010-06-30 10:53:14 +00001526 if (!BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx) ||
1527 !BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx))
1528 return false;
1529 break;
John McCallbf0ee352010-02-16 04:10:53 +00001530 }
Chris Lattner026dc962009-02-14 07:37:35 +00001531 if (BO->isAssignmentOp())
1532 return false;
1533 Loc = BO->getOperatorLoc();
1534 R1 = BO->getLHS()->getSourceRange();
1535 R2 = BO->getRHS()->getSourceRange();
1536 return true;
Chris Lattnere7716e62007-12-01 06:07:34 +00001537 }
Chris Lattnereb14fe82007-08-25 02:00:02 +00001538 case CompoundAssignOperatorClass:
Douglas Gregorc6dfe192010-05-08 22:41:50 +00001539 case VAArgExprClass:
Chris Lattner026dc962009-02-14 07:37:35 +00001540 return false;
Reid Spencer5f016e22007-07-11 17:01:13 +00001541
Fariborz Jahanianab38e4b2007-12-01 19:58:28 +00001542 case ConditionalOperatorClass: {
Ted Kremenekfb7cb352011-03-01 20:34:48 +00001543 // If only one of the LHS or RHS is a warning, the operator might
1544 // be being used for control flow. Only warn if both the LHS and
1545 // RHS are warnings.
Fariborz Jahanianab38e4b2007-12-01 19:58:28 +00001546 const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
Ted Kremenekfb7cb352011-03-01 20:34:48 +00001547 if (!Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx))
1548 return false;
1549 if (!Exp->getLHS())
Chris Lattner026dc962009-02-14 07:37:35 +00001550 return true;
Ted Kremenekfb7cb352011-03-01 20:34:48 +00001551 return Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
Fariborz Jahanianab38e4b2007-12-01 19:58:28 +00001552 }
1553
Reid Spencer5f016e22007-07-11 17:01:13 +00001554 case MemberExprClass:
Chris Lattner026dc962009-02-14 07:37:35 +00001555 // If the base pointer or element is to a volatile pointer/field, accessing
1556 // it is a side effect.
Mike Stumpdf317bf2009-11-03 23:25:48 +00001557 if (Ctx.getCanonicalType(getType()).isVolatileQualified())
Chris Lattner026dc962009-02-14 07:37:35 +00001558 return false;
1559 Loc = cast<MemberExpr>(this)->getMemberLoc();
1560 R1 = SourceRange(Loc, Loc);
1561 R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
1562 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00001563
Reid Spencer5f016e22007-07-11 17:01:13 +00001564 case ArraySubscriptExprClass:
1565 // If the base pointer or element is to a volatile pointer/field, accessing
Chris Lattner026dc962009-02-14 07:37:35 +00001566 // it is a side effect.
Mike Stumpdf317bf2009-11-03 23:25:48 +00001567 if (Ctx.getCanonicalType(getType()).isVolatileQualified())
Chris Lattner026dc962009-02-14 07:37:35 +00001568 return false;
1569 Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
1570 R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
1571 R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
1572 return true;
Eli Friedman211f6ad2008-05-27 15:24:04 +00001573
Chandler Carruth9b106832011-08-17 09:49:44 +00001574 case CXXOperatorCallExprClass: {
1575 // We warn about operator== and operator!= even when user-defined operator
1576 // overloads as there is no reasonable way to define these such that they
1577 // have non-trivial, desirable side-effects. See the -Wunused-comparison
1578 // warning: these operators are commonly typo'ed, and so warning on them
1579 // provides additional value as well. If this list is updated,
1580 // DiagnoseUnusedComparison should be as well.
1581 const CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(this);
1582 if (Op->getOperator() == OO_EqualEqual ||
Matt Beaumont-Gay6e521832011-09-19 18:51:20 +00001583 Op->getOperator() == OO_ExclaimEqual) {
1584 Loc = Op->getOperatorLoc();
1585 R1 = Op->getSourceRange();
Chandler Carruth9b106832011-08-17 09:49:44 +00001586 return true;
Matt Beaumont-Gay6e521832011-09-19 18:51:20 +00001587 }
Chandler Carruth9b106832011-08-17 09:49:44 +00001588
1589 // Fallthrough for generic call handling.
1590 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001591 case CallExprClass:
Eli Friedman852871a2009-04-29 16:35:53 +00001592 case CXXMemberCallExprClass: {
Chris Lattner026dc962009-02-14 07:37:35 +00001593 // If this is a direct call, get the callee.
1594 const CallExpr *CE = cast<CallExpr>(this);
Nuno Lopesd20254f2009-12-20 23:11:08 +00001595 if (const Decl *FD = CE->getCalleeDecl()) {
Chris Lattner026dc962009-02-14 07:37:35 +00001596 // If the callee has attribute pure, const, or warn_unused_result, warn
1597 // about it. void foo() { strlen("bar"); } should warn.
Chris Lattnerbc8d42c2009-10-13 04:53:48 +00001598 //
1599 // Note: If new cases are added here, DiagnoseUnusedExprResult should be
1600 // updated to match for QoI.
1601 if (FD->getAttr<WarnUnusedResultAttr>() ||
1602 FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) {
1603 Loc = CE->getCallee()->getLocStart();
1604 R1 = CE->getCallee()->getSourceRange();
Mike Stump1eb44332009-09-09 15:08:12 +00001605
Chris Lattnerbc8d42c2009-10-13 04:53:48 +00001606 if (unsigned NumArgs = CE->getNumArgs())
1607 R2 = SourceRange(CE->getArg(0)->getLocStart(),
1608 CE->getArg(NumArgs-1)->getLocEnd());
1609 return true;
1610 }
Chris Lattner026dc962009-02-14 07:37:35 +00001611 }
1612 return false;
1613 }
Anders Carlsson58beed92009-11-17 17:11:23 +00001614
1615 case CXXTemporaryObjectExprClass:
1616 case CXXConstructExprClass:
1617 return false;
1618
Fariborz Jahanianf0317742010-03-30 18:22:15 +00001619 case ObjCMessageExprClass: {
1620 const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
John McCallf85e1932011-06-15 23:02:42 +00001621 if (Ctx.getLangOptions().ObjCAutoRefCount &&
1622 ME->isInstanceMessage() &&
1623 !ME->getType()->isVoidType() &&
1624 ME->getSelector().getIdentifierInfoForSlot(0) &&
1625 ME->getSelector().getIdentifierInfoForSlot(0)
1626 ->getName().startswith("init")) {
1627 Loc = getExprLoc();
1628 R1 = ME->getSourceRange();
1629 return true;
1630 }
1631
Fariborz Jahanianf0317742010-03-30 18:22:15 +00001632 const ObjCMethodDecl *MD = ME->getMethodDecl();
1633 if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
1634 Loc = getExprLoc();
1635 return true;
1636 }
Chris Lattner026dc962009-02-14 07:37:35 +00001637 return false;
Fariborz Jahanianf0317742010-03-30 18:22:15 +00001638 }
Mike Stump1eb44332009-09-09 15:08:12 +00001639
John McCall12f78a62010-12-02 01:19:52 +00001640 case ObjCPropertyRefExprClass:
Chris Lattner5e94a0d2009-08-16 16:51:50 +00001641 Loc = getExprLoc();
1642 R1 = getSourceRange();
Chris Lattnera50089e2009-08-16 16:45:18 +00001643 return true;
John McCall12f78a62010-12-02 01:19:52 +00001644
Chris Lattner611b2ec2008-07-26 19:51:01 +00001645 case StmtExprClass: {
1646 // Statement exprs don't logically have side effects themselves, but are
1647 // sometimes used in macros in ways that give them a type that is unused.
1648 // For example ({ blah; foo(); }) will end up with a type if foo has a type.
1649 // however, if the result of the stmt expr is dead, we don't want to emit a
1650 // warning.
1651 const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
Argyrios Kyrtzidisd2827af2010-09-19 21:21:10 +00001652 if (!CS->body_empty()) {
Chris Lattner611b2ec2008-07-26 19:51:01 +00001653 if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
Mike Stumpdf317bf2009-11-03 23:25:48 +00001654 return E->isUnusedResultAWarning(Loc, R1, R2, Ctx);
Argyrios Kyrtzidisd2827af2010-09-19 21:21:10 +00001655 if (const LabelStmt *Label = dyn_cast<LabelStmt>(CS->body_back()))
1656 if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt()))
1657 return E->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1658 }
Mike Stump1eb44332009-09-09 15:08:12 +00001659
John McCall0faede62010-03-12 07:11:26 +00001660 if (getType()->isVoidType())
1661 return false;
Chris Lattner026dc962009-02-14 07:37:35 +00001662 Loc = cast<StmtExpr>(this)->getLParenLoc();
1663 R1 = getSourceRange();
1664 return true;
Chris Lattner611b2ec2008-07-26 19:51:01 +00001665 }
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001666 case CStyleCastExprClass:
Chris Lattnerfb846642009-07-28 18:25:28 +00001667 // If this is an explicit cast to void, allow it. People do this when they
1668 // think they know what they're doing :).
Chris Lattner026dc962009-02-14 07:37:35 +00001669 if (getType()->isVoidType())
Chris Lattnerfb846642009-07-28 18:25:28 +00001670 return false;
Chris Lattner026dc962009-02-14 07:37:35 +00001671 Loc = cast<CStyleCastExpr>(this)->getLParenLoc();
1672 R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange();
1673 return true;
Anders Carlsson58beed92009-11-17 17:11:23 +00001674 case CXXFunctionalCastExprClass: {
John McCall0faede62010-03-12 07:11:26 +00001675 if (getType()->isVoidType())
1676 return false;
Anders Carlsson58beed92009-11-17 17:11:23 +00001677 const CastExpr *CE = cast<CastExpr>(this);
Sean Huntc3021132010-05-05 15:23:54 +00001678
Anders Carlsson58beed92009-11-17 17:11:23 +00001679 // If this is a cast to void or a constructor conversion, check the operand.
1680 // Otherwise, the result of the cast is unused.
John McCall2de56d12010-08-25 11:45:40 +00001681 if (CE->getCastKind() == CK_ToVoid ||
1682 CE->getCastKind() == CK_ConstructorConversion)
Mike Stumpdf317bf2009-11-03 23:25:48 +00001683 return (cast<CastExpr>(this)->getSubExpr()
1684 ->isUnusedResultAWarning(Loc, R1, R2, Ctx));
Chris Lattner026dc962009-02-14 07:37:35 +00001685 Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc();
1686 R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange();
1687 return true;
Anders Carlsson58beed92009-11-17 17:11:23 +00001688 }
Mike Stump1eb44332009-09-09 15:08:12 +00001689
Eli Friedman4be1f472008-05-19 21:24:43 +00001690 case ImplicitCastExprClass:
1691 // Check the operand, since implicit casts are inserted by Sema
Mike Stumpdf317bf2009-11-03 23:25:48 +00001692 return (cast<ImplicitCastExpr>(this)
1693 ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
Eli Friedman4be1f472008-05-19 21:24:43 +00001694
Chris Lattner04421082008-04-08 04:40:51 +00001695 case CXXDefaultArgExprClass:
Mike Stumpdf317bf2009-11-03 23:25:48 +00001696 return (cast<CXXDefaultArgExpr>(this)
1697 ->getExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001698
1699 case CXXNewExprClass:
1700 // FIXME: In theory, there might be new expressions that don't have side
1701 // effects (e.g. a placement new with an uninitialized POD).
1702 case CXXDeleteExprClass:
Chris Lattner026dc962009-02-14 07:37:35 +00001703 return false;
Anders Carlsson2d46eb22009-08-16 04:11:06 +00001704 case CXXBindTemporaryExprClass:
Mike Stumpdf317bf2009-11-03 23:25:48 +00001705 return (cast<CXXBindTemporaryExpr>(this)
1706 ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
John McCall4765fa02010-12-06 08:20:24 +00001707 case ExprWithCleanupsClass:
1708 return (cast<ExprWithCleanups>(this)
Mike Stumpdf317bf2009-11-03 23:25:48 +00001709 ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001710 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001711}
1712
Fariborz Jahanian44baa8a2009-02-22 18:40:18 +00001713/// isOBJCGCCandidate - Check if an expression is objc gc'able.
Fariborz Jahanian7f4f86a2009-09-08 23:38:54 +00001714/// returns true, if it is; false otherwise.
Fariborz Jahanian102e3902009-06-01 21:29:32 +00001715bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const {
Peter Collingbournef111d932011-04-15 00:35:48 +00001716 const Expr *E = IgnoreParens();
1717 switch (E->getStmtClass()) {
Fariborz Jahanian44baa8a2009-02-22 18:40:18 +00001718 default:
1719 return false;
1720 case ObjCIvarRefExprClass:
1721 return true;
Fariborz Jahanian207c5212009-02-23 18:59:50 +00001722 case Expr::UnaryOperatorClass:
Peter Collingbournef111d932011-04-15 00:35:48 +00001723 return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
Fariborz Jahanian44baa8a2009-02-22 18:40:18 +00001724 case ImplicitCastExprClass:
Peter Collingbournef111d932011-04-15 00:35:48 +00001725 return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
Douglas Gregor03e80032011-06-21 17:03:29 +00001726 case MaterializeTemporaryExprClass:
1727 return cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr()
1728 ->isOBJCGCCandidate(Ctx);
Fariborz Jahanian06b89122009-05-05 23:28:21 +00001729 case CStyleCastExprClass:
Peter Collingbournef111d932011-04-15 00:35:48 +00001730 return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
Fariborz Jahaniane3f83492011-09-23 18:57:30 +00001731 case BlockDeclRefExprClass:
Douglas Gregora2813ce2009-10-23 18:54:35 +00001732 case DeclRefExprClass: {
Fariborz Jahaniane3f83492011-09-23 18:57:30 +00001733
1734 const Decl *D;
1735 if (const BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(E))
1736 D = BDRE->getDecl();
1737 else
1738 D = cast<DeclRefExpr>(E)->getDecl();
1739
Fariborz Jahanian102e3902009-06-01 21:29:32 +00001740 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1741 if (VD->hasGlobalStorage())
1742 return true;
1743 QualType T = VD->getType();
Fariborz Jahanian59a53fa2009-09-16 18:09:18 +00001744 // dereferencing to a pointer is always a gc'able candidate,
1745 // unless it is __weak.
Daniel Dunbar7e88a602009-09-17 06:31:17 +00001746 return T->isPointerType() &&
John McCall0953e762009-09-24 19:53:00 +00001747 (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak);
Fariborz Jahanian102e3902009-06-01 21:29:32 +00001748 }
Fariborz Jahanian44baa8a2009-02-22 18:40:18 +00001749 return false;
1750 }
Douglas Gregor83f6faf2009-08-31 23:41:50 +00001751 case MemberExprClass: {
Peter Collingbournef111d932011-04-15 00:35:48 +00001752 const MemberExpr *M = cast<MemberExpr>(E);
Fariborz Jahanian102e3902009-06-01 21:29:32 +00001753 return M->getBase()->isOBJCGCCandidate(Ctx);
Fariborz Jahanian44baa8a2009-02-22 18:40:18 +00001754 }
1755 case ArraySubscriptExprClass:
Peter Collingbournef111d932011-04-15 00:35:48 +00001756 return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx);
Fariborz Jahanian44baa8a2009-02-22 18:40:18 +00001757 }
1758}
Sebastian Redl369e51f2010-09-10 20:55:33 +00001759
Argyrios Kyrtzidis11ab7902010-11-01 18:49:26 +00001760bool Expr::isBoundMemberFunction(ASTContext &Ctx) const {
1761 if (isTypeDependent())
1762 return false;
John McCall7eb0a9e2010-11-24 05:12:34 +00001763 return ClassifyLValue(Ctx) == Expr::LV_MemberFunction;
Argyrios Kyrtzidis11ab7902010-11-01 18:49:26 +00001764}
1765
John McCall864c0412011-04-26 20:42:42 +00001766QualType Expr::findBoundMemberType(const Expr *expr) {
1767 assert(expr->getType()->isSpecificPlaceholderType(BuiltinType::BoundMember));
1768
1769 // Bound member expressions are always one of these possibilities:
1770 // x->m x.m x->*y x.*y
1771 // (possibly parenthesized)
1772
1773 expr = expr->IgnoreParens();
1774 if (const MemberExpr *mem = dyn_cast<MemberExpr>(expr)) {
1775 assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
1776 return mem->getMemberDecl()->getType();
1777 }
1778
1779 if (const BinaryOperator *op = dyn_cast<BinaryOperator>(expr)) {
1780 QualType type = op->getRHS()->getType()->castAs<MemberPointerType>()
1781 ->getPointeeType();
1782 assert(type->isFunctionType());
1783 return type;
1784 }
1785
1786 assert(isa<UnresolvedMemberExpr>(expr));
1787 return QualType();
1788}
1789
Sebastian Redl369e51f2010-09-10 20:55:33 +00001790static Expr::CanThrowResult MergeCanThrow(Expr::CanThrowResult CT1,
1791 Expr::CanThrowResult CT2) {
1792 // CanThrowResult constants are ordered so that the maximum is the correct
1793 // merge result.
1794 return CT1 > CT2 ? CT1 : CT2;
1795}
1796
1797static Expr::CanThrowResult CanSubExprsThrow(ASTContext &C, const Expr *CE) {
1798 Expr *E = const_cast<Expr*>(CE);
1799 Expr::CanThrowResult R = Expr::CT_Cannot;
John McCall7502c1d2011-02-13 04:07:26 +00001800 for (Expr::child_range I = E->children(); I && R != Expr::CT_Can; ++I) {
Sebastian Redl369e51f2010-09-10 20:55:33 +00001801 R = MergeCanThrow(R, cast<Expr>(*I)->CanThrow(C));
1802 }
1803 return R;
1804}
1805
Richard Smith7a614d82011-06-11 17:19:42 +00001806static Expr::CanThrowResult CanCalleeThrow(ASTContext &Ctx, const Expr *E,
1807 const Decl *D,
Sebastian Redl369e51f2010-09-10 20:55:33 +00001808 bool NullThrows = true) {
1809 if (!D)
1810 return NullThrows ? Expr::CT_Can : Expr::CT_Cannot;
1811
1812 // See if we can get a function type from the decl somehow.
1813 const ValueDecl *VD = dyn_cast<ValueDecl>(D);
1814 if (!VD) // If we have no clue what we're calling, assume the worst.
1815 return Expr::CT_Can;
1816
Sebastian Redl5221d8f2010-09-10 22:34:40 +00001817 // As an extension, we assume that __attribute__((nothrow)) functions don't
1818 // throw.
1819 if (isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
1820 return Expr::CT_Cannot;
1821
Sebastian Redl369e51f2010-09-10 20:55:33 +00001822 QualType T = VD->getType();
1823 const FunctionProtoType *FT;
1824 if ((FT = T->getAs<FunctionProtoType>())) {
1825 } else if (const PointerType *PT = T->getAs<PointerType>())
1826 FT = PT->getPointeeType()->getAs<FunctionProtoType>();
1827 else if (const ReferenceType *RT = T->getAs<ReferenceType>())
1828 FT = RT->getPointeeType()->getAs<FunctionProtoType>();
1829 else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
1830 FT = MT->getPointeeType()->getAs<FunctionProtoType>();
1831 else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
1832 FT = BT->getPointeeType()->getAs<FunctionProtoType>();
1833
1834 if (!FT)
1835 return Expr::CT_Can;
1836
Richard Smith7a614d82011-06-11 17:19:42 +00001837 if (FT->getExceptionSpecType() == EST_Delayed) {
1838 assert(isa<CXXConstructorDecl>(D) &&
1839 "only constructor exception specs can be unknown");
1840 Ctx.getDiagnostics().Report(E->getLocStart(),
1841 diag::err_exception_spec_unknown)
1842 << E->getSourceRange();
1843 return Expr::CT_Can;
1844 }
1845
Sebastian Redl8026f6d2011-03-13 17:09:40 +00001846 return FT->isNothrow(Ctx) ? Expr::CT_Cannot : Expr::CT_Can;
Sebastian Redl369e51f2010-09-10 20:55:33 +00001847}
1848
1849static Expr::CanThrowResult CanDynamicCastThrow(const CXXDynamicCastExpr *DC) {
1850 if (DC->isTypeDependent())
1851 return Expr::CT_Dependent;
1852
Sebastian Redl295995c2010-09-10 20:55:47 +00001853 if (!DC->getTypeAsWritten()->isReferenceType())
1854 return Expr::CT_Cannot;
1855
Eli Friedmanbe57cf42011-05-11 05:22:44 +00001856 if (DC->getSubExpr()->isTypeDependent())
1857 return Expr::CT_Dependent;
1858
Sebastian Redl369e51f2010-09-10 20:55:33 +00001859 return DC->getCastKind() == clang::CK_Dynamic? Expr::CT_Can : Expr::CT_Cannot;
1860}
1861
1862static Expr::CanThrowResult CanTypeidThrow(ASTContext &C,
1863 const CXXTypeidExpr *DC) {
1864 if (DC->isTypeOperand())
1865 return Expr::CT_Cannot;
1866
1867 Expr *Op = DC->getExprOperand();
1868 if (Op->isTypeDependent())
1869 return Expr::CT_Dependent;
1870
1871 const RecordType *RT = Op->getType()->getAs<RecordType>();
1872 if (!RT)
1873 return Expr::CT_Cannot;
1874
1875 if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
1876 return Expr::CT_Cannot;
1877
1878 if (Op->Classify(C).isPRValue())
1879 return Expr::CT_Cannot;
1880
1881 return Expr::CT_Can;
1882}
1883
1884Expr::CanThrowResult Expr::CanThrow(ASTContext &C) const {
1885 // C++ [expr.unary.noexcept]p3:
1886 // [Can throw] if in a potentially-evaluated context the expression would
1887 // contain:
1888 switch (getStmtClass()) {
1889 case CXXThrowExprClass:
1890 // - a potentially evaluated throw-expression
1891 return CT_Can;
1892
1893 case CXXDynamicCastExprClass: {
1894 // - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1895 // where T is a reference type, that requires a run-time check
1896 CanThrowResult CT = CanDynamicCastThrow(cast<CXXDynamicCastExpr>(this));
1897 if (CT == CT_Can)
1898 return CT;
1899 return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1900 }
1901
1902 case CXXTypeidExprClass:
1903 // - a potentially evaluated typeid expression applied to a glvalue
1904 // expression whose type is a polymorphic class type
1905 return CanTypeidThrow(C, cast<CXXTypeidExpr>(this));
1906
1907 // - a potentially evaluated call to a function, member function, function
1908 // pointer, or member function pointer that does not have a non-throwing
1909 // exception-specification
1910 case CallExprClass:
1911 case CXXOperatorCallExprClass:
1912 case CXXMemberCallExprClass: {
Eli Friedmanebc93e1762011-05-12 02:11:32 +00001913 const CallExpr *CE = cast<CallExpr>(this);
Eli Friedmanbe57cf42011-05-11 05:22:44 +00001914 CanThrowResult CT;
1915 if (isTypeDependent())
1916 CT = CT_Dependent;
Eli Friedmanebc93e1762011-05-12 02:11:32 +00001917 else if (isa<CXXPseudoDestructorExpr>(CE->getCallee()->IgnoreParens()))
1918 CT = CT_Cannot;
Eli Friedmanbe57cf42011-05-11 05:22:44 +00001919 else
Richard Smith7a614d82011-06-11 17:19:42 +00001920 CT = CanCalleeThrow(C, this, CE->getCalleeDecl());
Sebastian Redl369e51f2010-09-10 20:55:33 +00001921 if (CT == CT_Can)
1922 return CT;
1923 return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1924 }
1925
Sebastian Redl295995c2010-09-10 20:55:47 +00001926 case CXXConstructExprClass:
1927 case CXXTemporaryObjectExprClass: {
Richard Smith7a614d82011-06-11 17:19:42 +00001928 CanThrowResult CT = CanCalleeThrow(C, this,
Sebastian Redl369e51f2010-09-10 20:55:33 +00001929 cast<CXXConstructExpr>(this)->getConstructor());
1930 if (CT == CT_Can)
1931 return CT;
1932 return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1933 }
1934
1935 case CXXNewExprClass: {
Eli Friedmanbe57cf42011-05-11 05:22:44 +00001936 CanThrowResult CT;
1937 if (isTypeDependent())
1938 CT = CT_Dependent;
1939 else
1940 CT = MergeCanThrow(
Richard Smith7a614d82011-06-11 17:19:42 +00001941 CanCalleeThrow(C, this, cast<CXXNewExpr>(this)->getOperatorNew()),
1942 CanCalleeThrow(C, this, cast<CXXNewExpr>(this)->getConstructor(),
Sebastian Redl369e51f2010-09-10 20:55:33 +00001943 /*NullThrows*/false));
1944 if (CT == CT_Can)
1945 return CT;
1946 return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1947 }
1948
1949 case CXXDeleteExprClass: {
Eli Friedmanbe57cf42011-05-11 05:22:44 +00001950 CanThrowResult CT;
1951 QualType DTy = cast<CXXDeleteExpr>(this)->getDestroyedType();
1952 if (DTy.isNull() || DTy->isDependentType()) {
1953 CT = CT_Dependent;
1954 } else {
Richard Smith7a614d82011-06-11 17:19:42 +00001955 CT = CanCalleeThrow(C, this,
1956 cast<CXXDeleteExpr>(this)->getOperatorDelete());
Eli Friedmanbe57cf42011-05-11 05:22:44 +00001957 if (const RecordType *RT = DTy->getAs<RecordType>()) {
1958 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
Richard Smith7a614d82011-06-11 17:19:42 +00001959 CT = MergeCanThrow(CT, CanCalleeThrow(C, this, RD->getDestructor()));
Sebastian Redl0b34cf72010-09-10 23:27:10 +00001960 }
Eli Friedmanbe57cf42011-05-11 05:22:44 +00001961 if (CT == CT_Can)
1962 return CT;
Sebastian Redl0b34cf72010-09-10 23:27:10 +00001963 }
1964 return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1965 }
1966
1967 case CXXBindTemporaryExprClass: {
1968 // The bound temporary has to be destroyed again, which might throw.
Richard Smith7a614d82011-06-11 17:19:42 +00001969 CanThrowResult CT = CanCalleeThrow(C, this,
Sebastian Redl0b34cf72010-09-10 23:27:10 +00001970 cast<CXXBindTemporaryExpr>(this)->getTemporary()->getDestructor());
1971 if (CT == CT_Can)
1972 return CT;
Sebastian Redl369e51f2010-09-10 20:55:33 +00001973 return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1974 }
1975
1976 // ObjC message sends are like function calls, but never have exception
1977 // specs.
1978 case ObjCMessageExprClass:
1979 case ObjCPropertyRefExprClass:
Sebastian Redl369e51f2010-09-10 20:55:33 +00001980 return CT_Can;
1981
1982 // Many other things have subexpressions, so we have to test those.
1983 // Some are simple:
1984 case ParenExprClass:
1985 case MemberExprClass:
1986 case CXXReinterpretCastExprClass:
1987 case CXXConstCastExprClass:
1988 case ConditionalOperatorClass:
1989 case CompoundLiteralExprClass:
1990 case ExtVectorElementExprClass:
1991 case InitListExprClass:
1992 case DesignatedInitExprClass:
1993 case ParenListExprClass:
1994 case VAArgExprClass:
1995 case CXXDefaultArgExprClass:
John McCall4765fa02010-12-06 08:20:24 +00001996 case ExprWithCleanupsClass:
Sebastian Redl369e51f2010-09-10 20:55:33 +00001997 case ObjCIvarRefExprClass:
1998 case ObjCIsaExprClass:
1999 case ShuffleVectorExprClass:
2000 return CanSubExprsThrow(C, this);
2001
2002 // Some might be dependent for other reasons.
2003 case UnaryOperatorClass:
2004 case ArraySubscriptExprClass:
2005 case ImplicitCastExprClass:
2006 case CStyleCastExprClass:
2007 case CXXStaticCastExprClass:
2008 case CXXFunctionalCastExprClass:
2009 case BinaryOperatorClass:
Douglas Gregor03e80032011-06-21 17:03:29 +00002010 case CompoundAssignOperatorClass:
2011 case MaterializeTemporaryExprClass: {
Sebastian Redl369e51f2010-09-10 20:55:33 +00002012 CanThrowResult CT = isTypeDependent() ? CT_Dependent : CT_Cannot;
2013 return MergeCanThrow(CT, CanSubExprsThrow(C, this));
2014 }
2015
2016 // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms.
2017 case StmtExprClass:
2018 return CT_Can;
2019
2020 case ChooseExprClass:
2021 if (isTypeDependent() || isValueDependent())
2022 return CT_Dependent;
2023 return cast<ChooseExpr>(this)->getChosenSubExpr(C)->CanThrow(C);
2024
Peter Collingbournef111d932011-04-15 00:35:48 +00002025 case GenericSelectionExprClass:
2026 if (cast<GenericSelectionExpr>(this)->isResultDependent())
2027 return CT_Dependent;
2028 return cast<GenericSelectionExpr>(this)->getResultExpr()->CanThrow(C);
2029
Sebastian Redl369e51f2010-09-10 20:55:33 +00002030 // Some expressions are always dependent.
2031 case DependentScopeDeclRefExprClass:
2032 case CXXUnresolvedConstructExprClass:
2033 case CXXDependentScopeMemberExprClass:
2034 return CT_Dependent;
2035
2036 default:
2037 // All other expressions don't have subexpressions, or else they are
2038 // unevaluated.
2039 return CT_Cannot;
2040 }
2041}
2042
Ted Kremenek4e99a5f2008-01-17 16:57:34 +00002043Expr* Expr::IgnoreParens() {
2044 Expr* E = this;
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002045 while (true) {
2046 if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
2047 E = P->getSubExpr();
2048 continue;
2049 }
2050 if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2051 if (P->getOpcode() == UO_Extension) {
2052 E = P->getSubExpr();
2053 continue;
2054 }
2055 }
Peter Collingbournef111d932011-04-15 00:35:48 +00002056 if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2057 if (!P->isResultDependent()) {
2058 E = P->getResultExpr();
2059 continue;
2060 }
2061 }
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002062 return E;
2063 }
Ted Kremenek4e99a5f2008-01-17 16:57:34 +00002064}
2065
Chris Lattner56f34942008-02-13 01:02:39 +00002066/// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr
2067/// or CastExprs or ImplicitCastExprs, returning their operand.
2068Expr *Expr::IgnoreParenCasts() {
2069 Expr *E = this;
2070 while (true) {
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002071 if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
Chris Lattner56f34942008-02-13 01:02:39 +00002072 E = P->getSubExpr();
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002073 continue;
2074 }
2075 if (CastExpr *P = dyn_cast<CastExpr>(E)) {
Chris Lattner56f34942008-02-13 01:02:39 +00002076 E = P->getSubExpr();
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002077 continue;
2078 }
2079 if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2080 if (P->getOpcode() == UO_Extension) {
2081 E = P->getSubExpr();
2082 continue;
2083 }
2084 }
Peter Collingbournef111d932011-04-15 00:35:48 +00002085 if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2086 if (!P->isResultDependent()) {
2087 E = P->getResultExpr();
2088 continue;
2089 }
2090 }
Douglas Gregor03e80032011-06-21 17:03:29 +00002091 if (MaterializeTemporaryExpr *Materialize
2092 = dyn_cast<MaterializeTemporaryExpr>(E)) {
2093 E = Materialize->GetTemporaryExpr();
2094 continue;
2095 }
Douglas Gregorc0244c52011-09-08 17:56:33 +00002096 if (SubstNonTypeTemplateParmExpr *NTTP
2097 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2098 E = NTTP->getReplacement();
2099 continue;
2100 }
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002101 return E;
Chris Lattner56f34942008-02-13 01:02:39 +00002102 }
2103}
2104
John McCall9c5d70c2010-12-04 08:24:19 +00002105/// IgnoreParenLValueCasts - Ignore parentheses and lvalue-to-rvalue
2106/// casts. This is intended purely as a temporary workaround for code
2107/// that hasn't yet been rewritten to do the right thing about those
2108/// casts, and may disappear along with the last internal use.
John McCallf6a16482010-12-04 03:47:34 +00002109Expr *Expr::IgnoreParenLValueCasts() {
2110 Expr *E = this;
John McCall9c5d70c2010-12-04 08:24:19 +00002111 while (true) {
John McCallf6a16482010-12-04 03:47:34 +00002112 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
2113 E = P->getSubExpr();
2114 continue;
John McCall9c5d70c2010-12-04 08:24:19 +00002115 } else if (CastExpr *P = dyn_cast<CastExpr>(E)) {
John McCallf6a16482010-12-04 03:47:34 +00002116 if (P->getCastKind() == CK_LValueToRValue) {
2117 E = P->getSubExpr();
2118 continue;
2119 }
John McCall9c5d70c2010-12-04 08:24:19 +00002120 } else if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2121 if (P->getOpcode() == UO_Extension) {
2122 E = P->getSubExpr();
2123 continue;
2124 }
Peter Collingbournef111d932011-04-15 00:35:48 +00002125 } else if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2126 if (!P->isResultDependent()) {
2127 E = P->getResultExpr();
2128 continue;
2129 }
Douglas Gregor03e80032011-06-21 17:03:29 +00002130 } else if (MaterializeTemporaryExpr *Materialize
2131 = dyn_cast<MaterializeTemporaryExpr>(E)) {
2132 E = Materialize->GetTemporaryExpr();
2133 continue;
Douglas Gregorc0244c52011-09-08 17:56:33 +00002134 } else if (SubstNonTypeTemplateParmExpr *NTTP
2135 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2136 E = NTTP->getReplacement();
2137 continue;
John McCallf6a16482010-12-04 03:47:34 +00002138 }
2139 break;
2140 }
2141 return E;
2142}
2143
John McCall2fc46bf2010-05-05 22:59:52 +00002144Expr *Expr::IgnoreParenImpCasts() {
2145 Expr *E = this;
2146 while (true) {
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002147 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
John McCall2fc46bf2010-05-05 22:59:52 +00002148 E = P->getSubExpr();
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002149 continue;
2150 }
2151 if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) {
John McCall2fc46bf2010-05-05 22:59:52 +00002152 E = P->getSubExpr();
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002153 continue;
2154 }
2155 if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2156 if (P->getOpcode() == UO_Extension) {
2157 E = P->getSubExpr();
2158 continue;
2159 }
2160 }
Peter Collingbournef111d932011-04-15 00:35:48 +00002161 if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2162 if (!P->isResultDependent()) {
2163 E = P->getResultExpr();
2164 continue;
2165 }
2166 }
Douglas Gregor03e80032011-06-21 17:03:29 +00002167 if (MaterializeTemporaryExpr *Materialize
2168 = dyn_cast<MaterializeTemporaryExpr>(E)) {
2169 E = Materialize->GetTemporaryExpr();
2170 continue;
2171 }
Douglas Gregorc0244c52011-09-08 17:56:33 +00002172 if (SubstNonTypeTemplateParmExpr *NTTP
2173 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2174 E = NTTP->getReplacement();
2175 continue;
2176 }
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002177 return E;
John McCall2fc46bf2010-05-05 22:59:52 +00002178 }
2179}
2180
Hans Wennborg2f072b42011-06-09 17:06:51 +00002181Expr *Expr::IgnoreConversionOperator() {
2182 if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(this)) {
Chandler Carruth14d251c2011-06-21 17:22:09 +00002183 if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl()))
Hans Wennborg2f072b42011-06-09 17:06:51 +00002184 return MCE->getImplicitObjectArgument();
2185 }
2186 return this;
2187}
2188
Chris Lattnerecdd8412009-03-13 17:28:01 +00002189/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
2190/// value (including ptr->int casts of the same size). Strip off any
2191/// ParenExpr or CastExprs, returning their operand.
2192Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
2193 Expr *E = this;
2194 while (true) {
2195 if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
2196 E = P->getSubExpr();
2197 continue;
2198 }
Mike Stump1eb44332009-09-09 15:08:12 +00002199
Chris Lattnerecdd8412009-03-13 17:28:01 +00002200 if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2201 // We ignore integer <-> casts that are of the same width, ptr<->ptr and
Douglas Gregor2ade35e2010-06-16 00:17:44 +00002202 // ptr<->int casts of the same width. We also ignore all identity casts.
Chris Lattnerecdd8412009-03-13 17:28:01 +00002203 Expr *SE = P->getSubExpr();
Mike Stump1eb44332009-09-09 15:08:12 +00002204
Chris Lattnerecdd8412009-03-13 17:28:01 +00002205 if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
2206 E = SE;
2207 continue;
2208 }
Mike Stump1eb44332009-09-09 15:08:12 +00002209
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002210 if ((E->getType()->isPointerType() ||
Douglas Gregor9d3347a2010-06-16 00:35:25 +00002211 E->getType()->isIntegralType(Ctx)) &&
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002212 (SE->getType()->isPointerType() ||
Douglas Gregor9d3347a2010-06-16 00:35:25 +00002213 SE->getType()->isIntegralType(Ctx)) &&
Chris Lattnerecdd8412009-03-13 17:28:01 +00002214 Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
2215 E = SE;
2216 continue;
2217 }
2218 }
Mike Stump1eb44332009-09-09 15:08:12 +00002219
Abramo Bagnarab9eb35c2010-10-15 07:51:18 +00002220 if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2221 if (P->getOpcode() == UO_Extension) {
2222 E = P->getSubExpr();
2223 continue;
2224 }
2225 }
2226
Peter Collingbournef111d932011-04-15 00:35:48 +00002227 if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2228 if (!P->isResultDependent()) {
2229 E = P->getResultExpr();
2230 continue;
2231 }
2232 }
2233
Douglas Gregorc0244c52011-09-08 17:56:33 +00002234 if (SubstNonTypeTemplateParmExpr *NTTP
2235 = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2236 E = NTTP->getReplacement();
2237 continue;
2238 }
2239
Chris Lattnerecdd8412009-03-13 17:28:01 +00002240 return E;
2241 }
2242}
2243
Douglas Gregor6eef5192009-12-14 19:27:10 +00002244bool Expr::isDefaultArgument() const {
2245 const Expr *E = this;
Douglas Gregor03e80032011-06-21 17:03:29 +00002246 if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
2247 E = M->GetTemporaryExpr();
2248
Douglas Gregor6eef5192009-12-14 19:27:10 +00002249 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
2250 E = ICE->getSubExprAsWritten();
Sean Huntc3021132010-05-05 15:23:54 +00002251
Douglas Gregor6eef5192009-12-14 19:27:10 +00002252 return isa<CXXDefaultArgExpr>(E);
2253}
Chris Lattnerecdd8412009-03-13 17:28:01 +00002254
Douglas Gregor2f599792010-04-02 18:24:57 +00002255/// \brief Skip over any no-op casts and any temporary-binding
2256/// expressions.
Anders Carlssonf8b30152010-11-28 16:40:49 +00002257static const Expr *skipTemporaryBindingsNoOpCastsAndParens(const Expr *E) {
Douglas Gregor03e80032011-06-21 17:03:29 +00002258 if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
2259 E = M->GetTemporaryExpr();
2260
Douglas Gregor2f599792010-04-02 18:24:57 +00002261 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
John McCall2de56d12010-08-25 11:45:40 +00002262 if (ICE->getCastKind() == CK_NoOp)
Douglas Gregor2f599792010-04-02 18:24:57 +00002263 E = ICE->getSubExpr();
2264 else
2265 break;
2266 }
2267
2268 while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
2269 E = BE->getSubExpr();
2270
2271 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
John McCall2de56d12010-08-25 11:45:40 +00002272 if (ICE->getCastKind() == CK_NoOp)
Douglas Gregor2f599792010-04-02 18:24:57 +00002273 E = ICE->getSubExpr();
2274 else
2275 break;
2276 }
Anders Carlssonf8b30152010-11-28 16:40:49 +00002277
2278 return E->IgnoreParens();
Douglas Gregor2f599792010-04-02 18:24:57 +00002279}
2280
John McCall558d2ab2010-09-15 10:14:12 +00002281/// isTemporaryObject - Determines if this expression produces a
2282/// temporary of the given class type.
2283bool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const {
2284 if (!C.hasSameUnqualifiedType(getType(), C.getTypeDeclType(TempTy)))
2285 return false;
2286
Anders Carlssonf8b30152010-11-28 16:40:49 +00002287 const Expr *E = skipTemporaryBindingsNoOpCastsAndParens(this);
Douglas Gregor2f599792010-04-02 18:24:57 +00002288
John McCall58277b52010-09-15 20:59:13 +00002289 // Temporaries are by definition pr-values of class type.
Fariborz Jahaniandb148be2010-09-27 17:30:38 +00002290 if (!E->Classify(C).isPRValue()) {
2291 // In this context, property reference is a message call and is pr-value.
John McCall12f78a62010-12-02 01:19:52 +00002292 if (!isa<ObjCPropertyRefExpr>(E))
Fariborz Jahaniandb148be2010-09-27 17:30:38 +00002293 return false;
2294 }
Douglas Gregor2f599792010-04-02 18:24:57 +00002295
John McCall19e60ad2010-09-16 06:57:56 +00002296 // Black-list a few cases which yield pr-values of class type that don't
2297 // refer to temporaries of that type:
2298
2299 // - implicit derived-to-base conversions
John McCall558d2ab2010-09-15 10:14:12 +00002300 if (isa<ImplicitCastExpr>(E)) {
2301 switch (cast<ImplicitCastExpr>(E)->getCastKind()) {
2302 case CK_DerivedToBase:
2303 case CK_UncheckedDerivedToBase:
2304 return false;
2305 default:
2306 break;
2307 }
Douglas Gregor2f599792010-04-02 18:24:57 +00002308 }
2309
John McCall19e60ad2010-09-16 06:57:56 +00002310 // - member expressions (all)
2311 if (isa<MemberExpr>(E))
2312 return false;
2313
John McCall56ca35d2011-02-17 10:25:35 +00002314 // - opaque values (all)
2315 if (isa<OpaqueValueExpr>(E))
2316 return false;
2317
John McCall558d2ab2010-09-15 10:14:12 +00002318 return true;
Douglas Gregor2f599792010-04-02 18:24:57 +00002319}
2320
Douglas Gregor75e85042011-03-02 21:06:53 +00002321bool Expr::isImplicitCXXThis() const {
2322 const Expr *E = this;
2323
2324 // Strip away parentheses and casts we don't care about.
2325 while (true) {
2326 if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) {
2327 E = Paren->getSubExpr();
2328 continue;
2329 }
2330
2331 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2332 if (ICE->getCastKind() == CK_NoOp ||
2333 ICE->getCastKind() == CK_LValueToRValue ||
2334 ICE->getCastKind() == CK_DerivedToBase ||
2335 ICE->getCastKind() == CK_UncheckedDerivedToBase) {
2336 E = ICE->getSubExpr();
2337 continue;
2338 }
2339 }
2340
2341 if (const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
2342 if (UnOp->getOpcode() == UO_Extension) {
2343 E = UnOp->getSubExpr();
2344 continue;
2345 }
2346 }
2347
Douglas Gregor03e80032011-06-21 17:03:29 +00002348 if (const MaterializeTemporaryExpr *M
2349 = dyn_cast<MaterializeTemporaryExpr>(E)) {
2350 E = M->GetTemporaryExpr();
2351 continue;
2352 }
2353
Douglas Gregor75e85042011-03-02 21:06:53 +00002354 break;
2355 }
2356
2357 if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
2358 return This->isImplicit();
2359
2360 return false;
2361}
2362
Douglas Gregor898574e2008-12-05 23:32:09 +00002363/// hasAnyTypeDependentArguments - Determines if any of the expressions
2364/// in Exprs is type-dependent.
2365bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
2366 for (unsigned I = 0; I < NumExprs; ++I)
2367 if (Exprs[I]->isTypeDependent())
2368 return true;
2369
2370 return false;
2371}
2372
2373/// hasAnyValueDependentArguments - Determines if any of the expressions
2374/// in Exprs is value-dependent.
2375bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
2376 for (unsigned I = 0; I < NumExprs; ++I)
2377 if (Exprs[I]->isValueDependent())
2378 return true;
2379
2380 return false;
2381}
2382
John McCall4204f072010-08-02 21:13:48 +00002383bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef) const {
Eli Friedmanc39dc9a2009-01-25 03:12:18 +00002384 // This function is attempting whether an expression is an initializer
2385 // which can be evaluated at compile-time. isEvaluatable handles most
2386 // of the cases, but it can't deal with some initializer-specific
2387 // expressions, and it can't deal with aggregates; we deal with those here,
2388 // and fall back to isEvaluatable for the other cases.
2389
John McCall4204f072010-08-02 21:13:48 +00002390 // If we ever capture reference-binding directly in the AST, we can
2391 // kill the second parameter.
2392
2393 if (IsForRef) {
2394 EvalResult Result;
2395 return EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects;
2396 }
Eli Friedman1f4a6db2009-02-20 02:36:22 +00002397
Anders Carlssone8a32b82008-11-24 05:23:59 +00002398 switch (getStmtClass()) {
Eli Friedmanc39dc9a2009-01-25 03:12:18 +00002399 default: break;
Anders Carlssone8a32b82008-11-24 05:23:59 +00002400 case StringLiteralClass:
Steve Naroff14108da2009-07-10 23:34:53 +00002401 case ObjCStringLiteralClass:
Chris Lattnereaf2bb82009-02-24 22:18:39 +00002402 case ObjCEncodeExprClass:
Anders Carlssone8a32b82008-11-24 05:23:59 +00002403 return true;
John McCallb4b9b152010-08-01 21:51:45 +00002404 case CXXTemporaryObjectExprClass:
2405 case CXXConstructExprClass: {
2406 const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
John McCall4204f072010-08-02 21:13:48 +00002407
2408 // Only if it's
2409 // 1) an application of the trivial default constructor or
John McCallb4b9b152010-08-01 21:51:45 +00002410 if (!CE->getConstructor()->isTrivial()) return false;
John McCall4204f072010-08-02 21:13:48 +00002411 if (!CE->getNumArgs()) return true;
2412
2413 // 2) an elidable trivial copy construction of an operand which is
2414 // itself a constant initializer. Note that we consider the
2415 // operand on its own, *not* as a reference binding.
2416 return CE->isElidable() &&
2417 CE->getArg(0)->isConstantInitializer(Ctx, false);
John McCallb4b9b152010-08-01 21:51:45 +00002418 }
Nate Begeman59b5da62009-01-18 03:20:47 +00002419 case CompoundLiteralExprClass: {
Eli Friedman1f4a6db2009-02-20 02:36:22 +00002420 // This handles gcc's extension that allows global initializers like
2421 // "struct x {int x;} x = (struct x) {};".
2422 // FIXME: This accepts other cases it shouldn't!
Nate Begeman59b5da62009-01-18 03:20:47 +00002423 const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
John McCall4204f072010-08-02 21:13:48 +00002424 return Exp->isConstantInitializer(Ctx, false);
Nate Begeman59b5da62009-01-18 03:20:47 +00002425 }
Anders Carlssone8a32b82008-11-24 05:23:59 +00002426 case InitListExprClass: {
Eli Friedman1f4a6db2009-02-20 02:36:22 +00002427 // FIXME: This doesn't deal with fields with reference types correctly.
2428 // FIXME: This incorrectly allows pointers cast to integers to be assigned
2429 // to bitfields.
Anders Carlssone8a32b82008-11-24 05:23:59 +00002430 const InitListExpr *Exp = cast<InitListExpr>(this);
2431 unsigned numInits = Exp->getNumInits();
2432 for (unsigned i = 0; i < numInits; i++) {
John McCall4204f072010-08-02 21:13:48 +00002433 if (!Exp->getInit(i)->isConstantInitializer(Ctx, false))
Anders Carlssone8a32b82008-11-24 05:23:59 +00002434 return false;
2435 }
Eli Friedmanc39dc9a2009-01-25 03:12:18 +00002436 return true;
Anders Carlssone8a32b82008-11-24 05:23:59 +00002437 }
Douglas Gregor3498bdb2009-01-29 17:44:32 +00002438 case ImplicitValueInitExprClass:
2439 return true;
Chris Lattner3ae9f482009-10-13 07:14:16 +00002440 case ParenExprClass:
John McCall4204f072010-08-02 21:13:48 +00002441 return cast<ParenExpr>(this)->getSubExpr()
2442 ->isConstantInitializer(Ctx, IsForRef);
Peter Collingbournef111d932011-04-15 00:35:48 +00002443 case GenericSelectionExprClass:
2444 if (cast<GenericSelectionExpr>(this)->isResultDependent())
2445 return false;
2446 return cast<GenericSelectionExpr>(this)->getResultExpr()
2447 ->isConstantInitializer(Ctx, IsForRef);
Abramo Bagnara5cadfab2010-09-27 07:13:32 +00002448 case ChooseExprClass:
2449 return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)
2450 ->isConstantInitializer(Ctx, IsForRef);
Eli Friedmanc39dc9a2009-01-25 03:12:18 +00002451 case UnaryOperatorClass: {
2452 const UnaryOperator* Exp = cast<UnaryOperator>(this);
John McCall2de56d12010-08-25 11:45:40 +00002453 if (Exp->getOpcode() == UO_Extension)
John McCall4204f072010-08-02 21:13:48 +00002454 return Exp->getSubExpr()->isConstantInitializer(Ctx, false);
Eli Friedmanc39dc9a2009-01-25 03:12:18 +00002455 break;
2456 }
Chris Lattner3ae9f482009-10-13 07:14:16 +00002457 case BinaryOperatorClass: {
2458 // Special case &&foo - &&bar. It would be nice to generalize this somehow
2459 // but this handles the common case.
2460 const BinaryOperator *Exp = cast<BinaryOperator>(this);
John McCall2de56d12010-08-25 11:45:40 +00002461 if (Exp->getOpcode() == BO_Sub &&
Chris Lattner3ae9f482009-10-13 07:14:16 +00002462 isa<AddrLabelExpr>(Exp->getLHS()->IgnoreParenNoopCasts(Ctx)) &&
2463 isa<AddrLabelExpr>(Exp->getRHS()->IgnoreParenNoopCasts(Ctx)))
2464 return true;
2465 break;
2466 }
John McCall4204f072010-08-02 21:13:48 +00002467 case CXXFunctionalCastExprClass:
John McCallb4b9b152010-08-01 21:51:45 +00002468 case CXXStaticCastExprClass:
Chris Lattner81045d82009-04-21 05:19:11 +00002469 case ImplicitCastExprClass:
Eli Friedmanc39dc9a2009-01-25 03:12:18 +00002470 case CStyleCastExprClass:
2471 // Handle casts with a destination that's a struct or union; this
2472 // deals with both the gcc no-op struct cast extension and the
2473 // cast-to-union extension.
2474 if (getType()->isRecordType())
John McCall4204f072010-08-02 21:13:48 +00002475 return cast<CastExpr>(this)->getSubExpr()
2476 ->isConstantInitializer(Ctx, false);
Sean Huntc3021132010-05-05 15:23:54 +00002477
Chris Lattner430656e2009-10-13 22:12:09 +00002478 // Integer->integer casts can be handled here, which is important for
2479 // things like (int)(&&x-&&y). Scary but true.
2480 if (getType()->isIntegerType() &&
2481 cast<CastExpr>(this)->getSubExpr()->getType()->isIntegerType())
John McCall4204f072010-08-02 21:13:48 +00002482 return cast<CastExpr>(this)->getSubExpr()
2483 ->isConstantInitializer(Ctx, false);
Sean Huntc3021132010-05-05 15:23:54 +00002484
Eli Friedmanc39dc9a2009-01-25 03:12:18 +00002485 break;
Douglas Gregor03e80032011-06-21 17:03:29 +00002486
2487 case MaterializeTemporaryExprClass:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002488 return cast<MaterializeTemporaryExpr>(this)->GetTemporaryExpr()
Douglas Gregor03e80032011-06-21 17:03:29 +00002489 ->isConstantInitializer(Ctx, false);
Anders Carlssone8a32b82008-11-24 05:23:59 +00002490 }
Eli Friedmanc39dc9a2009-01-25 03:12:18 +00002491 return isEvaluatable(Ctx);
Steve Naroff38374b02007-09-02 20:30:18 +00002492}
2493
Chandler Carruth82214a82011-02-18 23:54:50 +00002494/// isNullPointerConstant - C99 6.3.2.3p3 - Return whether this is a null
2495/// pointer constant or not, as well as the specific kind of constant detected.
2496/// Null pointer constants can be integer constant expressions with the
2497/// value zero, casts of zero to void*, nullptr (C++0X), or __null
2498/// (a GNU extension).
2499Expr::NullPointerConstantKind
2500Expr::isNullPointerConstant(ASTContext &Ctx,
2501 NullPointerConstantValueDependence NPC) const {
Douglas Gregorce940492009-09-25 04:25:58 +00002502 if (isValueDependent()) {
2503 switch (NPC) {
2504 case NPC_NeverValueDependent:
David Blaikieb219cfc2011-09-23 05:06:16 +00002505 llvm_unreachable("Unexpected value dependent expression!");
Douglas Gregorce940492009-09-25 04:25:58 +00002506 case NPC_ValueDependentIsNull:
Chandler Carruth82214a82011-02-18 23:54:50 +00002507 if (isTypeDependent() || getType()->isIntegralType(Ctx))
2508 return NPCK_ZeroInteger;
2509 else
2510 return NPCK_NotNull;
Sean Huntc3021132010-05-05 15:23:54 +00002511
Douglas Gregorce940492009-09-25 04:25:58 +00002512 case NPC_ValueDependentIsNotNull:
Chandler Carruth82214a82011-02-18 23:54:50 +00002513 return NPCK_NotNull;
Douglas Gregorce940492009-09-25 04:25:58 +00002514 }
2515 }
Daniel Dunbarf515b222009-09-18 08:46:16 +00002516
Sebastian Redl07779722008-10-31 14:43:28 +00002517 // Strip off a cast to void*, if it exists. Except in C++.
Argyrios Kyrtzidis0835a3c2008-08-18 23:01:59 +00002518 if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
Sebastian Redl6215dee2008-11-04 11:45:54 +00002519 if (!Ctx.getLangOptions().CPlusPlus) {
Sebastian Redl07779722008-10-31 14:43:28 +00002520 // Check that it is a cast to void*.
Ted Kremenek6217b802009-07-29 21:53:49 +00002521 if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
Sebastian Redl07779722008-10-31 14:43:28 +00002522 QualType Pointee = PT->getPointeeType();
John McCall0953e762009-09-24 19:53:00 +00002523 if (!Pointee.hasQualifiers() &&
Sebastian Redl07779722008-10-31 14:43:28 +00002524 Pointee->isVoidType() && // to void*
2525 CE->getSubExpr()->getType()->isIntegerType()) // from int.
Douglas Gregorce940492009-09-25 04:25:58 +00002526 return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
Sebastian Redl07779722008-10-31 14:43:28 +00002527 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002528 }
Steve Naroffaa58f002008-01-14 16:10:57 +00002529 } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
2530 // Ignore the ImplicitCastExpr type entirely.
Douglas Gregorce940492009-09-25 04:25:58 +00002531 return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
Steve Naroffaa58f002008-01-14 16:10:57 +00002532 } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
2533 // Accept ((void*)0) as a null pointer constant, as many other
2534 // implementations do.
Douglas Gregorce940492009-09-25 04:25:58 +00002535 return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
Peter Collingbournef111d932011-04-15 00:35:48 +00002536 } else if (const GenericSelectionExpr *GE =
2537 dyn_cast<GenericSelectionExpr>(this)) {
2538 return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);
Mike Stump1eb44332009-09-09 15:08:12 +00002539 } else if (const CXXDefaultArgExpr *DefaultArg
Chris Lattner8123a952008-04-10 02:22:51 +00002540 = dyn_cast<CXXDefaultArgExpr>(this)) {
Chris Lattner04421082008-04-08 04:40:51 +00002541 // See through default argument expressions
Douglas Gregorce940492009-09-25 04:25:58 +00002542 return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
Douglas Gregor2d8b2732008-11-29 04:51:27 +00002543 } else if (isa<GNUNullExpr>(this)) {
2544 // The GNU __null extension is always a null pointer constant.
Chandler Carruth82214a82011-02-18 23:54:50 +00002545 return NPCK_GNUNull;
Douglas Gregor03e80032011-06-21 17:03:29 +00002546 } else if (const MaterializeTemporaryExpr *M
2547 = dyn_cast<MaterializeTemporaryExpr>(this)) {
2548 return M->GetTemporaryExpr()->isNullPointerConstant(Ctx, NPC);
Steve Naroffaaffbf72008-01-14 02:53:34 +00002549 }
Douglas Gregor2d8b2732008-11-29 04:51:27 +00002550
Sebastian Redl6e8ed162009-05-10 18:38:11 +00002551 // C++0x nullptr_t is always a null pointer constant.
2552 if (getType()->isNullPtrType())
Chandler Carruth82214a82011-02-18 23:54:50 +00002553 return NPCK_CXX0X_nullptr;
Sebastian Redl6e8ed162009-05-10 18:38:11 +00002554
Fariborz Jahanianff3a0782010-09-27 22:42:37 +00002555 if (const RecordType *UT = getType()->getAsUnionType())
2556 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
2557 if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){
2558 const Expr *InitExpr = CLE->getInitializer();
2559 if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
2560 return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC);
2561 }
Steve Naroffaa58f002008-01-14 16:10:57 +00002562 // This expression must be an integer type.
Sean Huntc3021132010-05-05 15:23:54 +00002563 if (!getType()->isIntegerType() ||
Fariborz Jahanian56fc0d12009-10-06 00:09:31 +00002564 (Ctx.getLangOptions().CPlusPlus && getType()->isEnumeralType()))
Chandler Carruth82214a82011-02-18 23:54:50 +00002565 return NPCK_NotNull;
Mike Stump1eb44332009-09-09 15:08:12 +00002566
Reid Spencer5f016e22007-07-11 17:01:13 +00002567 // If we have an integer constant expression, we need to *evaluate* it and
2568 // test for the value 0.
Eli Friedman09de1762009-04-25 22:37:12 +00002569 llvm::APSInt Result;
Chandler Carruth82214a82011-02-18 23:54:50 +00002570 bool IsNull = isIntegerConstantExpr(Result, Ctx) && Result == 0;
2571
2572 return (IsNull ? NPCK_ZeroInteger : NPCK_NotNull);
Reid Spencer5f016e22007-07-11 17:01:13 +00002573}
Steve Naroff31a45842007-07-28 23:10:27 +00002574
John McCallf6a16482010-12-04 03:47:34 +00002575/// \brief If this expression is an l-value for an Objective C
2576/// property, find the underlying property reference expression.
2577const ObjCPropertyRefExpr *Expr::getObjCProperty() const {
2578 const Expr *E = this;
2579 while (true) {
2580 assert((E->getValueKind() == VK_LValue &&
2581 E->getObjectKind() == OK_ObjCProperty) &&
2582 "expression is not a property reference");
2583 E = E->IgnoreParenCasts();
2584 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
2585 if (BO->getOpcode() == BO_Comma) {
2586 E = BO->getRHS();
2587 continue;
2588 }
2589 }
2590
2591 break;
2592 }
2593
2594 return cast<ObjCPropertyRefExpr>(E);
2595}
2596
Douglas Gregor33bbbc52009-05-02 02:18:30 +00002597FieldDecl *Expr::getBitField() {
Douglas Gregor6f4a69a2009-07-06 15:38:40 +00002598 Expr *E = this->IgnoreParens();
Douglas Gregor33bbbc52009-05-02 02:18:30 +00002599
Douglas Gregorde4b1d82010-01-29 19:14:02 +00002600 while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
John McCallf6a16482010-12-04 03:47:34 +00002601 if (ICE->getCastKind() == CK_LValueToRValue ||
2602 (ICE->getValueKind() != VK_RValue && ICE->getCastKind() == CK_NoOp))
Douglas Gregorde4b1d82010-01-29 19:14:02 +00002603 E = ICE->getSubExpr()->IgnoreParens();
2604 else
2605 break;
2606 }
2607
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002608 if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
Douglas Gregor86f19402008-12-20 23:49:58 +00002609 if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
Douglas Gregor33bbbc52009-05-02 02:18:30 +00002610 if (Field->isBitField())
2611 return Field;
2612
Argyrios Kyrtzidis0f279e72010-10-30 19:52:22 +00002613 if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E))
2614 if (FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
2615 if (Field->isBitField())
2616 return Field;
2617
Eli Friedman42068e92011-07-13 02:05:57 +00002618 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) {
Douglas Gregor33bbbc52009-05-02 02:18:30 +00002619 if (BinOp->isAssignmentOp() && BinOp->getLHS())
2620 return BinOp->getLHS()->getBitField();
2621
Eli Friedman42068e92011-07-13 02:05:57 +00002622 if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS())
2623 return BinOp->getRHS()->getBitField();
2624 }
2625
Douglas Gregor33bbbc52009-05-02 02:18:30 +00002626 return 0;
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002627}
2628
Anders Carlsson09380262010-01-31 17:18:49 +00002629bool Expr::refersToVectorElement() const {
2630 const Expr *E = this->IgnoreParens();
Sean Huntc3021132010-05-05 15:23:54 +00002631
Anders Carlsson09380262010-01-31 17:18:49 +00002632 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
John McCall5baba9d2010-08-25 10:28:54 +00002633 if (ICE->getValueKind() != VK_RValue &&
John McCall2de56d12010-08-25 11:45:40 +00002634 ICE->getCastKind() == CK_NoOp)
Anders Carlsson09380262010-01-31 17:18:49 +00002635 E = ICE->getSubExpr()->IgnoreParens();
2636 else
2637 break;
2638 }
Sean Huntc3021132010-05-05 15:23:54 +00002639
Anders Carlsson09380262010-01-31 17:18:49 +00002640 if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
2641 return ASE->getBase()->getType()->isVectorType();
2642
2643 if (isa<ExtVectorElementExpr>(E))
2644 return true;
2645
2646 return false;
2647}
2648
Chris Lattner2140e902009-02-16 22:14:05 +00002649/// isArrow - Return true if the base expression is a pointer to vector,
2650/// return false if the base expression is a vector.
2651bool ExtVectorElementExpr::isArrow() const {
2652 return getBase()->getType()->isPointerType();
2653}
2654
Nate Begeman213541a2008-04-18 23:10:10 +00002655unsigned ExtVectorElementExpr::getNumElements() const {
John McCall183700f2009-09-21 23:43:11 +00002656 if (const VectorType *VT = getType()->getAs<VectorType>())
Nate Begeman8a997642008-05-09 06:41:27 +00002657 return VT->getNumElements();
2658 return 1;
Chris Lattner4d0ac882007-08-03 16:00:20 +00002659}
2660
Nate Begeman8a997642008-05-09 06:41:27 +00002661/// containsDuplicateElements - Return true if any element access is repeated.
Nate Begeman213541a2008-04-18 23:10:10 +00002662bool ExtVectorElementExpr::containsDuplicateElements() const {
Daniel Dunbara2b34eb2009-10-18 02:09:09 +00002663 // FIXME: Refactor this code to an accessor on the AST node which returns the
2664 // "type" of component access, and share with code below and in Sema.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002665 StringRef Comp = Accessor->getName();
Nate Begeman190d6a22009-01-18 02:01:21 +00002666
2667 // Halving swizzles do not contain duplicate elements.
Daniel Dunbar15027422009-10-17 23:53:04 +00002668 if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")
Nate Begeman190d6a22009-01-18 02:01:21 +00002669 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00002670
Nate Begeman190d6a22009-01-18 02:01:21 +00002671 // Advance past s-char prefix on hex swizzles.
Daniel Dunbar15027422009-10-17 23:53:04 +00002672 if (Comp[0] == 's' || Comp[0] == 'S')
2673 Comp = Comp.substr(1);
Mike Stump1eb44332009-09-09 15:08:12 +00002674
Daniel Dunbar15027422009-10-17 23:53:04 +00002675 for (unsigned i = 0, e = Comp.size(); i != e; ++i)
Chris Lattner5f9e2722011-07-23 10:55:15 +00002676 if (Comp.substr(i + 1).find(Comp[i]) != StringRef::npos)
Steve Narofffec0b492007-07-30 03:29:09 +00002677 return true;
Daniel Dunbar15027422009-10-17 23:53:04 +00002678
Steve Narofffec0b492007-07-30 03:29:09 +00002679 return false;
2680}
Chris Lattnerb8f849d2007-08-02 23:36:59 +00002681
Nate Begeman8a997642008-05-09 06:41:27 +00002682/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
Nate Begeman3b8d1162008-05-13 21:03:02 +00002683void ExtVectorElementExpr::getEncodedElementAccess(
Chris Lattner5f9e2722011-07-23 10:55:15 +00002684 SmallVectorImpl<unsigned> &Elts) const {
2685 StringRef Comp = Accessor->getName();
Daniel Dunbar4b55b242009-10-18 02:09:31 +00002686 if (Comp[0] == 's' || Comp[0] == 'S')
2687 Comp = Comp.substr(1);
Mike Stump1eb44332009-09-09 15:08:12 +00002688
Daniel Dunbar4b55b242009-10-18 02:09:31 +00002689 bool isHi = Comp == "hi";
2690 bool isLo = Comp == "lo";
2691 bool isEven = Comp == "even";
2692 bool isOdd = Comp == "odd";
Mike Stump1eb44332009-09-09 15:08:12 +00002693
Nate Begeman8a997642008-05-09 06:41:27 +00002694 for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
2695 uint64_t Index;
Mike Stump1eb44332009-09-09 15:08:12 +00002696
Nate Begeman8a997642008-05-09 06:41:27 +00002697 if (isHi)
2698 Index = e + i;
2699 else if (isLo)
2700 Index = i;
2701 else if (isEven)
2702 Index = 2 * i;
2703 else if (isOdd)
2704 Index = 2 * i + 1;
2705 else
Daniel Dunbar4b55b242009-10-18 02:09:31 +00002706 Index = ExtVectorType::getAccessorIdx(Comp[i]);
Chris Lattnerb8f849d2007-08-02 23:36:59 +00002707
Nate Begeman3b8d1162008-05-13 21:03:02 +00002708 Elts.push_back(Index);
Chris Lattnerb8f849d2007-08-02 23:36:59 +00002709 }
Nate Begeman8a997642008-05-09 06:41:27 +00002710}
2711
Douglas Gregor04badcf2010-04-21 00:45:42 +00002712ObjCMessageExpr::ObjCMessageExpr(QualType T,
John McCallf89e55a2010-11-18 06:31:45 +00002713 ExprValueKind VK,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002714 SourceLocation LBracLoc,
2715 SourceLocation SuperLoc,
2716 bool IsInstanceSuper,
2717 QualType SuperType,
Sean Huntc3021132010-05-05 15:23:54 +00002718 Selector Sel,
Argyrios Kyrtzidisf40f0d52010-12-10 20:08:27 +00002719 SourceLocation SelLoc,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002720 ObjCMethodDecl *Method,
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002721 ArrayRef<Expr *> Args,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002722 SourceLocation RBracLoc)
John McCallf89e55a2010-11-18 06:31:45 +00002723 : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary,
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002724 /*TypeDependent=*/false, /*ValueDependent=*/false,
Douglas Gregor561f8122011-07-01 01:22:09 +00002725 /*InstantiationDependent=*/false,
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002726 /*ContainsUnexpandedParameterPack=*/false),
Argyrios Kyrtzidis04fb8ef2011-10-03 06:36:40 +00002727 Kind(IsInstanceSuper? SuperInstance : SuperClass),
John McCallf85e1932011-06-15 23:02:42 +00002728 HasMethod(Method != 0), IsDelegateInitCall(false), SuperLoc(SuperLoc),
Douglas Gregor04badcf2010-04-21 00:45:42 +00002729 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2730 : Sel.getAsOpaquePtr())),
Argyrios Kyrtzidisf40f0d52010-12-10 20:08:27 +00002731 SelectorLoc(SelLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc)
Douglas Gregorc2350e52010-03-08 16:40:19 +00002732{
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002733 setNumArgs(Args.size());
Douglas Gregor04badcf2010-04-21 00:45:42 +00002734 setReceiverPointer(SuperType.getAsOpaquePtr());
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002735 if (!Args.empty())
2736 std::copy(Args.begin(), Args.end(), getArgs());
Ted Kremenek4df728e2008-06-24 15:50:53 +00002737}
2738
Douglas Gregor04badcf2010-04-21 00:45:42 +00002739ObjCMessageExpr::ObjCMessageExpr(QualType T,
John McCallf89e55a2010-11-18 06:31:45 +00002740 ExprValueKind VK,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002741 SourceLocation LBracLoc,
2742 TypeSourceInfo *Receiver,
Argyrios Kyrtzidisf40f0d52010-12-10 20:08:27 +00002743 Selector Sel,
2744 SourceLocation SelLoc,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002745 ObjCMethodDecl *Method,
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002746 ArrayRef<Expr *> Args,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002747 SourceLocation RBracLoc)
John McCallf89e55a2010-11-18 06:31:45 +00002748 : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(),
Douglas Gregor561f8122011-07-01 01:22:09 +00002749 T->isDependentType(), T->isInstantiationDependentType(),
2750 T->containsUnexpandedParameterPack()),
Argyrios Kyrtzidis04fb8ef2011-10-03 06:36:40 +00002751 Kind(Class),
John McCallf85e1932011-06-15 23:02:42 +00002752 HasMethod(Method != 0), IsDelegateInitCall(false),
Douglas Gregor04badcf2010-04-21 00:45:42 +00002753 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2754 : Sel.getAsOpaquePtr())),
Argyrios Kyrtzidisf40f0d52010-12-10 20:08:27 +00002755 SelectorLoc(SelLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc)
Douglas Gregor04badcf2010-04-21 00:45:42 +00002756{
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002757 setNumArgs(Args.size());
Douglas Gregor04badcf2010-04-21 00:45:42 +00002758 setReceiverPointer(Receiver);
Douglas Gregoraa165f82011-01-03 19:04:46 +00002759 Expr **MyArgs = getArgs();
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002760 for (unsigned I = 0; I != Args.size(); ++I) {
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002761 if (Args[I]->isTypeDependent())
2762 ExprBits.TypeDependent = true;
2763 if (Args[I]->isValueDependent())
2764 ExprBits.ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +00002765 if (Args[I]->isInstantiationDependent())
2766 ExprBits.InstantiationDependent = true;
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002767 if (Args[I]->containsUnexpandedParameterPack())
2768 ExprBits.ContainsUnexpandedParameterPack = true;
2769
2770 MyArgs[I] = Args[I];
2771 }
Ted Kremenek4df728e2008-06-24 15:50:53 +00002772}
2773
Douglas Gregor04badcf2010-04-21 00:45:42 +00002774ObjCMessageExpr::ObjCMessageExpr(QualType T,
John McCallf89e55a2010-11-18 06:31:45 +00002775 ExprValueKind VK,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002776 SourceLocation LBracLoc,
2777 Expr *Receiver,
Sean Huntc3021132010-05-05 15:23:54 +00002778 Selector Sel,
Argyrios Kyrtzidisf40f0d52010-12-10 20:08:27 +00002779 SourceLocation SelLoc,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002780 ObjCMethodDecl *Method,
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002781 ArrayRef<Expr *> Args,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002782 SourceLocation RBracLoc)
John McCallf89e55a2010-11-18 06:31:45 +00002783 : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, Receiver->isTypeDependent(),
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002784 Receiver->isTypeDependent(),
Douglas Gregor561f8122011-07-01 01:22:09 +00002785 Receiver->isInstantiationDependent(),
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002786 Receiver->containsUnexpandedParameterPack()),
Argyrios Kyrtzidis04fb8ef2011-10-03 06:36:40 +00002787 Kind(Instance),
John McCallf85e1932011-06-15 23:02:42 +00002788 HasMethod(Method != 0), IsDelegateInitCall(false),
Douglas Gregor04badcf2010-04-21 00:45:42 +00002789 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2790 : Sel.getAsOpaquePtr())),
Argyrios Kyrtzidisf40f0d52010-12-10 20:08:27 +00002791 SelectorLoc(SelLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc)
Douglas Gregor04badcf2010-04-21 00:45:42 +00002792{
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002793 setNumArgs(Args.size());
Douglas Gregor04badcf2010-04-21 00:45:42 +00002794 setReceiverPointer(Receiver);
Douglas Gregoraa165f82011-01-03 19:04:46 +00002795 Expr **MyArgs = getArgs();
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002796 for (unsigned I = 0; I != Args.size(); ++I) {
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002797 if (Args[I]->isTypeDependent())
2798 ExprBits.TypeDependent = true;
2799 if (Args[I]->isValueDependent())
2800 ExprBits.ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +00002801 if (Args[I]->isInstantiationDependent())
2802 ExprBits.InstantiationDependent = true;
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002803 if (Args[I]->containsUnexpandedParameterPack())
2804 ExprBits.ContainsUnexpandedParameterPack = true;
2805
2806 MyArgs[I] = Args[I];
2807 }
Chris Lattner0389e6b2009-04-26 00:44:05 +00002808}
2809
Douglas Gregor04badcf2010-04-21 00:45:42 +00002810ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
John McCallf89e55a2010-11-18 06:31:45 +00002811 ExprValueKind VK,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002812 SourceLocation LBracLoc,
2813 SourceLocation SuperLoc,
2814 bool IsInstanceSuper,
2815 QualType SuperType,
Sean Huntc3021132010-05-05 15:23:54 +00002816 Selector Sel,
Argyrios Kyrtzidis95137622011-10-03 06:36:17 +00002817 ArrayRef<SourceLocation> SelLocs,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002818 ObjCMethodDecl *Method,
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002819 ArrayRef<Expr *> Args,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002820 SourceLocation RBracLoc) {
Sean Huntc3021132010-05-05 15:23:54 +00002821 unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002822 Args.size() * sizeof(Expr *);
Douglas Gregor04badcf2010-04-21 00:45:42 +00002823 void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
John McCallf89e55a2010-11-18 06:31:45 +00002824 return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, SuperLoc, IsInstanceSuper,
Argyrios Kyrtzidis95137622011-10-03 06:36:17 +00002825 SuperType, Sel, SelLocs.front(), Method,
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002826 Args, RBracLoc);
Douglas Gregor04badcf2010-04-21 00:45:42 +00002827}
2828
2829ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
John McCallf89e55a2010-11-18 06:31:45 +00002830 ExprValueKind VK,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002831 SourceLocation LBracLoc,
2832 TypeSourceInfo *Receiver,
Sean Huntc3021132010-05-05 15:23:54 +00002833 Selector Sel,
Argyrios Kyrtzidis95137622011-10-03 06:36:17 +00002834 ArrayRef<SourceLocation> SelLocs,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002835 ObjCMethodDecl *Method,
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002836 ArrayRef<Expr *> Args,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002837 SourceLocation RBracLoc) {
Sean Huntc3021132010-05-05 15:23:54 +00002838 unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002839 Args.size() * sizeof(Expr *);
Douglas Gregor04badcf2010-04-21 00:45:42 +00002840 void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
Argyrios Kyrtzidis95137622011-10-03 06:36:17 +00002841 return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel,
2842 SelLocs.front(),
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002843 Method, Args, RBracLoc);
Douglas Gregor04badcf2010-04-21 00:45:42 +00002844}
2845
2846ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
John McCallf89e55a2010-11-18 06:31:45 +00002847 ExprValueKind VK,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002848 SourceLocation LBracLoc,
2849 Expr *Receiver,
Argyrios Kyrtzidisf40f0d52010-12-10 20:08:27 +00002850 Selector Sel,
Argyrios Kyrtzidis95137622011-10-03 06:36:17 +00002851 ArrayRef<SourceLocation> SelLocs,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002852 ObjCMethodDecl *Method,
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002853 ArrayRef<Expr *> Args,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002854 SourceLocation RBracLoc) {
Sean Huntc3021132010-05-05 15:23:54 +00002855 unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002856 Args.size() * sizeof(Expr *);
Douglas Gregor04badcf2010-04-21 00:45:42 +00002857 void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
Argyrios Kyrtzidis95137622011-10-03 06:36:17 +00002858 return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel,
2859 SelLocs.front(),
Argyrios Kyrtzidis8d9ed792011-10-03 06:36:45 +00002860 Method, Args, RBracLoc);
Douglas Gregor04badcf2010-04-21 00:45:42 +00002861}
2862
Sean Huntc3021132010-05-05 15:23:54 +00002863ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(ASTContext &Context,
Douglas Gregor04badcf2010-04-21 00:45:42 +00002864 unsigned NumArgs) {
Sean Huntc3021132010-05-05 15:23:54 +00002865 unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
Douglas Gregor04badcf2010-04-21 00:45:42 +00002866 NumArgs * sizeof(Expr *);
2867 void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2868 return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs);
2869}
Argyrios Kyrtzidise005d192010-12-10 20:08:30 +00002870
2871SourceRange ObjCMessageExpr::getReceiverRange() const {
2872 switch (getReceiverKind()) {
2873 case Instance:
2874 return getInstanceReceiver()->getSourceRange();
2875
2876 case Class:
2877 return getClassReceiverTypeInfo()->getTypeLoc().getSourceRange();
2878
2879 case SuperInstance:
2880 case SuperClass:
2881 return getSuperLoc();
2882 }
2883
2884 return SourceLocation();
2885}
2886
Douglas Gregor04badcf2010-04-21 00:45:42 +00002887Selector ObjCMessageExpr::getSelector() const {
2888 if (HasMethod)
2889 return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod)
2890 ->getSelector();
Sean Huntc3021132010-05-05 15:23:54 +00002891 return Selector(SelectorOrMethod);
Douglas Gregor04badcf2010-04-21 00:45:42 +00002892}
2893
2894ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const {
2895 switch (getReceiverKind()) {
2896 case Instance:
2897 if (const ObjCObjectPointerType *Ptr
2898 = getInstanceReceiver()->getType()->getAs<ObjCObjectPointerType>())
2899 return Ptr->getInterfaceDecl();
2900 break;
2901
2902 case Class:
John McCallc12c5bb2010-05-15 11:32:37 +00002903 if (const ObjCObjectType *Ty
2904 = getClassReceiver()->getAs<ObjCObjectType>())
2905 return Ty->getInterface();
Douglas Gregor04badcf2010-04-21 00:45:42 +00002906 break;
2907
2908 case SuperInstance:
2909 if (const ObjCObjectPointerType *Ptr
2910 = getSuperType()->getAs<ObjCObjectPointerType>())
2911 return Ptr->getInterfaceDecl();
2912 break;
2913
2914 case SuperClass:
Argyrios Kyrtzidisee8a6ca2011-01-25 00:03:48 +00002915 if (const ObjCObjectType *Iface
2916 = getSuperType()->getAs<ObjCObjectType>())
2917 return Iface->getInterface();
Douglas Gregor04badcf2010-04-21 00:45:42 +00002918 break;
2919 }
2920
2921 return 0;
Ted Kremenekeb3b3242010-02-11 22:41:21 +00002922}
Chris Lattner0389e6b2009-04-26 00:44:05 +00002923
Chris Lattner5f9e2722011-07-23 10:55:15 +00002924StringRef ObjCBridgedCastExpr::getBridgeKindName() const {
John McCallf85e1932011-06-15 23:02:42 +00002925 switch (getBridgeKind()) {
2926 case OBC_Bridge:
2927 return "__bridge";
2928 case OBC_BridgeTransfer:
2929 return "__bridge_transfer";
2930 case OBC_BridgeRetained:
2931 return "__bridge_retained";
2932 }
2933
2934 return "__bridge";
2935}
2936
Jay Foad4ba2a172011-01-12 09:06:06 +00002937bool ChooseExpr::isConditionTrue(const ASTContext &C) const {
Eli Friedman9a901bb2009-04-26 19:19:15 +00002938 return getCond()->EvaluateAsInt(C) != 0;
Chris Lattner27437ca2007-10-25 00:29:32 +00002939}
2940
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002941ShuffleVectorExpr::ShuffleVectorExpr(ASTContext &C, Expr **args, unsigned nexpr,
2942 QualType Type, SourceLocation BLoc,
2943 SourceLocation RP)
2944 : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary,
2945 Type->isDependentType(), Type->isDependentType(),
Douglas Gregor561f8122011-07-01 01:22:09 +00002946 Type->isInstantiationDependentType(),
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002947 Type->containsUnexpandedParameterPack()),
2948 BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(nexpr)
2949{
2950 SubExprs = new (C) Stmt*[nexpr];
2951 for (unsigned i = 0; i < nexpr; i++) {
2952 if (args[i]->isTypeDependent())
2953 ExprBits.TypeDependent = true;
2954 if (args[i]->isValueDependent())
2955 ExprBits.ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +00002956 if (args[i]->isInstantiationDependent())
2957 ExprBits.InstantiationDependent = true;
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00002958 if (args[i]->containsUnexpandedParameterPack())
2959 ExprBits.ContainsUnexpandedParameterPack = true;
2960
2961 SubExprs[i] = args[i];
2962 }
2963}
2964
Nate Begeman888376a2009-08-12 02:28:50 +00002965void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs,
2966 unsigned NumExprs) {
2967 if (SubExprs) C.Deallocate(SubExprs);
2968
2969 SubExprs = new (C) Stmt* [NumExprs];
Douglas Gregor94cd5d12009-04-16 00:01:45 +00002970 this->NumExprs = NumExprs;
2971 memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
Mike Stump1eb44332009-09-09 15:08:12 +00002972}
Nate Begeman888376a2009-08-12 02:28:50 +00002973
Peter Collingbournef111d932011-04-15 00:35:48 +00002974GenericSelectionExpr::GenericSelectionExpr(ASTContext &Context,
2975 SourceLocation GenericLoc, Expr *ControllingExpr,
2976 TypeSourceInfo **AssocTypes, Expr **AssocExprs,
2977 unsigned NumAssocs, SourceLocation DefaultLoc,
2978 SourceLocation RParenLoc,
2979 bool ContainsUnexpandedParameterPack,
2980 unsigned ResultIndex)
2981 : Expr(GenericSelectionExprClass,
2982 AssocExprs[ResultIndex]->getType(),
2983 AssocExprs[ResultIndex]->getValueKind(),
2984 AssocExprs[ResultIndex]->getObjectKind(),
2985 AssocExprs[ResultIndex]->isTypeDependent(),
2986 AssocExprs[ResultIndex]->isValueDependent(),
Douglas Gregor561f8122011-07-01 01:22:09 +00002987 AssocExprs[ResultIndex]->isInstantiationDependent(),
Peter Collingbournef111d932011-04-15 00:35:48 +00002988 ContainsUnexpandedParameterPack),
2989 AssocTypes(new (Context) TypeSourceInfo*[NumAssocs]),
2990 SubExprs(new (Context) Stmt*[END_EXPR+NumAssocs]), NumAssocs(NumAssocs),
2991 ResultIndex(ResultIndex), GenericLoc(GenericLoc), DefaultLoc(DefaultLoc),
2992 RParenLoc(RParenLoc) {
2993 SubExprs[CONTROLLING] = ControllingExpr;
2994 std::copy(AssocTypes, AssocTypes+NumAssocs, this->AssocTypes);
2995 std::copy(AssocExprs, AssocExprs+NumAssocs, SubExprs+END_EXPR);
2996}
2997
2998GenericSelectionExpr::GenericSelectionExpr(ASTContext &Context,
2999 SourceLocation GenericLoc, Expr *ControllingExpr,
3000 TypeSourceInfo **AssocTypes, Expr **AssocExprs,
3001 unsigned NumAssocs, SourceLocation DefaultLoc,
3002 SourceLocation RParenLoc,
3003 bool ContainsUnexpandedParameterPack)
3004 : Expr(GenericSelectionExprClass,
3005 Context.DependentTy,
3006 VK_RValue,
3007 OK_Ordinary,
Douglas Gregor561f8122011-07-01 01:22:09 +00003008 /*isTypeDependent=*/true,
3009 /*isValueDependent=*/true,
3010 /*isInstantiationDependent=*/true,
Peter Collingbournef111d932011-04-15 00:35:48 +00003011 ContainsUnexpandedParameterPack),
3012 AssocTypes(new (Context) TypeSourceInfo*[NumAssocs]),
3013 SubExprs(new (Context) Stmt*[END_EXPR+NumAssocs]), NumAssocs(NumAssocs),
3014 ResultIndex(-1U), GenericLoc(GenericLoc), DefaultLoc(DefaultLoc),
3015 RParenLoc(RParenLoc) {
3016 SubExprs[CONTROLLING] = ControllingExpr;
3017 std::copy(AssocTypes, AssocTypes+NumAssocs, this->AssocTypes);
3018 std::copy(AssocExprs, AssocExprs+NumAssocs, SubExprs+END_EXPR);
3019}
3020
Ted Kremenek77ed8e42007-08-24 18:13:47 +00003021//===----------------------------------------------------------------------===//
Douglas Gregor05c13a32009-01-22 00:58:24 +00003022// DesignatedInitExpr
3023//===----------------------------------------------------------------------===//
3024
Chandler Carruthb1138242011-06-16 06:47:06 +00003025IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() const {
Douglas Gregor05c13a32009-01-22 00:58:24 +00003026 assert(Kind == FieldDesignator && "Only valid on a field designator");
3027 if (Field.NameOrField & 0x01)
3028 return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
3029 else
3030 return getField()->getIdentifier();
3031}
3032
Sean Huntc3021132010-05-05 15:23:54 +00003033DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty,
Douglas Gregor319d57f2010-01-06 23:17:19 +00003034 unsigned NumDesignators,
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00003035 const Designator *Designators,
Mike Stump1eb44332009-09-09 15:08:12 +00003036 SourceLocation EqualOrColonLoc,
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00003037 bool GNUSyntax,
Mike Stump1eb44332009-09-09 15:08:12 +00003038 Expr **IndexExprs,
Douglas Gregor9ea62762009-05-21 23:17:49 +00003039 unsigned NumIndexExprs,
3040 Expr *Init)
Mike Stump1eb44332009-09-09 15:08:12 +00003041 : Expr(DesignatedInitExprClass, Ty,
John McCallf89e55a2010-11-18 06:31:45 +00003042 Init->getValueKind(), Init->getObjectKind(),
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003043 Init->isTypeDependent(), Init->isValueDependent(),
Douglas Gregor561f8122011-07-01 01:22:09 +00003044 Init->isInstantiationDependent(),
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003045 Init->containsUnexpandedParameterPack()),
Mike Stump1eb44332009-09-09 15:08:12 +00003046 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
3047 NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) {
Douglas Gregor319d57f2010-01-06 23:17:19 +00003048 this->Designators = new (C) Designator[NumDesignators];
Douglas Gregor9ea62762009-05-21 23:17:49 +00003049
3050 // Record the initializer itself.
John McCall7502c1d2011-02-13 04:07:26 +00003051 child_range Child = children();
Douglas Gregor9ea62762009-05-21 23:17:49 +00003052 *Child++ = Init;
3053
3054 // Copy the designators and their subexpressions, computing
3055 // value-dependence along the way.
3056 unsigned IndexIdx = 0;
3057 for (unsigned I = 0; I != NumDesignators; ++I) {
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00003058 this->Designators[I] = Designators[I];
Douglas Gregor9ea62762009-05-21 23:17:49 +00003059
3060 if (this->Designators[I].isArrayDesignator()) {
3061 // Compute type- and value-dependence.
3062 Expr *Index = IndexExprs[IndexIdx];
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003063 if (Index->isTypeDependent() || Index->isValueDependent())
3064 ExprBits.ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +00003065 if (Index->isInstantiationDependent())
3066 ExprBits.InstantiationDependent = true;
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003067 // Propagate unexpanded parameter packs.
3068 if (Index->containsUnexpandedParameterPack())
3069 ExprBits.ContainsUnexpandedParameterPack = true;
Douglas Gregor9ea62762009-05-21 23:17:49 +00003070
3071 // Copy the index expressions into permanent storage.
3072 *Child++ = IndexExprs[IndexIdx++];
3073 } else if (this->Designators[I].isArrayRangeDesignator()) {
3074 // Compute type- and value-dependence.
3075 Expr *Start = IndexExprs[IndexIdx];
3076 Expr *End = IndexExprs[IndexIdx + 1];
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003077 if (Start->isTypeDependent() || Start->isValueDependent() ||
Douglas Gregor561f8122011-07-01 01:22:09 +00003078 End->isTypeDependent() || End->isValueDependent()) {
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003079 ExprBits.ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +00003080 ExprBits.InstantiationDependent = true;
3081 } else if (Start->isInstantiationDependent() ||
3082 End->isInstantiationDependent()) {
3083 ExprBits.InstantiationDependent = true;
3084 }
3085
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003086 // Propagate unexpanded parameter packs.
3087 if (Start->containsUnexpandedParameterPack() ||
3088 End->containsUnexpandedParameterPack())
3089 ExprBits.ContainsUnexpandedParameterPack = true;
Douglas Gregor9ea62762009-05-21 23:17:49 +00003090
3091 // Copy the start/end expressions into permanent storage.
3092 *Child++ = IndexExprs[IndexIdx++];
3093 *Child++ = IndexExprs[IndexIdx++];
3094 }
3095 }
3096
3097 assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions");
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00003098}
3099
Douglas Gregor05c13a32009-01-22 00:58:24 +00003100DesignatedInitExpr *
Mike Stump1eb44332009-09-09 15:08:12 +00003101DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
Douglas Gregor05c13a32009-01-22 00:58:24 +00003102 unsigned NumDesignators,
3103 Expr **IndexExprs, unsigned NumIndexExprs,
3104 SourceLocation ColonOrEqualLoc,
3105 bool UsesColonSyntax, Expr *Init) {
Steve Naroffc0ac4922009-01-27 23:20:32 +00003106 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
Steve Naroffc0ac4922009-01-27 23:20:32 +00003107 sizeof(Stmt *) * (NumIndexExprs + 1), 8);
Douglas Gregor319d57f2010-01-06 23:17:19 +00003108 return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators,
Douglas Gregor9ea62762009-05-21 23:17:49 +00003109 ColonOrEqualLoc, UsesColonSyntax,
3110 IndexExprs, NumIndexExprs, Init);
Douglas Gregor05c13a32009-01-22 00:58:24 +00003111}
3112
Mike Stump1eb44332009-09-09 15:08:12 +00003113DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
Douglas Gregord077d752009-04-16 00:55:48 +00003114 unsigned NumIndexExprs) {
3115 void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
3116 sizeof(Stmt *) * (NumIndexExprs + 1), 8);
3117 return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
3118}
3119
Douglas Gregor319d57f2010-01-06 23:17:19 +00003120void DesignatedInitExpr::setDesignators(ASTContext &C,
3121 const Designator *Desigs,
Douglas Gregord077d752009-04-16 00:55:48 +00003122 unsigned NumDesigs) {
Douglas Gregor319d57f2010-01-06 23:17:19 +00003123 Designators = new (C) Designator[NumDesigs];
Douglas Gregord077d752009-04-16 00:55:48 +00003124 NumDesignators = NumDesigs;
3125 for (unsigned I = 0; I != NumDesigs; ++I)
3126 Designators[I] = Desigs[I];
3127}
3128
Abramo Bagnara24f46742011-03-16 15:08:46 +00003129SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const {
3130 DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this);
3131 if (size() == 1)
3132 return DIE->getDesignator(0)->getSourceRange();
3133 return SourceRange(DIE->getDesignator(0)->getStartLocation(),
3134 DIE->getDesignator(size()-1)->getEndLocation());
3135}
3136
Douglas Gregor05c13a32009-01-22 00:58:24 +00003137SourceRange DesignatedInitExpr::getSourceRange() const {
3138 SourceLocation StartLoc;
Chris Lattnerd603eaa2009-02-16 22:33:34 +00003139 Designator &First =
3140 *const_cast<DesignatedInitExpr*>(this)->designators_begin();
Douglas Gregor05c13a32009-01-22 00:58:24 +00003141 if (First.isFieldDesignator()) {
Douglas Gregoreeae8f02009-03-28 00:41:23 +00003142 if (GNUSyntax)
Douglas Gregor05c13a32009-01-22 00:58:24 +00003143 StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
3144 else
3145 StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
3146 } else
Chris Lattnerd603eaa2009-02-16 22:33:34 +00003147 StartLoc =
3148 SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
Douglas Gregor05c13a32009-01-22 00:58:24 +00003149 return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
3150}
3151
Douglas Gregor05c13a32009-01-22 00:58:24 +00003152Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
3153 assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
3154 char* Ptr = static_cast<char*>(static_cast<void *>(this));
3155 Ptr += sizeof(DesignatedInitExpr);
Douglas Gregor05c13a32009-01-22 00:58:24 +00003156 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
3157 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
3158}
3159
3160Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
Mike Stump1eb44332009-09-09 15:08:12 +00003161 assert(D.Kind == Designator::ArrayRangeDesignator &&
Douglas Gregor05c13a32009-01-22 00:58:24 +00003162 "Requires array range designator");
3163 char* Ptr = static_cast<char*>(static_cast<void *>(this));
3164 Ptr += sizeof(DesignatedInitExpr);
Douglas Gregor05c13a32009-01-22 00:58:24 +00003165 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
3166 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
3167}
3168
3169Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
Mike Stump1eb44332009-09-09 15:08:12 +00003170 assert(D.Kind == Designator::ArrayRangeDesignator &&
Douglas Gregor05c13a32009-01-22 00:58:24 +00003171 "Requires array range designator");
3172 char* Ptr = static_cast<char*>(static_cast<void *>(this));
3173 Ptr += sizeof(DesignatedInitExpr);
Douglas Gregor05c13a32009-01-22 00:58:24 +00003174 Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
3175 return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
3176}
3177
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00003178/// \brief Replaces the designator at index @p Idx with the series
3179/// of designators in [First, Last).
Douglas Gregor319d57f2010-01-06 23:17:19 +00003180void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx,
Mike Stump1eb44332009-09-09 15:08:12 +00003181 const Designator *First,
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00003182 const Designator *Last) {
3183 unsigned NumNewDesignators = Last - First;
3184 if (NumNewDesignators == 0) {
3185 std::copy_backward(Designators + Idx + 1,
3186 Designators + NumDesignators,
3187 Designators + Idx);
3188 --NumNewDesignators;
3189 return;
3190 } else if (NumNewDesignators == 1) {
3191 Designators[Idx] = *First;
3192 return;
3193 }
3194
Mike Stump1eb44332009-09-09 15:08:12 +00003195 Designator *NewDesignators
Douglas Gregor319d57f2010-01-06 23:17:19 +00003196 = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00003197 std::copy(Designators, Designators + Idx, NewDesignators);
3198 std::copy(First, Last, NewDesignators + Idx);
3199 std::copy(Designators + Idx + 1, Designators + NumDesignators,
3200 NewDesignators + Idx + NumNewDesignators);
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00003201 Designators = NewDesignators;
3202 NumDesignators = NumDesignators - 1 + NumNewDesignators;
3203}
3204
Mike Stump1eb44332009-09-09 15:08:12 +00003205ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc,
Nate Begeman2ef13e52009-08-10 23:49:36 +00003206 Expr **exprs, unsigned nexprs,
Manuel Klimek0d9106f2011-06-22 20:02:16 +00003207 SourceLocation rparenloc, QualType T)
3208 : Expr(ParenListExprClass, T, VK_RValue, OK_Ordinary,
Douglas Gregor561f8122011-07-01 01:22:09 +00003209 false, false, false, false),
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003210 NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) {
Manuel Klimek0d9106f2011-06-22 20:02:16 +00003211 assert(!T.isNull() && "ParenListExpr must have a valid type");
Nate Begeman2ef13e52009-08-10 23:49:36 +00003212 Exprs = new (C) Stmt*[nexprs];
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003213 for (unsigned i = 0; i != nexprs; ++i) {
3214 if (exprs[i]->isTypeDependent())
3215 ExprBits.TypeDependent = true;
3216 if (exprs[i]->isValueDependent())
3217 ExprBits.ValueDependent = true;
Douglas Gregor561f8122011-07-01 01:22:09 +00003218 if (exprs[i]->isInstantiationDependent())
3219 ExprBits.InstantiationDependent = true;
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003220 if (exprs[i]->containsUnexpandedParameterPack())
3221 ExprBits.ContainsUnexpandedParameterPack = true;
3222
Nate Begeman2ef13e52009-08-10 23:49:36 +00003223 Exprs[i] = exprs[i];
Douglas Gregorbebbe0d2010-12-15 01:34:56 +00003224 }
Nate Begeman2ef13e52009-08-10 23:49:36 +00003225}
3226
John McCalle996ffd2011-02-16 08:02:54 +00003227const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) {
3228 if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e))
3229 e = ewc->getSubExpr();
Douglas Gregor03e80032011-06-21 17:03:29 +00003230 if (const MaterializeTemporaryExpr *m = dyn_cast<MaterializeTemporaryExpr>(e))
3231 e = m->GetTemporaryExpr();
John McCalle996ffd2011-02-16 08:02:54 +00003232 e = cast<CXXConstructExpr>(e)->getArg(0);
3233 while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
3234 e = ice->getSubExpr();
3235 return cast<OpaqueValueExpr>(e);
3236}
3237
Douglas Gregor05c13a32009-01-22 00:58:24 +00003238//===----------------------------------------------------------------------===//
Ted Kremenekce2fc3a2008-10-27 18:40:21 +00003239// ExprIterator.
3240//===----------------------------------------------------------------------===//
3241
3242Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
3243Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
3244Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
3245const Expr* ConstExprIterator::operator[](size_t idx) const {
3246 return cast<Expr>(I[idx]);
3247}
3248const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
3249const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
3250
3251//===----------------------------------------------------------------------===//
Ted Kremenek77ed8e42007-08-24 18:13:47 +00003252// Child Iterators for iterating over subexpressions/substatements
3253//===----------------------------------------------------------------------===//
3254
Peter Collingbournef4e3cfb2011-03-11 19:24:49 +00003255// UnaryExprOrTypeTraitExpr
3256Stmt::child_range UnaryExprOrTypeTraitExpr::children() {
Sebastian Redl05189992008-11-11 17:56:53 +00003257 // If this is of a type and the type is a VLA type (and not a typedef), the
3258 // size expression of the VLA needs to be treated as an executable expression.
3259 // Why isn't this weirdness documented better in StmtIterator?
3260 if (isArgumentType()) {
John McCallf4c73712011-01-19 06:33:43 +00003261 if (const VariableArrayType* T = dyn_cast<VariableArrayType>(
Sebastian Redl05189992008-11-11 17:56:53 +00003262 getArgumentType().getTypePtr()))
John McCall63c00d72011-02-09 08:16:59 +00003263 return child_range(child_iterator(T), child_iterator());
3264 return child_range();
Sebastian Redl05189992008-11-11 17:56:53 +00003265 }
John McCall63c00d72011-02-09 08:16:59 +00003266 return child_range(&Argument.Ex, &Argument.Ex + 1);
Ted Kremenek9ac59282007-10-18 23:28:49 +00003267}
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00003268
Steve Naroff563477d2007-09-18 23:55:05 +00003269// ObjCMessageExpr
John McCall63c00d72011-02-09 08:16:59 +00003270Stmt::child_range ObjCMessageExpr::children() {
3271 Stmt **begin;
Douglas Gregor04badcf2010-04-21 00:45:42 +00003272 if (getReceiverKind() == Instance)
John McCall63c00d72011-02-09 08:16:59 +00003273 begin = reinterpret_cast<Stmt **>(this + 1);
3274 else
3275 begin = reinterpret_cast<Stmt **>(getArgs());
3276 return child_range(begin,
3277 reinterpret_cast<Stmt **>(getArgs() + getNumArgs()));
Steve Naroff563477d2007-09-18 23:55:05 +00003278}
3279
Steve Naroff4eb206b2008-09-03 18:15:37 +00003280// Blocks
John McCall6b5a61b2011-02-07 10:33:21 +00003281BlockDeclRefExpr::BlockDeclRefExpr(VarDecl *d, QualType t, ExprValueKind VK,
Douglas Gregora779d9c2011-01-19 21:32:01 +00003282 SourceLocation l, bool ByRef,
John McCall6b5a61b2011-02-07 10:33:21 +00003283 bool constAdded)
Douglas Gregor561f8122011-07-01 01:22:09 +00003284 : Expr(BlockDeclRefExprClass, t, VK, OK_Ordinary, false, false, false,
Douglas Gregora779d9c2011-01-19 21:32:01 +00003285 d->isParameterPack()),
John McCall6b5a61b2011-02-07 10:33:21 +00003286 D(d), Loc(l), IsByRef(ByRef), ConstQualAdded(constAdded)
Douglas Gregora779d9c2011-01-19 21:32:01 +00003287{
Douglas Gregord967e312011-01-19 21:52:31 +00003288 bool TypeDependent = false;
3289 bool ValueDependent = false;
Douglas Gregor561f8122011-07-01 01:22:09 +00003290 bool InstantiationDependent = false;
3291 computeDeclRefDependence(D, getType(), TypeDependent, ValueDependent,
3292 InstantiationDependent);
Douglas Gregord967e312011-01-19 21:52:31 +00003293 ExprBits.TypeDependent = TypeDependent;
3294 ExprBits.ValueDependent = ValueDependent;
Douglas Gregor561f8122011-07-01 01:22:09 +00003295 ExprBits.InstantiationDependent = InstantiationDependent;
Douglas Gregora779d9c2011-01-19 21:32:01 +00003296}