 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
77.8% |
896 / 1152 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
91.5% |
1054 / 1152 |
| |
|
Line Coverage: |
89.2% |
1129 / 1266 |
| |
 |
|
 |
1 : //===--- Expr.cpp - Expression AST Node Implementation --------------------===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // This file implements the Expr class and subclasses.
11 : //
12 : //===----------------------------------------------------------------------===//
13 :
14 : #include "clang/AST/Expr.h"
15 : #include "clang/AST/ExprCXX.h"
16 : #include "clang/AST/APValue.h"
17 : #include "clang/AST/ASTContext.h"
18 : #include "clang/AST/DeclObjC.h"
19 : #include "clang/AST/DeclCXX.h"
20 : #include "clang/AST/DeclTemplate.h"
21 : #include "clang/AST/RecordLayout.h"
22 : #include "clang/AST/StmtVisitor.h"
23 : #include "clang/Basic/Builtins.h"
24 : #include "clang/Basic/TargetInfo.h"
25 : #include "llvm/Support/ErrorHandling.h"
26 : #include "llvm/Support/raw_ostream.h"
27 : #include <algorithm>
28 : using namespace clang;
29 :
30 : //===----------------------------------------------------------------------===//
31 : // Primary Expressions.
32 : //===----------------------------------------------------------------------===//
33 :
34 : void ExplicitTemplateArgumentList::initializeFrom(
35 315: const TemplateArgumentListInfo &Info) {
36 315: LAngleLoc = Info.getLAngleLoc();
37 315: RAngleLoc = Info.getRAngleLoc();
38 315: NumTemplateArgs = Info.size();
39 :
40 315: TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
320: branch 0 taken
315: branch 1 taken
41 635: for (unsigned i = 0; i != NumTemplateArgs; ++i)
320: branch 2 taken
0: branch 3 not taken
42 320: new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
43 315: }
44 :
45 : void ExplicitTemplateArgumentList::copyInto(
46 352: TemplateArgumentListInfo &Info) const {
47 352: Info.setLAngleLoc(LAngleLoc);
48 352: Info.setRAngleLoc(RAngleLoc);
347: branch 0 taken
352: branch 1 taken
49 699: for (unsigned I = 0; I != NumTemplateArgs; ++I)
50 347: Info.addArgument(getTemplateArgs()[I]);
51 352: }
52 :
53 : std::size_t ExplicitTemplateArgumentList::sizeFor(
54 315: const TemplateArgumentListInfo &Info) {
55 : return sizeof(ExplicitTemplateArgumentList) +
56 315: sizeof(TemplateArgumentLoc) * Info.size();
57 : }
58 :
59 39219: void DeclRefExpr::computeDependence() {
60 39219: TypeDependent = false;
61 39219: ValueDependent = false;
62 :
63 39219: NamedDecl *D = getDecl();
64 :
65 : // (TD) C++ [temp.dep.expr]p3:
66 : // An id-expression is type-dependent if it contains:
67 : //
68 : // and
69 : //
70 : // (VD) C++ [temp.dep.constexpr]p2:
71 : // An identifier is value-dependent if it is:
72 :
73 : // (TD) - an identifier that was declared with dependent type
74 : // (VD) - a name declared with a dependent type,
383: branch 3 taken
38836: branch 4 taken
75 39219: if (getType()->isDependentType()) {
76 383: TypeDependent = true;
77 383: ValueDependent = true;
78 : }
79 : // (TD) - a conversion-function-id that specifies a dependent type
9164: branch 2 taken
29672: branch 3 taken
0: branch 8 not taken
9164: branch 9 taken
0: branch 10 not taken
38836: branch 11 taken
80 38836: else if (D->getDeclName().getNameKind()
81 : == DeclarationName::CXXConversionFunctionName &&
82 : D->getDeclName().getCXXNameType()->isDependentType()) {
83 0: TypeDependent = true;
84 0: ValueDependent = true;
85 : }
86 : // (TD) - a template-id that is dependent,
118: branch 1 taken
38718: branch 2 taken
0: branch 6 not taken
118: branch 7 taken
0: branch 8 not taken
38836: branch 9 taken
87 38836: else if (hasExplicitTemplateArgumentList() &&
88 : TemplateSpecializationType::anyDependentTemplateArguments(
89 : getTemplateArgs(),
90 : getNumTemplateArgs())) {
91 0: TypeDependent = true;
92 0: ValueDependent = true;
93 : }
94 : // (VD) - the name of a non-type template parameter,
220: branch 1 taken
38616: branch 2 taken
95 38836: else if (isa<NonTypeTemplateParmDecl>(D))
96 220: ValueDependent = true;
97 : // (VD) - a constant with integral or enumeration type and is
98 : // initialized with an expression that is value-dependent.
22122: branch 1 taken
16494: branch 2 taken
99 38616: else if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
7111: branch 3 taken
15011: branch 4 taken
290: branch 7 taken
6821: branch 8 taken
290: branch 9 taken
21832: branch 10 taken
100 22122: if (Var->getType()->isIntegralType() &&
101 : Var->getType().getCVRQualifiers() == Qualifiers::Const) {
269: branch 1 taken
21: branch 2 taken
102 290: if (const Expr *Init = Var->getAnyInitializer())
2: branch 1 taken
267: branch 2 taken
103 269: if (Init->isValueDependent())
104 2: ValueDependent = true;
105 : }
106 : }
107 : // (TD) - a nested-name-specifier or a qualified-id that names a
108 : // member of an unknown specialization.
109 : // (handled by DependentScopeDeclRefExpr)
110 39219: }
111 :
112 : DeclRefExpr::DeclRefExpr(NestedNameSpecifier *Qualifier,
113 : SourceRange QualifierRange,
114 : ValueDecl *D, SourceLocation NameLoc,
115 : const TemplateArgumentListInfo *TemplateArgs,
116 29371: QualType T)
117 : : Expr(DeclRefExprClass, T, false, false),
118 : DecoratedD(D,
119 : (Qualifier? HasQualifierFlag : 0) |
120 : (TemplateArgs ? HasExplicitTemplateArgumentListFlag : 0)),
904: branch 1 taken
28467: branch 2 taken
118: branch 3 taken
29253: branch 4 taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
0: branch 10 not taken
121 29371: Loc(NameLoc) {
904: branch 0 taken
28467: branch 1 taken
28467: branch 2 taken
28467: branch 3 taken
122 29371: if (Qualifier) {
123 904: NameQualifier *NQ = getNameQualifier();
124 904: NQ->NNS = Qualifier;
125 904: NQ->Range = QualifierRange;
126 : }
127 :
118: branch 0 taken
29253: branch 1 taken
29253: branch 2 taken
29253: branch 3 taken
128 29371: if (TemplateArgs)
129 118: getExplicitTemplateArgumentList()->initializeFrom(*TemplateArgs);
130 :
131 29371: computeDependence();
132 29371: }
133 :
134 : DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
135 : NestedNameSpecifier *Qualifier,
136 : SourceRange QualifierRange,
137 : ValueDecl *D,
138 : SourceLocation NameLoc,
139 : QualType T,
140 29371: const TemplateArgumentListInfo *TemplateArgs) {
141 29371: std::size_t Size = sizeof(DeclRefExpr);
904: branch 0 taken
28467: branch 1 taken
142 29371: if (Qualifier != 0)
143 904: Size += sizeof(NameQualifier);
144 :
118: branch 0 taken
29253: branch 1 taken
145 29371: if (TemplateArgs)
146 118: Size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
147 :
148 29371: void *Mem = Context.Allocate(Size, llvm::alignof<DeclRefExpr>());
149 : return new (Mem) DeclRefExpr(Qualifier, QualifierRange, D, NameLoc,
29371: branch 1 taken
0: branch 2 not taken
150 29371: TemplateArgs, T);
151 : }
152 :
153 187044: SourceRange DeclRefExpr::getSourceRange() const {
154 : // FIXME: Does not handle multi-token names well, e.g., operator[].
155 187044: SourceRange R(Loc);
156 :
1734: branch 1 taken
185310: branch 2 taken
157 187044: if (hasQualifier())
158 1734: R.setBegin(getQualifierRange().getBegin());
477: branch 1 taken
186567: branch 2 taken
159 187044: if (hasExplicitTemplateArgumentList())
160 477: R.setEnd(getRAngleLoc());
161 : return R;
162 : }
163 :
164 : // FIXME: Maybe this should use DeclPrinter with a special "print predefined
165 : // expr" policy instead.
166 : std::string PredefinedExpr::ComputeName(ASTContext &Context, IdentType IT,
167 416: const Decl *CurrentDecl) {
323: branch 1 taken
93: branch 2 taken
168 416: if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
203: branch 0 taken
120: branch 1 taken
169 323: if (IT != PrettyFunction)
170 203: return FD->getNameAsString();
171 :
172 120: llvm::SmallString<256> Name;
173 120: llvm::raw_svector_ostream Out(Name);
174 :
58: branch 1 taken
62: branch 2 taken
175 120: if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
4: branch 1 taken
54: branch 2 taken
176 58: if (MD->isVirtual())
177 4: Out << "virtual ";
2: branch 1 taken
56: branch 2 taken
178 58: if (MD->isStatic())
179 2: Out << "static ";
180 : }
181 :
182 120: PrintingPolicy Policy(Context.getLangOptions());
183 120: Policy.SuppressTagKind = true;
184 :
185 120: std::string Proto = FD->getQualifiedNameAsString(Policy);
186 :
187 120: const FunctionType *AFT = FD->getType()->getAs<FunctionType>();
188 120: const FunctionProtoType *FT = 0;
96: branch 1 taken
24: branch 2 taken
189 120: if (FD->hasWrittenPrototype())
190 96: FT = dyn_cast<FunctionProtoType>(AFT);
191 :
192 120: Proto += "(";
96: branch 0 taken
24: branch 1 taken
193 120: if (FT) {
194 96: llvm::raw_string_ostream POut(Proto);
22: branch 2 taken
96: branch 3 taken
195 118: for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
4: branch 0 taken
18: branch 1 taken
196 22: if (i) POut << ", ";
197 22: std::string Param;
198 22: FD->getParamDecl(i)->getType().getAsStringInternal(Param, Policy);
199 22: POut << Param;
200 : }
201 :
2: branch 1 taken
94: branch 2 taken
202 96: if (FT->isVariadic()) {
2: branch 1 taken
0: branch 2 not taken
203 2: if (FD->getNumParams()) POut << ", ";
204 2: POut << "...";
205 96: }
206 : }
207 120: Proto += ")";
208 :
58: branch 1 taken
62: branch 2 taken
209 120: if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
210 58: Qualifiers ThisQuals = Qualifiers::fromCVRMask(MD->getTypeQualifiers());
4: branch 1 taken
54: branch 2 taken
211 58: if (ThisQuals.hasConst())
212 4: Proto += " const";
4: branch 1 taken
54: branch 2 taken
213 58: if (ThisQuals.hasVolatile())
214 4: Proto += " volatile";
215 : }
216 :
114: branch 1 taken
6: branch 2 taken
112: branch 4 taken
2: branch 5 taken
112: branch 6 taken
8: branch 7 taken
217 120: if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
218 112: AFT->getResultType().getAsStringInternal(Proto, Policy);
219 :
220 120: Out << Proto;
221 :
222 120: Out.flush();
223 120: return Name.str().str();
224 : }
87: branch 1 taken
6: branch 2 taken
225 93: if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
226 87: llvm::SmallString<256> Name;
227 87: llvm::raw_svector_ostream Out(Name);
57: branch 1 taken
30: branch 2 taken
228 87: Out << (MD->isInstanceMethod() ? '-' : '+');
229 87: Out << '[';
230 87: Out << MD->getClassInterface()->getNameAsString();
12: branch 0 taken
75: branch 1 taken
231 87: if (const ObjCCategoryImplDecl *CID =
232 87: dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext())) {
233 12: Out << '(';
234 12: Out << CID->getNameAsString();
235 12: Out << ')';
236 : }
237 87: Out << ' ';
238 87: Out << MD->getSelector().getAsString();
239 87: Out << ']';
240 :
241 87: Out.flush();
242 87: return Name.str().str();
243 : }
5: branch 1 taken
1: branch 2 taken
1: branch 3 taken
4: branch 4 taken
1: branch 5 taken
5: branch 6 taken
244 6: if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) {
245 : // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
246 1: return "top level";
247 : }
248 5: return "";
249 : }
250 :
251 : /// getValueAsApproximateDouble - This returns the value as an inaccurate
252 : /// double. Note that this may cause loss of precision, but is useful for
253 : /// debugging dumps, etc.
254 3: double FloatingLiteral::getValueAsApproximateDouble() const {
255 3: llvm::APFloat V = getValue();
256 : bool ignored;
257 : V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
258 3: &ignored);
259 3: return V.convertToDouble();
260 : }
261 :
262 : StringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData,
263 : unsigned ByteLength, bool Wide,
264 : QualType Ty,
265 : const SourceLocation *Loc,
266 1844: unsigned NumStrs) {
267 : // Allocate enough space for the StringLiteral plus an array of locations for
268 : // any concatenated string tokens.
269 : void *Mem = C.Allocate(sizeof(StringLiteral)+
270 : sizeof(SourceLocation)*(NumStrs-1),
271 1844: llvm::alignof<StringLiteral>());
1844: branch 1 taken
0: branch 2 not taken
272 1844: StringLiteral *SL = new (Mem) StringLiteral(Ty);
273 :
274 : // OPTIMIZE: could allocate this appended to the StringLiteral.
275 1844: char *AStrData = new (C, 1) char[ByteLength];
276 1844: memcpy(AStrData, StrData, ByteLength);
277 1844: SL->StrData = AStrData;
278 1844: SL->ByteLength = ByteLength;
279 1844: SL->IsWide = Wide;
280 1844: SL->TokLocs[0] = Loc[0];
281 1844: SL->NumConcatenated = NumStrs;
282 :
141: branch 0 taken
1703: branch 1 taken
283 1844: if (NumStrs != 1)
284 141: memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1));
285 1844: return SL;
286 : }
287 :
288 25: StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) {
289 : void *Mem = C.Allocate(sizeof(StringLiteral)+
290 : sizeof(SourceLocation)*(NumStrs-1),
291 25: llvm::alignof<StringLiteral>());
25: branch 2 taken
0: branch 3 not taken
292 25: StringLiteral *SL = new (Mem) StringLiteral(QualType());
293 25: SL->StrData = 0;
294 25: SL->ByteLength = 0;
295 25: SL->NumConcatenated = NumStrs;
296 25: return SL;
297 : }
298 :
299 50: void StringLiteral::DoDestroy(ASTContext &C) {
300 50: C.Deallocate(const_cast<char*>(StrData));
301 50: Expr::DoDestroy(C);
302 50: }
303 :
304 25: void StringLiteral::setString(ASTContext &C, llvm::StringRef Str) {
0: branch 0 not taken
25: branch 1 taken
305 25: if (StrData)
306 0: C.Deallocate(const_cast<char*>(StrData));
307 :
308 25: char *AStrData = new (C, 1) char[Str.size()];
309 25: memcpy(AStrData, Str.data(), Str.size());
310 25: StrData = AStrData;
311 25: ByteLength = Str.size();
312 25: }
313 :
314 : /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
315 : /// corresponds to, e.g. "sizeof" or "[pre]++".
316 151: const char *UnaryOperator::getOpcodeStr(Opcode Op) {
0: branch 0 not taken
2: branch 1 taken
0: branch 2 not taken
12: branch 3 taken
8: branch 4 taken
109: branch 5 taken
4: branch 6 taken
2: branch 7 taken
1: branch 8 taken
0: branch 9 not taken
4: branch 10 taken
4: branch 11 taken
2: branch 12 taken
2: branch 13 taken
1: branch 14 taken
317 151: switch (Op) {
318 0: default: assert(0 && "Unknown unary operator");
319 2: case PostInc: return "++";
320 0: case PostDec: return "--";
321 12: case PreInc: return "++";
322 8: case PreDec: return "--";
323 109: case AddrOf: return "&";
324 4: case Deref: return "*";
325 2: case Plus: return "+";
326 1: case Minus: return "-";
327 0: case Not: return "~";
328 4: case LNot: return "!";
329 4: case Real: return "__real";
330 2: case Imag: return "__imag";
331 2: case Extension: return "__extension__";
332 1: case OffsetOf: return "__builtin_offsetof";
333 : }
334 : }
335 :
336 : UnaryOperator::Opcode
337 41: UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) {
0: branch 0 not taken
11: branch 1 taken
2: branch 2 taken
4: branch 3 taken
19: branch 4 taken
0: branch 5 not taken
3: branch 6 taken
0: branch 7 not taken
2: branch 8 taken
338 41: switch (OO) {
339 0: default: assert(false && "No unary operator for overloaded function");
3: branch 0 taken
8: branch 1 taken
340 11: case OO_PlusPlus: return Postfix ? PostInc : PreInc;
0: branch 0 not taken
2: branch 1 taken
341 2: case OO_MinusMinus: return Postfix ? PostDec : PreDec;
342 4: case OO_Amp: return AddrOf;
343 19: case OO_Star: return Deref;
344 0: case OO_Plus: return Plus;
345 3: case OO_Minus: return Minus;
346 0: case OO_Tilde: return Not;
347 2: case OO_Exclaim: return LNot;
348 : }
349 : }
350 :
351 294: OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) {
40: branch 0 taken
14: branch 1 taken
144: branch 2 taken
42: branch 3 taken
17: branch 4 taken
16: branch 5 taken
2: branch 6 taken
19: branch 7 taken
0: branch 8 not taken
352 294: switch (Opc) {
353 40: case PostInc: case PreInc: return OO_PlusPlus;
354 14: case PostDec: case PreDec: return OO_MinusMinus;
355 144: case AddrOf: return OO_Amp;
356 42: case Deref: return OO_Star;
357 17: case Plus: return OO_Plus;
358 16: case Minus: return OO_Minus;
359 2: case Not: return OO_Tilde;
360 19: case LNot: return OO_Exclaim;
361 0: default: return OO_None;
362 : }
363 : }
364 :
365 :
366 : //===----------------------------------------------------------------------===//
367 : // Postfix Operators.
368 : //===----------------------------------------------------------------------===//
369 :
370 : CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args,
371 1135: unsigned numargs, QualType t, SourceLocation rparenloc)
372 : : Expr(SC, t,
373 : fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
374 : fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)),
0: branch 1 not taken
0: branch 2 not taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 10 not taken
0: branch 11 not taken
1090: branch 15 taken
45: branch 16 taken
0: branch 18 not taken
1090: branch 19 taken
1090: branch 21 taken
45: branch 22 taken
0: branch 24 not taken
1090: branch 25 taken
375 1135: NumArgs(numargs) {
376 :
377 1135: SubExprs = new (C) Stmt*[numargs+1];
378 1135: SubExprs[FN] = fn;
1847: branch 0 taken
1847: branch 1 taken
712: branch 2 taken
1135: branch 3 taken
379 1847: for (unsigned i = 0; i != numargs; ++i)
380 712: SubExprs[i+ARGS_START] = args[i];
381 :
382 1135: RParenLoc = rparenloc;
383 1135: }
384 :
385 : CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs,
386 15256: QualType t, SourceLocation rparenloc)
387 : : Expr(CallExprClass, t,
388 : fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
389 : fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)),
15151: branch 1 taken
105: branch 2 taken
41: branch 4 taken
15110: branch 5 taken
15151: branch 7 taken
105: branch 8 taken
37: branch 10 taken
15114: branch 11 taken
0: branch 15 not taken
0: branch 16 not taken
0: branch 18 not taken
0: branch 19 not taken
0: branch 21 not taken
0: branch 22 not taken
0: branch 24 not taken
0: branch 25 not taken
390 15256: NumArgs(numargs) {
391 :
392 15256: SubExprs = new (C) Stmt*[numargs+1];
393 15256: SubExprs[FN] = fn;
9153: branch 0 taken
15256: branch 1 taken
15256: branch 2 taken
15256: branch 3 taken
394 24409: for (unsigned i = 0; i != numargs; ++i)
395 9153: SubExprs[i+ARGS_START] = args[i];
396 :
397 15256: RParenLoc = rparenloc;
398 15256: }
399 :
400 11: CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty)
401 11: : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
402 11: SubExprs = new (C) Stmt*[1];
403 11: }
404 :
405 256: void CallExpr::DoDestroy(ASTContext& C) {
406 256: DestroyChildren(C);
256: branch 0 taken
0: branch 1 not taken
407 256: if (SubExprs) C.Deallocate(SubExprs);
408 256: this->~CallExpr();
409 256: C.Deallocate(this);
410 256: }
411 :
412 4272: Decl *CallExpr::getCalleeDecl() {
413 4272: Expr *CEE = getCallee()->IgnoreParenCasts();
4119: branch 1 taken
153: branch 2 taken
414 4272: if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
415 4119: return DRE->getDecl();
25: branch 1 taken
128: branch 2 taken
416 153: if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
417 25: return ME->getMemberDecl();
418 :
419 128: return 0;
420 : }
421 :
422 3221: FunctionDecl *CallExpr::getDirectCallee() {
423 3221: return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
424 : }
425 :
426 : /// setNumArgs - This changes the number of arguments present in this call.
427 : /// Any orphaned expressions are deleted by this, and any new operands are set
428 : /// to null.
429 73: void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) {
430 : // No change, just return.
73: branch 1 taken
0: branch 2 not taken
431 73: if (NumArgs == getNumArgs()) return;
432 :
433 : // If shrinking # arguments, just delete the extras and forgot them.
8: branch 1 taken
65: branch 2 taken
434 73: if (NumArgs < getNumArgs()) {
8: branch 1 taken
8: branch 2 taken
435 16: for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i)
436 8: getArg(i)->Destroy(C);
437 8: this->NumArgs = NumArgs;
438 8: return;
439 : }
440 :
441 : // Otherwise, we are growing the # arguments. New an bigger argument array.
442 65: Stmt **NewSubExprs = new (C) Stmt*[NumArgs+1];
443 : // Copy over args.
103: branch 1 taken
65: branch 2 taken
444 168: for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i)
445 103: NewSubExprs[i] = SubExprs[i];
446 : // Null out new args.
96: branch 1 taken
65: branch 2 taken
447 161: for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i)
448 96: NewSubExprs[i] = 0;
449 :
65: branch 0 taken
0: branch 1 not taken
450 65: if (SubExprs) C.Deallocate(SubExprs);
451 65: SubExprs = NewSubExprs;
452 65: this->NumArgs = NumArgs;
453 : }
454 :
455 : /// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If
456 : /// not, return 0.
457 1075: unsigned CallExpr::isBuiltinCall(ASTContext &Context) const {
458 : // All simple function calls (e.g. func()) are implicitly cast to pointer to
459 : // function. As a result, we try and obtain the DeclRefExpr from the
460 : // ImplicitCastExpr.
461 1075: const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
94: branch 0 taken
981: branch 1 taken
462 1075: if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
463 94: return 0;
464 :
465 981: const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
28: branch 0 taken
953: branch 1 taken
466 981: if (!DRE)
467 28: return 0;
468 :
469 953: const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
0: branch 0 not taken
953: branch 1 taken
470 953: if (!FDecl)
471 0: return 0;
472 :
16: branch 1 taken
937: branch 2 taken
473 953: if (!FDecl->getIdentifier())
474 16: return 0;
475 :
476 937: return FDecl->getBuiltinID();
477 : }
478 :
479 12020: QualType CallExpr::getCallReturnType() const {
480 12020: QualType CalleeType = getCallee()->getType();
11384: branch 2 taken
636: branch 3 taken
481 12020: if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>())
482 11384: CalleeType = FnTypePtr->getPointeeType();
27: branch 2 taken
609: branch 3 taken
483 636: else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>())
484 27: CalleeType = BPT->getPointeeType();
485 :
486 12020: const FunctionType *FnType = CalleeType->getAs<FunctionType>();
487 12020: return FnType->getResultType();
488 : }
489 :
490 : MemberExpr::MemberExpr(Expr *base, bool isarrow, NestedNameSpecifier *qual,
491 : SourceRange qualrange, ValueDecl *memberdecl,
492 : SourceLocation l, const TemplateArgumentListInfo *targs,
493 2030: QualType ty)
494 : : Expr(MemberExprClass, ty,
495 : base->isTypeDependent() || (qual && qual->isDependent()),
496 : base->isValueDependent() || (qual && qual->isDependent())),
497 : Base(base), MemberDecl(memberdecl), MemberLoc(l), IsArrow(isarrow),
1954: branch 1 taken
76: branch 2 taken
85: branch 3 taken
1869: branch 4 taken
0: branch 6 not taken
85: branch 7 taken
1955: branch 9 taken
75: branch 10 taken
85: branch 11 taken
1870: branch 12 taken
0: branch 14 not taken
85: branch 15 taken
0: branch 18 not taken
0: branch 19 not taken
0: branch 20 not taken
0: branch 21 not taken
0: branch 23 not taken
0: branch 24 not taken
0: branch 26 not taken
0: branch 27 not taken
0: branch 28 not taken
0: branch 29 not taken
0: branch 31 not taken
0: branch 32 not taken
498 2030: HasQualifier(qual != 0), HasExplicitTemplateArgumentList(targs) {
499 : // Initialize the qualifier, if any.
88: branch 0 taken
1942: branch 1 taken
1942: branch 2 taken
1942: branch 3 taken
500 2030: if (HasQualifier) {
501 88: NameQualifier *NQ = getMemberQualifier();
502 88: NQ->NNS = qual;
503 88: NQ->Range = qualrange;
504 : }
505 :
506 : // Initialize the explicit template argument list, if any.
29: branch 0 taken
2001: branch 1 taken
2001: branch 2 taken
2001: branch 3 taken
507 2030: if (targs)
508 29: getExplicitTemplateArgumentList()->initializeFrom(*targs);
509 2030: }
510 :
511 : MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow,
512 : NestedNameSpecifier *qual,
513 : SourceRange qualrange,
514 : ValueDecl *memberdecl,
515 : SourceLocation l,
516 : const TemplateArgumentListInfo *targs,
517 2030: QualType ty) {
518 2030: std::size_t Size = sizeof(MemberExpr);
88: branch 0 taken
1942: branch 1 taken
519 2030: if (qual != 0)
520 88: Size += sizeof(NameQualifier);
521 :
29: branch 0 taken
2001: branch 1 taken
522 2030: if (targs)
523 29: Size += ExplicitTemplateArgumentList::sizeFor(*targs);
524 :
525 2030: void *Mem = C.Allocate(Size, llvm::alignof<MemberExpr>());
526 : return new (Mem) MemberExpr(base, isarrow, qual, qualrange, memberdecl, l,
2030: branch 1 taken
0: branch 2 not taken
527 2030: targs, ty);
528 : }
529 :
530 44: const char *CastExpr::getCastKindName() const {
12: branch 1 taken
0: branch 2 not taken
4: branch 3 taken
0: branch 4 not taken
4: branch 5 taken
0: branch 6 not taken
0: branch 7 not taken
9: branch 8 taken
7: branch 9 taken
0: branch 10 not taken
0: branch 11 not taken
0: branch 12 not taken
1: branch 13 taken
0: branch 14 not taken
0: branch 15 not taken
0: branch 16 not taken
0: branch 17 not taken
0: branch 18 not taken
4: branch 19 taken
2: branch 20 taken
0: branch 21 not taken
1: branch 22 taken
0: branch 23 not taken
0: branch 24 not taken
0: branch 25 not taken
0: branch 26 not taken
531 44: switch (getCastKind()) {
532 : case CastExpr::CK_Unknown:
533 12: return "Unknown";
534 : case CastExpr::CK_BitCast:
535 0: return "BitCast";
536 : case CastExpr::CK_NoOp:
537 4: return "NoOp";
538 : case CastExpr::CK_BaseToDerived:
539 0: return "BaseToDerived";
540 : case CastExpr::CK_DerivedToBase:
541 4: return "DerivedToBase";
542 : case CastExpr::CK_Dynamic:
543 0: return "Dynamic";
544 : case CastExpr::CK_ToUnion:
545 0: return "ToUnion";
546 : case CastExpr::CK_ArrayToPointerDecay:
547 9: return "ArrayToPointerDecay";
548 : case CastExpr::CK_FunctionToPointerDecay:
549 7: return "FunctionToPointerDecay";
550 : case CastExpr::CK_NullToMemberPointer:
551 0: return "NullToMemberPointer";
552 : case CastExpr::CK_BaseToDerivedMemberPointer:
553 0: return "BaseToDerivedMemberPointer";
554 : case CastExpr::CK_DerivedToBaseMemberPointer:
555 0: return "DerivedToBaseMemberPointer";
556 : case CastExpr::CK_UserDefinedConversion:
557 1: return "UserDefinedConversion";
558 : case CastExpr::CK_ConstructorConversion:
559 0: return "ConstructorConversion";
560 : case CastExpr::CK_IntegralToPointer:
561 0: return "IntegralToPointer";
562 : case CastExpr::CK_PointerToIntegral:
563 0: return "PointerToIntegral";
564 : case CastExpr::CK_ToVoid:
565 0: return "ToVoid";
566 : case CastExpr::CK_VectorSplat:
567 0: return "VectorSplat";
568 : case CastExpr::CK_IntegralCast:
569 4: return "IntegralCast";
570 : case CastExpr::CK_IntegralToFloating:
571 2: return "IntegralToFloating";
572 : case CastExpr::CK_FloatingToIntegral:
573 0: return "FloatingToIntegral";
574 : case CastExpr::CK_FloatingCast:
575 1: return "FloatingCast";
576 : case CastExpr::CK_MemberPointerToBoolean:
577 0: return "MemberPointerToBoolean";
578 : case CastExpr::CK_AnyPointerToObjCPointerCast:
579 0: return "AnyPointerToObjCPointerCast";
580 : case CastExpr::CK_AnyPointerToBlockPointerCast:
581 0: return "AnyPointerToBlockPointerCast";
582 : }
583 :
584 0: assert(0 && "Unhandled cast kind!");
585 : return 0;
586 : }
587 :
588 1002: Expr *CastExpr::getSubExprAsWritten() {
589 1002: Expr *SubExpr = 0;
590 1002: CastExpr *E = this;
25: branch 1 taken
1002: branch 2 taken
591 1027: do {
592 1027: SubExpr = E->getSubExpr();
593 :
594 : // Skip any temporary bindings; they're implicit.
3: branch 1 taken
1024: branch 2 taken
595 1027: if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
596 3: SubExpr = Binder->getSubExpr();
597 :
598 : // Conversions by constructor and conversion functions have a
599 : // subexpression describing the call; strip it off.
12: branch 1 taken
1015: branch 2 taken
600 1027: if (E->getCastKind() == CastExpr::CK_ConstructorConversion)
601 12: SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0);
1: branch 1 taken
1014: branch 2 taken
602 1015: else if (E->getCastKind() == CastExpr::CK_UserDefinedConversion)
603 1: SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument();
604 :
605 : // If the subexpression we're left with is an implicit cast, look
606 : // through that, too.
607 : } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr)));
608 :
609 1002: return SubExpr;
610 : }
611 :
612 : /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
613 : /// corresponds to, e.g. "<<=".
614 131: const char *BinaryOperator::getOpcodeStr(Opcode Op) {
0: branch 0 not taken
7: branch 1 taken
2: branch 2 taken
0: branch 3 not taken
14: branch 4 taken
22: branch 5 taken
6: branch 6 taken
0: branch 7 not taken
0: branch 8 not taken
2: branch 9 taken
2: branch 10 taken
2: branch 11 taken
1: branch 12 taken
14: branch 13 taken
2: branch 14 taken
18: branch 15 taken
2: branch 16 taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 19 not taken
27: branch 20 taken
0: branch 21 not taken
0: branch 22 not taken
0: branch 23 not taken
10: branch 24 taken
0: branch 25 not taken
0: branch 26 not taken
0: branch 27 not taken
0: branch 28 not taken
0: branch 29 not taken
0: branch 30 not taken
0: branch 31 not taken
0: branch 32 not taken
615 131: switch (Op) {
616 0: case PtrMemD: return ".*";
617 7: case PtrMemI: return "->*";
618 2: case Mul: return "*";
619 0: case Div: return "/";
620 14: case Rem: return "%";
621 22: case Add: return "+";
622 6: case Sub: return "-";
623 0: case Shl: return "<<";
624 0: case Shr: return ">>";
625 2: case LT: return "<";
626 2: case GT: return ">";
627 2: case LE: return "<=";
628 1: case GE: return ">=";
629 14: case EQ: return "==";
630 2: case NE: return "!=";
631 18: case And: return "&";
632 2: case Xor: return "^";
633 0: case Or: return "|";
634 0: case LAnd: return "&&";
635 0: case LOr: return "||";
636 27: case Assign: return "=";
637 0: case MulAssign: return "*=";
638 0: case DivAssign: return "/=";
639 0: case RemAssign: return "%=";
640 10: case AddAssign: return "+=";
641 0: case SubAssign: return "-=";
642 0: case ShlAssign: return "<<=";
643 0: case ShrAssign: return ">>=";
644 0: case AndAssign: return "&=";
645 0: case XorAssign: return "^=";
646 0: case OrAssign: return "|=";
647 0: case Comma: return ",";
648 : }
649 :
650 0: return "";
651 : }
652 :
653 : BinaryOperator::Opcode
654 14: BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
0: branch 0 not taken
8: branch 1 taken
0: branch 2 not taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 11 not taken
5: branch 12 taken
0: branch 13 not taken
0: branch 14 not taken
0: branch 15 not taken
0: branch 16 not taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 19 not taken
0: branch 20 not taken
0: branch 21 not taken
0: branch 22 not taken
0: branch 23 not taken
1: branch 24 taken
0: branch 25 not taken
0: branch 26 not taken
0: branch 27 not taken
0: branch 28 not taken
0: branch 29 not taken
0: branch 30 not taken
0: branch 31 not taken
655 14: switch (OO) {
656 0: default: assert(false && "Not an overloadable binary operator");
657 8: case OO_Plus: return Add;
658 0: case OO_Minus: return Sub;
659 0: case OO_Star: return Mul;
660 0: case OO_Slash: return Div;
661 0: case OO_Percent: return Rem;
662 0: case OO_Caret: return Xor;
663 0: case OO_Amp: return And;
664 0: case OO_Pipe: return Or;
665 0: case OO_Equal: return Assign;
666 0: case OO_Less: return LT;
667 0: case OO_Greater: return GT;
668 5: case OO_PlusEqual: return AddAssign;
669 0: case OO_MinusEqual: return SubAssign;
670 0: case OO_StarEqual: return MulAssign;
671 0: case OO_SlashEqual: return DivAssign;
672 0: case OO_PercentEqual: return RemAssign;
673 0: case OO_CaretEqual: return XorAssign;
674 0: case OO_AmpEqual: return AndAssign;
675 0: case OO_PipeEqual: return OrAssign;
676 0: case OO_LessLess: return Shl;
677 0: case OO_GreaterGreater: return Shr;
678 0: case OO_LessLessEqual: return ShlAssign;
679 0: case OO_GreaterGreaterEqual: return ShrAssign;
680 1: case OO_EqualEqual: return EQ;
681 0: case OO_ExclaimEqual: return NE;
682 0: case OO_LessEqual: return LE;
683 0: case OO_GreaterEqual: return GE;
684 0: case OO_AmpAmp: return LAnd;
685 0: case OO_PipePipe: return LOr;
686 0: case OO_Comma: return Comma;
687 0: case OO_ArrowStar: return PtrMemI;
688 : }
689 : }
690 :
691 929: OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
692 : static const OverloadedOperatorKind OverOps[] = {
693 : /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
694 : OO_Star, OO_Slash, OO_Percent,
695 : OO_Plus, OO_Minus,
696 : OO_LessLess, OO_GreaterGreater,
697 : OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
698 : OO_EqualEqual, OO_ExclaimEqual,
699 : OO_Amp,
700 : OO_Caret,
701 : OO_Pipe,
702 : OO_AmpAmp,
703 : OO_PipePipe,
704 : OO_Equal, OO_StarEqual,
705 : OO_SlashEqual, OO_PercentEqual,
706 : OO_PlusEqual, OO_MinusEqual,
707 : OO_LessLessEqual, OO_GreaterGreaterEqual,
708 : OO_AmpEqual, OO_CaretEqual,
709 : OO_PipeEqual,
710 : OO_Comma
711 : };
712 929: return OverOps[Opc];
713 : }
714 :
715 : InitListExpr::InitListExpr(SourceLocation lbraceloc,
716 : Expr **initExprs, unsigned numInits,
717 1930: SourceLocation rbraceloc)
718 : : Expr(InitListExprClass, QualType(), false, false),
719 : LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0),
720 1930: UnionFieldInit(0), HadArrayRangeDesignator(false)
721 : {
2499: branch 0 taken
1930: branch 1 taken
1930: branch 2 taken
1930: branch 3 taken
722 4429: for (unsigned I = 0; I != numInits; ++I) {
12: branch 1 taken
2487: branch 2 taken
0: branch 4 not taken
0: branch 5 not taken
723 2499: if (initExprs[I]->isTypeDependent())
724 12: TypeDependent = true;
15: branch 1 taken
2484: branch 2 taken
0: branch 4 not taken
0: branch 5 not taken
725 2499: if (initExprs[I]->isValueDependent())
726 15: ValueDependent = true;
727 : }
728 :
729 1930: InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits);
730 1930: }
731 :
732 1019: void InitListExpr::reserveInits(unsigned NumInits) {
997: branch 1 taken
22: branch 2 taken
733 1019: if (NumInits > InitExprs.size())
734 997: InitExprs.reserve(NumInits);
735 1019: }
736 :
737 185: void InitListExpr::resizeInits(ASTContext &Context, unsigned NumInits) {
0: branch 1 not taken
185: branch 2 taken
738 185: for (unsigned Idx = NumInits, LastIdx = InitExprs.size();
739 : Idx < LastIdx; ++Idx)
740 0: InitExprs[Idx]->Destroy(Context);
741 185: InitExprs.resize(NumInits, 0);
742 185: }
743 :
744 2490: Expr *InitListExpr::updateInit(unsigned Init, Expr *expr) {
2297: branch 1 taken
193: branch 2 taken
745 2490: if (Init >= InitExprs.size()) {
746 2297: InitExprs.insert(InitExprs.end(), Init - InitExprs.size() + 1, 0);
747 2297: InitExprs.back() = expr;
748 2297: return 0;
749 : }
750 :
751 193: Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
752 193: InitExprs[Init] = expr;
753 193: return Result;
754 : }
755 :
756 : /// getFunctionType - Return the underlying function type for this block.
757 : ///
758 95: const FunctionType *BlockExpr::getFunctionType() const {
759 : return getType()->getAs<BlockPointerType>()->
760 95: getPointeeType()->getAs<FunctionType>();
761 : }
762 :
763 832: SourceLocation BlockExpr::getCaretLocation() const {
764 832: return TheBlock->getCaretLocation();
765 : }
766 974: const Stmt *BlockExpr::getBody() const {
767 974: return TheBlock->getBody();
768 : }
769 90: Stmt *BlockExpr::getBody() {
770 90: return TheBlock->getBody();
771 : }
772 :
773 :
774 : //===----------------------------------------------------------------------===//
775 : // Generic Expression Routines
776 : //===----------------------------------------------------------------------===//
777 :
778 : /// isUnusedResultAWarning - Return true if this immediate expression should
779 : /// be warned about if the result is unused. If so, fill in Loc and Ranges
780 : /// with location to warn on and the source range[s] to report with the
781 : /// warning.
782 : bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1,
783 5698: SourceRange &R2, ASTContext &Ctx) const {
784 : // Don't warn if the expr is type dependent. The type could end up
785 : // instantiating to void.
172: branch 1 taken
5526: branch 2 taken
786 5698: if (isTypeDependent())
787 172: return false;
788 :
50: branch 1 taken
27: branch 2 taken
643: branch 3 taken
3129: branch 4 taken
272: branch 5 taken
21: branch 6 taken
3: branch 7 taken
4: branch 8 taken
1040: branch 9 taken
8: branch 10 taken
253: branch 11 taken
1: branch 12 taken
1: branch 13 taken
23: branch 14 taken
9: branch 15 taken
5: branch 16 taken
0: branch 17 not taken
26: branch 18 taken
5: branch 19 taken
6: branch 20 taken
789 5526: switch (getStmtClass()) {
790 : default:
791 50: Loc = getExprLoc();
792 50: R1 = getSourceRange();
793 50: return true;
794 : case ParenExprClass:
795 : return cast<ParenExpr>(this)->getSubExpr()->
796 27: isUnusedResultAWarning(Loc, R1, R2, Ctx);
797 : case UnaryOperatorClass: {
798 643: const UnaryOperator *UO = cast<UnaryOperator>(this);
799 :
5: branch 1 taken
628: branch 2 taken
2: branch 3 taken
7: branch 4 taken
1: branch 5 taken
800 643: switch (UO->getOpcode()) {
801 5: default: break;
802 : case UnaryOperator::PostInc:
803 : case UnaryOperator::PostDec:
804 : case UnaryOperator::PreInc:
805 : case UnaryOperator::PreDec: // ++/--
806 628: return false; // Not a warning.
807 : case UnaryOperator::Deref:
808 : // Dereferencing a volatile pointer is a side-effect.
1: branch 3 taken
1: branch 4 taken
809 2: if (Ctx.getCanonicalType(getType()).isVolatileQualified())
810 1: return false;
811 1: break;
812 : case UnaryOperator::Real:
813 : case UnaryOperator::Imag:
814 : // accessing a piece of a volatile complex is a side-effect.
3: branch 4 taken
4: branch 5 taken
815 7: if (Ctx.getCanonicalType(UO->getSubExpr()->getType())
816 : .isVolatileQualified())
817 3: return false;
818 4: break;
819 : case UnaryOperator::Extension:
820 1: return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
821 : }
822 10: Loc = UO->getOperatorLoc();
823 10: R1 = UO->getSubExpr()->getSourceRange();
824 10: return true;
825 : }
826 : case BinaryOperatorClass: {
827 3129: const BinaryOperator *BO = cast<BinaryOperator>(this);
828 : // Consider comma to have side effects if the LHS or RHS does.
22: branch 1 taken
3107: branch 2 taken
829 3129: if (BO->getOpcode() == BinaryOperator::Comma)
830 : return (BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx) ||
15: branch 2 taken
7: branch 3 taken
1: branch 6 taken
14: branch 7 taken
831 22: BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
832 :
3087: branch 1 taken
20: branch 2 taken
833 3107: if (BO->isAssignmentOp())
834 3087: return false;
835 20: Loc = BO->getOperatorLoc();
836 20: R1 = BO->getLHS()->getSourceRange();
837 20: R2 = BO->getRHS()->getSourceRange();
838 20: return true;
839 : }
840 : case CompoundAssignOperatorClass:
841 272: return false;
842 :
843 : case ConditionalOperatorClass: {
844 : // The condition must be evaluated, but if either the LHS or RHS is a
845 : // warning, warn about them.
846 21: const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
21: branch 1 taken
0: branch 2 not taken
1: branch 5 taken
20: branch 6 taken
1: branch 7 taken
20: branch 8 taken
847 21: if (Exp->getLHS() &&
848 : Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx))
849 1: return true;
850 20: return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
851 : }
852 :
853 : case MemberExprClass:
854 : // If the base pointer or element is to a volatile pointer/field, accessing
855 : // it is a side effect.
0: branch 3 not taken
3: branch 4 taken
856 3: if (Ctx.getCanonicalType(getType()).isVolatileQualified())
857 0: return false;
858 3: Loc = cast<MemberExpr>(this)->getMemberLoc();
859 3: R1 = SourceRange(Loc, Loc);
860 3: R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
861 3: return true;
862 :
863 : case ArraySubscriptExprClass:
864 : // If the base pointer or element is to a volatile pointer/field, accessing
865 : // it is a side effect.
1: branch 3 taken
3: branch 4 taken
866 4: if (Ctx.getCanonicalType(getType()).isVolatileQualified())
867 1: return false;
868 3: Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
869 3: R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
870 3: R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
871 3: return true;
872 :
873 : case CallExprClass:
874 : case CXXOperatorCallExprClass:
875 : case CXXMemberCallExprClass: {
876 : // If this is a direct call, get the callee.
877 1040: const CallExpr *CE = cast<CallExpr>(this);
1027: branch 1 taken
13: branch 2 taken
878 1040: if (const Decl *FD = CE->getCalleeDecl()) {
879 : // If the callee has attribute pure, const, or warn_unused_result, warn
880 : // about it. void foo() { strlen("bar"); } should warn.
881 : //
882 : // Note: If new cases are added here, DiagnoseUnusedExprResult should be
883 : // updated to match for QoI.
1022: branch 1 taken
5: branch 2 taken
1021: branch 4 taken
1: branch 5 taken
5: branch 7 taken
1016: branch 8 taken
11: branch 9 taken
1016: branch 10 taken
884 1027: if (FD->getAttr<WarnUnusedResultAttr>() ||
885 : FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) {
886 11: Loc = CE->getCallee()->getLocStart();
887 11: R1 = CE->getCallee()->getSourceRange();
888 :
6: branch 1 taken
5: branch 2 taken
889 11: if (unsigned NumArgs = CE->getNumArgs())
890 : R2 = SourceRange(CE->getArg(0)->getLocStart(),
891 6: CE->getArg(NumArgs-1)->getLocEnd());
892 11: return true;
893 : }
894 : }
895 1029: return false;
896 : }
897 :
898 : case CXXTemporaryObjectExprClass:
899 : case CXXConstructExprClass:
900 8: return false;
901 :
902 : case ObjCMessageExprClass:
903 253: return false;
904 :
905 : case ObjCImplicitSetterGetterRefExprClass: { // Dot syntax for message send.
906 : #if 0
907 : const ObjCImplicitSetterGetterRefExpr *Ref =
908 : cast<ObjCImplicitSetterGetterRefExpr>(this);
909 : // FIXME: We really want the location of the '.' here.
910 : Loc = Ref->getLocation();
911 : R1 = SourceRange(Ref->getLocation(), Ref->getLocation());
912 : if (Ref->getBase())
913 : R2 = Ref->getBase()->getSourceRange();
914 : #else
915 1: Loc = getExprLoc();
916 1: R1 = getSourceRange();
917 : #endif
918 1: return true;
919 : }
920 : case StmtExprClass: {
921 : // Statement exprs don't logically have side effects themselves, but are
922 : // sometimes used in macros in ways that give them a type that is unused.
923 : // For example ({ blah; foo(); }) will end up with a type if foo has a type.
924 : // however, if the result of the stmt expr is dead, we don't want to emit a
925 : // warning.
926 1: const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
1: branch 1 taken
0: branch 2 not taken
927 1: if (!CS->body_empty())
1: branch 2 taken
0: branch 3 not taken
928 1: if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
929 1: return E->isUnusedResultAWarning(Loc, R1, R2, Ctx);
930 :
931 0: Loc = cast<StmtExpr>(this)->getLParenLoc();
932 0: R1 = getSourceRange();
933 0: return true;
934 : }
935 : case CStyleCastExprClass:
936 : // If this is an explicit cast to void, allow it. People do this when they
937 : // think they know what they're doing :).
1: branch 3 taken
22: branch 4 taken
938 23: if (getType()->isVoidType())
939 1: return false;
940 22: Loc = cast<CStyleCastExpr>(this)->getLParenLoc();
941 22: R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange();
942 22: return true;
943 : case CXXFunctionalCastExprClass: {
944 9: const CastExpr *CE = cast<CastExpr>(this);
945 :
946 : // If this is a cast to void or a constructor conversion, check the operand.
947 : // Otherwise, the result of the cast is unused.
8: branch 1 taken
1: branch 2 taken
6: branch 4 taken
2: branch 5 taken
7: branch 6 taken
2: branch 7 taken
948 9: if (CE->getCastKind() == CastExpr::CK_ToVoid ||
949 : CE->getCastKind() == CastExpr::CK_ConstructorConversion)
950 : return (cast<CastExpr>(this)->getSubExpr()
951 7: ->isUnusedResultAWarning(Loc, R1, R2, Ctx));
952 2: Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc();
953 2: R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange();
954 2: return true;
955 : }
956 :
957 : case ImplicitCastExprClass:
958 : // Check the operand, since implicit casts are inserted by Sema
959 : return (cast<ImplicitCastExpr>(this)
960 5: ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
961 :
962 : case CXXDefaultArgExprClass:
963 : return (cast<CXXDefaultArgExpr>(this)
964 0: ->getExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
965 :
966 : case CXXNewExprClass:
967 : // FIXME: In theory, there might be new expressions that don't have side
968 : // effects (e.g. a placement new with an uninitialized POD).
969 : case CXXDeleteExprClass:
970 26: return false;
971 : case CXXBindTemporaryExprClass:
972 : return (cast<CXXBindTemporaryExpr>(this)
973 5: ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
974 : case CXXExprWithTemporariesClass:
975 : return (cast<CXXExprWithTemporaries>(this)
976 6: ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
977 : }
978 : }
979 :
980 : /// DeclCanBeLvalue - Determine whether the given declaration can be
981 : /// an lvalue. This is a helper routine for isLvalue.
982 33431: static bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) {
983 : // C++ [temp.param]p6:
984 : // A non-type non-reference template-parameter is not an lvalue.
126: branch 0 taken
33305: branch 1 taken
985 33431: if (const NonTypeTemplateParmDecl *NTTParm
986 33431: = dyn_cast<NonTypeTemplateParmDecl>(Decl))
987 126: return NTTParm->getType()->isReferenceType();
988 :
989 : return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) ||
990 : // C++ 3.10p2: An lvalue refers to an object or function.
991 : (Ctx.getLangOptions().CPlusPlus &&
6517: branch 1 taken
26788: branch 2 taken
6474: branch 4 taken
43: branch 5 taken
6465: branch 7 taken
9: branch 8 taken
6329: branch 10 taken
136: branch 11 taken
0: branch 13 not taken
6329: branch 14 taken
992 33305: (isa<FunctionDecl>(Decl) || isa<FunctionTemplateDecl>(Decl)));
993 : }
994 :
995 : /// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an
996 : /// incomplete type other than void. Nonarray expressions that can be lvalues:
997 : /// - name, where name must be a variable
998 : /// - e[i]
999 : /// - (e), where e must be an lvalue
1000 : /// - e.name, where e must be an lvalue
1001 : /// - e->name
1002 : /// - *e, the type of e cannot be a function type
1003 : /// - string-constant
1004 : /// - (__real__ e) and (__imag__ e) where e is an lvalue [GNU extension]
1005 : /// - reference type [C++ [expr]]
1006 : ///
1007 66323: Expr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const {
66323: branch 2 taken
0: branch 3 not taken
1008 66323: assert(!TR->isReferenceType() && "Expressions can't have reference type.");
1009 :
1010 66323: isLvalueResult Res = isLvalueInternal(Ctx);
35609: branch 0 taken
30714: branch 1 taken
30184: branch 3 taken
5425: branch 4 taken
60898: branch 5 taken
5425: branch 6 taken
1011 101932: if (Res != LV_Valid || Ctx.getLangOptions().CPlusPlus)
1012 60898: return Res;
1013 :
1014 : // first, check the type (C99 6.3.2.1). Expressions with function
1015 : // type in C are not lvalues, but they can be lvalues in C++.
5424: branch 2 taken
1: branch 3 taken
0: branch 6 not taken
5424: branch 7 taken
1: branch 8 taken
5424: branch 9 taken
1016 5425: if (TR->isFunctionType() || TR == Ctx.OverloadTy)
1017 1: return LV_NotObjectType;
1018 :
1019 : // Allow qualified void which is an incomplete type other than void (yuck).
11: branch 2 taken
5413: branch 3 taken
7: branch 6 taken
4: branch 7 taken
7: branch 8 taken
5417: branch 9 taken
1020 5424: if (TR->isVoidType() && !Ctx.getCanonicalType(TR).hasQualifiers())
1021 7: return LV_IncompleteVoidType;
1022 :
1023 5417: return LV_Valid;
1024 : }
1025 :
1026 : // Check whether the expression can be sanely treated like an l-value
1027 66395: Expr::isLvalueResult Expr::isLvalueInternal(ASTContext &Ctx) const {
625: branch 1 taken
842: branch 2 taken
33431: branch 3 taken
146: branch 4 taken
2045: branch 5 taken
2176: branch 6 taken
1004: branch 7 taken
984: branch 8 taken
923: branch 9 taken
10045: branch 10 taken
98: branch 11 taken
4: branch 12 taken
45: branch 13 taken
218: branch 14 taken
96: branch 15 taken
22: branch 16 taken
52: branch 17 taken
206: branch 18 taken
6: branch 19 taken
4552: branch 20 taken
119: branch 21 taken
72: branch 22 taken
0: branch 23 not taken
145: branch 24 taken
2: branch 25 taken
20: branch 26 taken
8517: branch 27 taken
1028 66395: switch (getStmtClass()) {
1029 : case ObjCIsaExprClass:
1030 : case StringLiteralClass: // C99 6.5.1p4
1031 : case ObjCEncodeExprClass: // @encode behaves like its string in every way.
1032 625: return LV_Valid;
1033 : case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2))))
1034 : // For vectors, make sure base is an lvalue (i.e. not a function call).
104: branch 5 taken
738: branch 6 taken
1035 842: if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType())
1036 104: return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx);
1037 738: return LV_Valid;
1038 : case DeclRefExprClass: { // C99 6.5.1p2
1039 33431: const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl();
26967: branch 1 taken
6464: branch 2 taken
1040 33431: if (DeclCanBeLvalue(RefdDecl, Ctx))
1041 26967: return LV_Valid;
1042 6464: break;
1043 : }
1044 : case BlockDeclRefExprClass: {
1045 146: const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
146: branch 2 taken
0: branch 3 not taken
1046 146: if (isa<VarDecl>(BDR->getDecl()))
1047 146: return LV_Valid;
1048 0: break;
1049 : }
1050 : case MemberExprClass: {
1051 2045: const MemberExpr *m = cast<MemberExpr>(this);
1728: branch 1 taken
317: branch 2 taken
1052 2045: if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4:
1053 1728: NamedDecl *Member = m->getMemberDecl();
1054 : // C++ [expr.ref]p4:
1055 : // If E2 is declared to have type "reference to T", then E1.E2
1056 : // is an lvalue.
1728: branch 1 taken
0: branch 2 not taken
1057 1728: if (ValueDecl *Value = dyn_cast<ValueDecl>(Member))
156: branch 3 taken
1572: branch 4 taken
1058 1728: if (Value->getType()->isReferenceType())
1059 156: return LV_Valid;
1060 :
1061 : // -- If E2 is a static data member [...] then E1.E2 is an lvalue.
23: branch 1 taken
1549: branch 2 taken
23: branch 5 taken
0: branch 6 not taken
23: branch 7 taken
1549: branch 8 taken
1062 1572: if (isa<VarDecl>(Member) && Member->getDeclContext()->isRecord())
1063 23: return LV_Valid;
1064 :
1065 : // -- If E2 is a non-static data member [...]. If E1 is an
1066 : // lvalue, then E1.E2 is an lvalue.
1529: branch 1 taken
20: branch 2 taken
1067 1549: if (isa<FieldDecl>(Member)) {
630: branch 1 taken
899: branch 2 taken
1068 1529: if (m->isArrow())
1069 630: return LV_Valid;
1070 899: Expr *BaseExp = m->getBase();
1071 : return (BaseExp->getStmtClass() == ObjCPropertyRefExprClass) ?
899: branch 1 taken
0: branch 2 not taken
1072 899: LV_SubObjCPropertySetting : BaseExp->isLvalue(Ctx);
1073 : }
1074 :
1075 : // -- If it refers to a static member function [...], then
1076 : // E1.E2 is an lvalue.
1077 : // -- Otherwise, if E1.E2 refers to a non-static member
1078 : // function [...], then E1.E2 is not an lvalue.
10: branch 1 taken
10: branch 2 taken
1079 20: if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member))
6: branch 1 taken
4: branch 2 taken
1080 10: return Method->isStatic()? LV_Valid : LV_MemberFunction;
1081 :
1082 : // -- If E2 is a member enumerator [...], the expression E1.E2
1083 : // is not an lvalue.
10: branch 1 taken
0: branch 2 not taken
1084 10: if (isa<EnumConstantDecl>(Member))
1085 10: return LV_InvalidExpression;
1086 :
1087 : // Not an lvalue.
1088 0: return LV_InvalidExpression;
1089 : }
1090 :
1091 : // C99 6.5.2.3p4
91: branch 1 taken
226: branch 2 taken
1092 317: if (m->isArrow())
1093 91: return LV_Valid;
1094 226: Expr *BaseExp = m->getBase();
1095 : return (BaseExp->getStmtClass() == ObjCPropertyRefExprClass) ?
224: branch 1 taken
2: branch 2 taken
1096 226: LV_SubObjCPropertySetting : BaseExp->isLvalue(Ctx);
1097 : }
1098 : case UnaryOperatorClass:
1111: branch 2 taken
1065: branch 3 taken
1099 2176: if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref)
1100 1111: return LV_Valid; // C99 6.5.3p4
1101 :
1063: branch 2 taken
2: branch 3 taken
1049: branch 6 taken
14: branch 7 taken
2: branch 10 taken
1047: branch 11 taken
18: branch 12 taken
1047: branch 13 taken
1102 1065: if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real ||
1103 : cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag ||
1104 : cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension)
1105 18: return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx); // GNU.
1106 :
1047: branch 1 taken
0: branch 2 not taken
992: branch 5 taken
55: branch 6 taken
1: branch 9 taken
991: branch 10 taken
56: branch 11 taken
991: branch 12 taken
1107 1047: if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1
1108 : (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc ||
1109 : cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec))
1110 56: return LV_Valid;
1111 991: break;
1112 : case ImplicitCastExprClass:
1113 : return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid
728: branch 2 taken
276: branch 3 taken
1114 1004: : LV_InvalidExpression;
1115 : case ParenExprClass: // C99 6.5.1p5
1116 984: return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx);
1117 : case BinaryOperatorClass:
1118 : case CompoundAssignOperatorClass: {
1119 923: const BinaryOperator *BinOp = cast<BinaryOperator>(this);
1120 :
917: branch 1 taken
6: branch 2 taken
10: branch 4 taken
907: branch 5 taken
10: branch 6 taken
913: branch 7 taken
1121 923: if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1
1122 : BinOp->getOpcode() == BinaryOperator::Comma)
1123 10: return BinOp->getRHS()->isLvalue(Ctx);
1124 :
1125 : // C++ [expr.mptr.oper]p6
1126 : // The result of a .* expression is an lvalue only if its first operand is
1127 : // an lvalue and its second operand is a pointer to data member.
17: branch 1 taken
896: branch 2 taken
17: branch 6 taken
0: branch 7 not taken
17: branch 8 taken
896: branch 9 taken
1128 913: if (BinOp->getOpcode() == BinaryOperator::PtrMemD &&
1129 : !BinOp->getType()->isFunctionType())
1130 17: return BinOp->getLHS()->isLvalue(Ctx);
1131 :
1132 : // The result of an ->* expression is an lvalue only if its second operand
1133 : // is a pointer to data member.
30: branch 1 taken
866: branch 2 taken
30: branch 6 taken
0: branch 7 not taken
30: branch 8 taken
866: branch 9 taken
1134 896: if (BinOp->getOpcode() == BinaryOperator::PtrMemI &&
1135 : !BinOp->getType()->isFunctionType()) {
1136 30: QualType Ty = BinOp->getRHS()->getType();
30: branch 2 taken
0: branch 3 not taken
30: branch 6 taken
0: branch 7 not taken
30: branch 8 taken
0: branch 9 not taken
1137 30: if (Ty->isMemberPointerType() && !Ty->isMemberFunctionPointerType())
1138 30: return LV_Valid;
1139 : }
1140 :
824: branch 1 taken
42: branch 2 taken
1141 866: if (!BinOp->isAssignmentOp())
1142 824: return LV_InvalidExpression;
1143 :
40: branch 1 taken
2: branch 2 taken
1144 42: if (Ctx.getLangOptions().CPlusPlus)
1145 : // C++ [expr.ass]p1:
1146 : // The result of an assignment operation [...] is an lvalue.
1147 40: return LV_Valid;
1148 :
1149 :
1150 : // C99 6.5.16:
1151 : // An assignment expression [...] is not an lvalue.
1152 2: return LV_InvalidExpression;
1153 : }
1154 : case CallExprClass:
1155 : case CXXOperatorCallExprClass:
1156 : case CXXMemberCallExprClass: {
1157 : // C++0x [expr.call]p10
1158 : // A function call is an lvalue if and only if the result type
1159 : // is an lvalue reference.
1160 10045: QualType ReturnType = cast<CallExpr>(this)->getCallReturnType();
1636: branch 2 taken
8409: branch 3 taken
1161 10045: if (ReturnType->isLValueReferenceType())
1162 1636: return LV_Valid;
1163 :
1164 8409: break;
1165 : }
1166 : case CompoundLiteralExprClass: // C99 6.5.2.5p5
1167 98: return LV_Valid;
1168 : case ChooseExprClass:
1169 : // __builtin_choose_expr is an lvalue if the selected operand is.
1170 4: return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)->isLvalue(Ctx);
1171 : case ExtVectorElementExprClass:
4: branch 2 taken
41: branch 3 taken
1172 45: if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements())
1173 4: return LV_DuplicateVectorComponents;
1174 41: return LV_Valid;
1175 : case ObjCIvarRefExprClass: // ObjC instance variables are lvalues.
1176 218: return LV_Valid;
1177 : case ObjCPropertyRefExprClass: // FIXME: check if read-only property.
1178 96: return LV_Valid;
1179 : case ObjCImplicitSetterGetterRefExprClass: // FIXME: check if read-only property.
1180 22: return LV_Valid;
1181 : case PredefinedExprClass:
1182 52: return LV_Valid;
1183 : case UnresolvedLookupExprClass:
1184 206: return LV_Valid;
1185 : case CXXDefaultArgExprClass:
1186 6: return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx);
1187 : case CStyleCastExprClass:
1188 : case CXXFunctionalCastExprClass:
1189 : case CXXStaticCastExprClass:
1190 : case CXXDynamicCastExprClass:
1191 : case CXXReinterpretCastExprClass:
1192 : case CXXConstCastExprClass:
1193 : // The result of an explicit cast is an lvalue if the type we are
1194 : // casting to is an lvalue reference type. See C++ [expr.cast]p1,
1195 : // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2,
1196 : // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1.
303: branch 4 taken
4249: branch 5 taken
1197 4552: if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()->
1198 : isLValueReferenceType())
1199 303: return LV_Valid;
1200 4249: break;
1201 : case CXXTypeidExprClass:
1202 : // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ...
1203 119: return LV_Valid;
1204 : case CXXBindTemporaryExprClass:
1205 : return cast<CXXBindTemporaryExpr>(this)->getSubExpr()->
1206 72: isLvalueInternal(Ctx);
1207 : case CXXBindReferenceExprClass:
1208 : // Something that's bound to a reference is always an lvalue.
1209 0: return LV_Valid;
1210 : case ConditionalOperatorClass: {
1211 : // Complicated handling is only for C++.
6: branch 1 taken
139: branch 2 taken
1212 145: if (!Ctx.getLangOptions().CPlusPlus)
1213 6: return LV_InvalidExpression;
1214 :
1215 : // Sema should have taken care to ensure that a CXXTemporaryObjectExpr is
1216 : // everywhere there's an object converted to an rvalue. Also, any other
1217 : // casts should be wrapped by ImplicitCastExprs. There's just the special
1218 : // case involving throws to work out.
1219 139: const ConditionalOperator *Cond = cast<ConditionalOperator>(this);
1220 139: Expr *True = Cond->getTrueExpr();
1221 139: Expr *False = Cond->getFalseExpr();
1222 : // C++0x 5.16p2
1223 : // If either the second or the third operand has type (cv) void, [...]
1224 : // the result [...] is an rvalue.
135: branch 3 taken
4: branch 4 taken
2: branch 8 taken
133: branch 9 taken
6: branch 10 taken
133: branch 11 taken
1225 139: if (True->getType()->isVoidType() || False->getType()->isVoidType())
1226 6: return LV_InvalidExpression;
1227 :
1228 : // Both sides must be lvalues for the result to be an lvalue.
46: branch 1 taken
87: branch 2 taken
21: branch 4 taken
25: branch 5 taken
108: branch 6 taken
25: branch 7 taken
1229 133: if (True->isLvalue(Ctx) != LV_Valid || False->isLvalue(Ctx) != LV_Valid)
1230 108: return LV_InvalidExpression;
1231 :
1232 : // That's it.
1233 25: return LV_Valid;
1234 : }
1235 :
1236 : case Expr::CXXExprWithTemporariesClass:
1237 2: return cast<CXXExprWithTemporaries>(this)->getSubExpr()->isLvalue(Ctx);
1238 :
1239 : case Expr::ObjCMessageExprClass:
20: branch 0 taken
0: branch 1 not taken
1240 20: if (const ObjCMethodDecl *Method
1241 20: = cast<ObjCMessageExpr>(this)->getMethodDecl())
6: branch 3 taken
14: branch 4 taken
1242 20: if (Method->getResultType()->isLValueReferenceType())
1243 6: return LV_Valid;
1244 : break;
1245 :
1246 : default:
1247 : break;
1248 : }
1249 28644: return LV_InvalidExpression;
1250 : }
1251 :
1252 : /// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
1253 : /// does not have an incomplete type, does not have a const-qualified type, and
1254 : /// if it is a structure or union, does not have any member (including,
1255 : /// recursively, any member or element of all contained aggregates or unions)
1256 : /// with a const-qualified type.
1257 : Expr::isModifiableLvalueResult
1258 4549: Expr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const {
1259 4549: isLvalueResult lvalResult = isLvalue(Ctx);
1260 :
4525: branch 0 taken
0: branch 1 not taken
5: branch 2 taken
4: branch 3 taken
13: branch 4 taken
0: branch 5 not taken
2: branch 6 taken
0: branch 7 not taken
1261 4549: switch (lvalResult) {
1262 : case LV_Valid:
1263 : // C++ 3.10p11: Functions cannot be modified, but pointers to
1264 : // functions can be modifiable.
789: branch 1 taken
3736: branch 2 taken
0: branch 5 not taken
789: branch 6 taken
0: branch 7 not taken
4525: branch 8 taken
1265 4525: if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType())
1266 0: return MLV_NotObjectType;
1267 4525: break;
1268 :
1269 0: case LV_NotObjectType: return MLV_NotObjectType;
1270 5: case LV_IncompleteVoidType: return MLV_IncompleteVoidType;
1271 4: case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents;
1272 : case LV_InvalidExpression:
1273 : // If the top level is a C-style cast, and the subexpression is a valid
1274 : // lvalue, then this is probably a use of the old-school "cast as lvalue"
1275 : // GCC extension. We don't support it, but we want to produce good
1276 : // diagnostics when it happens so that the user knows why.
4: branch 2 taken
9: branch 3 taken
1277 13: if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(IgnoreParens())) {
3: branch 2 taken
1: branch 3 taken
1278 4: if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) {
3: branch 0 taken
0: branch 1 not taken
1279 3: if (Loc)
1280 3: *Loc = CE->getLParenLoc();
1281 3: return MLV_LValueCast;
1282 : }
1283 : }
1284 10: return MLV_InvalidExpression;
1285 0: case LV_MemberFunction: return MLV_MemberFunction;
1286 2: case LV_SubObjCPropertySetting: return MLV_SubObjCPropertySetting;
1287 : }
1288 :
1289 : // The following is illegal:
1290 : // void takeclosure(void (^C)(void));
1291 : // void func() { int x = 1; takeclosure(^{ x = 7; }); }
1292 : //
81: branch 1 taken
4444: branch 2 taken
1293 4525: if (const BlockDeclRefExpr *BDR = dyn_cast<BlockDeclRefExpr>(this)) {
1: branch 1 taken
80: branch 2 taken
1: branch 5 taken
0: branch 6 not taken
1: branch 7 taken
80: branch 8 taken
1294 81: if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl()))
1295 1: return MLV_NotBlockQualified;
1296 : }
1297 :
1298 : // Assigning to an 'implicit' property?
22: branch 0 taken
4502: branch 1 taken
1299 4524: if (const ObjCImplicitSetterGetterRefExpr* Expr =
1300 4524: dyn_cast<ObjCImplicitSetterGetterRefExpr>(this)) {
2: branch 1 taken
20: branch 2 taken
1301 22: if (Expr->getSetterMethod() == 0)
1302 2: return MLV_NoSetterProperty;
1303 : }
1304 :
1305 4522: QualType CT = Ctx.getCanonicalType(getType());
1306 :
17: branch 1 taken
4505: branch 2 taken
1307 4522: if (CT.isConstQualified())
1308 17: return MLV_ConstQualified;
0: branch 2 not taken
4505: branch 3 taken
1309 4505: if (CT->isArrayType())
1310 0: return MLV_ArrayType;
1: branch 2 taken
4504: branch 3 taken
1311 4505: if (CT->isIncompleteType())
1312 1: return MLV_IncompleteType;
1313 :
54: branch 2 taken
4450: branch 3 taken
1314 4504: if (const RecordType *r = CT->getAs<RecordType>()) {
0: branch 1 not taken
54: branch 2 taken
1315 54: if (r->hasConstFields())
1316 0: return MLV_ConstQualified;
1317 : }
1318 :
1319 4504: return MLV_Valid;
1320 : }
1321 :
1322 : /// isOBJCGCCandidate - Check if an expression is objc gc'able.
1323 : /// returns true, if it is; false otherwise.
1324 238: bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const {
0: branch 1 not taken
37: branch 2 taken
8: branch 3 taken
2: branch 4 taken
48: branch 5 taken
2: branch 6 taken
38: branch 7 taken
30: branch 8 taken
73: branch 9 taken
1325 238: switch (getStmtClass()) {
1326 : default:
1327 0: return false;
1328 : case ObjCIvarRefExprClass:
1329 37: return true;
1330 : case Expr::UnaryOperatorClass:
1331 8: return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1332 : case ParenExprClass:
1333 2: return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1334 : case ImplicitCastExprClass:
1335 48: return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1336 : case CStyleCastExprClass:
1337 2: return cast<CStyleCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1338 : case DeclRefExprClass: {
1339 38: const Decl *D = cast<DeclRefExpr>(this)->getDecl();
38: branch 1 taken
0: branch 2 not taken
1340 38: if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
33: branch 1 taken
5: branch 2 taken
1341 38: if (VD->hasGlobalStorage())
1342 33: return true;
1343 5: QualType T = VD->getType();
1344 : // dereferencing to a pointer is always a gc'able candidate,
1345 : // unless it is __weak.
1346 : return T->isPointerType() &&
5: branch 2 taken
0: branch 3 not taken
4: branch 5 taken
1: branch 6 taken
1347 5: (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak);
1348 : }
1349 0: return false;
1350 : }
1351 : case MemberExprClass: {
1352 30: const MemberExpr *M = cast<MemberExpr>(this);
1353 30: return M->getBase()->isOBJCGCCandidate(Ctx);
1354 : }
1355 : case ArraySubscriptExprClass:
1356 73: return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate(Ctx);
1357 : }
1358 : }
1359 108713: Expr* Expr::IgnoreParens() {
1360 108713: Expr* E = this;
3786: branch 1 taken
108713: branch 2 taken
1361 116285: while (ParenExpr* P = dyn_cast<ParenExpr>(E))
1362 3786: E = P->getSubExpr();
1363 :
1364 108713: return E;
1365 : }
1366 :
1367 : /// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr
1368 : /// or CastExprs or ImplicitCastExprs, returning their operand.
1369 9800: Expr *Expr::IgnoreParenCasts() {
1370 9800: Expr *E = this;
1371 7856: while (true) {
469: branch 1 taken
17187: branch 2 taken
1372 17656: if (ParenExpr *P = dyn_cast<ParenExpr>(E))
1373 469: E = P->getSubExpr();
7387: branch 1 taken
9800: branch 2 taken
1374 17187: else if (CastExpr *P = dyn_cast<CastExpr>(E))
1375 7387: E = P->getSubExpr();
1376 : else
1377 9800: return E;
1378 : }
1379 : }
1380 :
1381 : /// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
1382 : /// value (including ptr->int casts of the same size). Strip off any
1383 : /// ParenExpr or CastExprs, returning their operand.
1384 91: Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
1385 91: Expr *E = this;
1386 47: while (true) {
6: branch 1 taken
132: branch 2 taken
1387 138: if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
1388 6: E = P->getSubExpr();
1389 6: continue;
1390 : }
1391 :
45: branch 1 taken
87: branch 2 taken
1392 132: if (CastExpr *P = dyn_cast<CastExpr>(E)) {
1393 : // We ignore integer <-> casts that are of the same width, ptr<->ptr and
1394 : // ptr<->int casts of the same width. We also ignore all identify casts.
1395 45: Expr *SE = P->getSubExpr();
1396 :
36: branch 3 taken
9: branch 4 taken
1397 45: if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
1398 36: E = SE;
1399 36: continue;
1400 : }
1401 :
7: branch 3 taken
2: branch 4 taken
3: branch 8 taken
4: branch 9 taken
2: branch 13 taken
3: branch 14 taken
2: branch 18 taken
0: branch 19 not taken
5: branch 24 taken
0: branch 25 not taken
5: branch 26 taken
4: branch 27 taken
1402 9: if ((E->getType()->isPointerType() || E->getType()->isIntegralType()) &&
1403 : (SE->getType()->isPointerType() || SE->getType()->isIntegralType()) &&
1404 : Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
1405 5: E = SE;
1406 5: continue;
1407 : }
1408 : }
1409 :
1410 91: return E;
1411 : }
1412 : }
1413 :
1414 43: bool Expr::isDefaultArgument() const {
1415 43: const Expr *E = this;
2: branch 1 taken
43: branch 2 taken
1416 47: while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
1417 2: E = ICE->getSubExprAsWritten();
1418 :
1419 43: return isa<CXXDefaultArgExpr>(E);
1420 : }
1421 :
1422 : /// hasAnyTypeDependentArguments - Determines if any of the expressions
1423 : /// in Exprs is type-dependent.
1424 44851: bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
33697: branch 0 taken
44730: branch 1 taken
1425 78427: for (unsigned I = 0; I < NumExprs; ++I)
121: branch 1 taken
33576: branch 2 taken
1426 33697: if (Exprs[I]->isTypeDependent())
1427 121: return true;
1428 :
1429 44730: return false;
1430 : }
1431 :
1432 : /// hasAnyValueDependentArguments - Determines if any of the expressions
1433 : /// in Exprs is value-dependent.
1434 18352: bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
10827: branch 0 taken
18282: branch 1 taken
1435 29109: for (unsigned I = 0; I < NumExprs; ++I)
70: branch 1 taken
10757: branch 2 taken
1436 10827: if (Exprs[I]->isValueDependent())
1437 70: return true;
1438 :
1439 18282: return false;
1440 : }
1441 :
1442 1973: bool Expr::isConstantInitializer(ASTContext &Ctx) const {
1443 : // This function is attempting whether an expression is an initializer
1444 : // which can be evaluated at compile-time. isEvaluatable handles most
1445 : // of the cases, but it can't deal with some initializer-specific
1446 : // expressions, and it can't deal with aggregates; we deal with those here,
1447 : // and fall back to isEvaluatable for the other cases.
1448 :
1449 : // FIXME: This function assumes the variable being assigned to
1450 : // isn't a reference type!
1451 :
690: branch 1 taken
47: branch 2 taken
10: branch 3 taken
406: branch 4 taken
67: branch 5 taken
14: branch 6 taken
136: branch 7 taken
31: branch 8 taken
572: branch 9 taken
1452 1973: switch (getStmtClass()) {
1453 690: default: break;
1454 : case StringLiteralClass:
1455 : case ObjCStringLiteralClass:
1456 : case ObjCEncodeExprClass:
1457 47: return true;
1458 : case CompoundLiteralExprClass: {
1459 : // This handles gcc's extension that allows global initializers like
1460 : // "struct x {int x;} x = (struct x) {};".
1461 : // FIXME: This accepts other cases it shouldn't!
1462 10: const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
1463 10: return Exp->isConstantInitializer(Ctx);
1464 : }
1465 : case InitListExprClass: {
1466 : // FIXME: This doesn't deal with fields with reference types correctly.
1467 : // FIXME: This incorrectly allows pointers cast to integers to be assigned
1468 : // to bitfields.
1469 406: const InitListExpr *Exp = cast<InitListExpr>(this);
1470 406: unsigned numInits = Exp->getNumInits();
890: branch 0 taken
391: branch 1 taken
1471 1281: for (unsigned i = 0; i < numInits; i++) {
15: branch 2 taken
875: branch 3 taken
1472 890: if (!Exp->getInit(i)->isConstantInitializer(Ctx))
1473 15: return false;
1474 : }
1475 391: return true;
1476 : }
1477 : case ImplicitValueInitExprClass:
1478 67: return true;
1479 : case ParenExprClass:
1480 14: return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1481 : case UnaryOperatorClass: {
1482 136: const UnaryOperator* Exp = cast<UnaryOperator>(this);
1: branch 1 taken
135: branch 2 taken
1483 136: if (Exp->getOpcode() == UnaryOperator::Extension)
1484 1: return Exp->getSubExpr()->isConstantInitializer(Ctx);
1485 135: break;
1486 : }
1487 : case BinaryOperatorClass: {
1488 : // Special case &&foo - &&bar. It would be nice to generalize this somehow
1489 : // but this handles the common case.
1490 31: const BinaryOperator *Exp = cast<BinaryOperator>(this);
4: branch 1 taken
27: branch 2 taken
1: branch 6 taken
3: branch 7 taken
1: branch 11 taken
0: branch 12 not taken
1: branch 13 taken
30: branch 14 taken
1491 31: if (Exp->getOpcode() == BinaryOperator::Sub &&
1492 : isa<AddrLabelExpr>(Exp->getLHS()->IgnoreParenNoopCasts(Ctx)) &&
1493 : isa<AddrLabelExpr>(Exp->getRHS()->IgnoreParenNoopCasts(Ctx)))
1494 1: return true;
1495 30: break;
1496 : }
1497 : case ImplicitCastExprClass:
1498 : case CStyleCastExprClass:
1499 : // Handle casts with a destination that's a struct or union; this
1500 : // deals with both the gcc no-op struct cast extension and the
1501 : // cast-to-union extension.
13: branch 3 taken
559: branch 4 taken
1502 572: if (getType()->isRecordType())
1503 13: return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1504 :
1505 : // Integer->integer casts can be handled here, which is important for
1506 : // things like (int)(&&x-&&y). Scary but true.
213: branch 3 taken
346: branch 4 taken
185: branch 10 taken
28: branch 11 taken
185: branch 12 taken
374: branch 13 taken
1507 559: if (getType()->isIntegerType() &&
1508 : cast<CastExpr>(this)->getSubExpr()->getType()->isIntegerType())
1509 185: return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1510 :
1511 : break;
1512 : }
1513 1229: return isEvaluatable(Ctx);
1514 : }
1515 :
1516 : /// isIntegerConstantExpr - this recursive routine will test if an expression is
1517 : /// an integer constant expression.
1518 :
1519 : /// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
1520 : /// comma, etc
1521 : ///
1522 : /// FIXME: Handle offsetof. Two things to do: Handle GCC's __builtin_offsetof
1523 : /// to support gcc 4.0+ and handle the idiom GCC recognizes with a null pointer
1524 : /// cast+dereference.
1525 :
1526 : // CheckICE - This function does the fundamental ICE checking: the returned
1527 : // ICEDiag contains a Val of 0, 1, or 2, and a possibly null SourceLocation.
1528 : // Note that to reduce code duplication, this helper does no evaluation
1529 : // itself; the caller checks whether the expression is evaluatable, and
1530 : // in the rare cases where CheckICE actually cares about the evaluated
1531 : // value, it calls into Evalute.
1532 : //
1533 : // Meanings of Val:
1534 : // 0: This expression is an ICE if it can be evaluated by Evaluate.
1535 : // 1: This expression is not an ICE, but if it isn't evaluated, it's
1536 : // a legal subexpression for an ICE. This return value is used to handle
1537 : // the comma operator in C99 mode.
1538 : // 2: This expression is not an ICE, and is not a legal subexpression for one.
1539 :
1540 : struct ICEDiag {
1541 : unsigned Val;
1542 : SourceLocation Loc;
1543 :
1544 : public:
1545 393: ICEDiag(unsigned v, SourceLocation l) : Val(v), Loc(l) {}
1546 14784: ICEDiag() : Val(0) {}
1547 : };
1548 :
1549 14784: ICEDiag NoDiag() { return ICEDiag(); }
1550 :
1551 28: static ICEDiag CheckEvalInICE(const Expr* E, ASTContext &Ctx) {
1552 28: Expr::EvalResult EVResult;
24: branch 1 taken
4: branch 2 taken
24: branch 3 taken
0: branch 4 not taken
0: branch 6 not taken
24: branch 7 taken
4: branch 8 taken
24: branch 9 taken
1553 28: if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
1554 : !EVResult.Val.isInt()) {
1555 4: return ICEDiag(2, E->getLocStart());
1556 : }
1557 24: return NoDiag();
1558 : }
1559 :
1560 20537: static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) {
20537: branch 1 taken
0: branch 2 not taken
1561 20537: assert(!E->isValueDependent() && "Should not see value dependent exprs!");
35: branch 3 taken
20502: branch 4 taken
1562 20537: if (!E->getType()->isIntegralType()) {
1563 35: return ICEDiag(2, E->getLocStart());
1564 : }
1565 :
14: branch 1 taken
4: branch 2 taken
947: branch 3 taken
12736: branch 4 taken
34: branch 5 taken
1174: branch 6 taken
986: branch 7 taken
457: branch 8 taken
1923: branch 9 taken
1384: branch 10 taken
842: branch 11 taken
0: branch 12 not taken
1: branch 13 taken
0: branch 14 not taken
1566 20502: switch (E->getStmtClass()) {
1567 : #define STMT(Node, Base) case Expr::Node##Class:
1568 : #define EXPR(Node, Base)
1569 : #include "clang/AST/StmtNodes.def"
1570 : case Expr::PredefinedExprClass:
1571 : case Expr::FloatingLiteralClass:
1572 : case Expr::ImaginaryLiteralClass:
1573 : case Expr::StringLiteralClass:
1574 : case Expr::ArraySubscriptExprClass:
1575 : case Expr::MemberExprClass:
1576 : case Expr::CompoundAssignOperatorClass:
1577 : case Expr::CompoundLiteralExprClass:
1578 : case Expr::ExtVectorElementExprClass:
1579 : case Expr::InitListExprClass:
1580 : case Expr::DesignatedInitExprClass:
1581 : case Expr::ImplicitValueInitExprClass:
1582 : case Expr::ParenListExprClass:
1583 : case Expr::VAArgExprClass:
1584 : case Expr::AddrLabelExprClass:
1585 : case Expr::StmtExprClass:
1586 : case Expr::CXXMemberCallExprClass:
1587 : case Expr::CXXDynamicCastExprClass:
1588 : case Expr::CXXTypeidExprClass:
1589 : case Expr::CXXNullPtrLiteralExprClass:
1590 : case Expr::CXXThisExprClass:
1591 : case Expr::CXXThrowExprClass:
1592 : case Expr::CXXNewExprClass:
1593 : case Expr::CXXDeleteExprClass:
1594 : case Expr::CXXPseudoDestructorExprClass:
1595 : case Expr::UnresolvedLookupExprClass:
1596 : case Expr::DependentScopeDeclRefExprClass:
1597 : case Expr::CXXConstructExprClass:
1598 : case Expr::CXXBindTemporaryExprClass:
1599 : case Expr::CXXBindReferenceExprClass:
1600 : case Expr::CXXExprWithTemporariesClass:
1601 : case Expr::CXXTemporaryObjectExprClass:
1602 : case Expr::CXXUnresolvedConstructExprClass:
1603 : case Expr::CXXDependentScopeMemberExprClass:
1604 : case Expr::UnresolvedMemberExprClass:
1605 : case Expr::ObjCStringLiteralClass:
1606 : case Expr::ObjCEncodeExprClass:
1607 : case Expr::ObjCMessageExprClass:
1608 : case Expr::ObjCSelectorExprClass:
1609 : case Expr::ObjCProtocolExprClass:
1610 : case Expr::ObjCIvarRefExprClass:
1611 : case Expr::ObjCPropertyRefExprClass:
1612 : case Expr::ObjCImplicitSetterGetterRefExprClass:
1613 : case Expr::ObjCSuperExprClass:
1614 : case Expr::ObjCIsaExprClass:
1615 : case Expr::ShuffleVectorExprClass:
1616 : case Expr::BlockExprClass:
1617 : case Expr::BlockDeclRefExprClass:
1618 : case Expr::NoStmtClass:
1619 14: return ICEDiag(2, E->getLocStart());
1620 :
1621 : case Expr::GNUNullExprClass:
1622 : // GCC considers the GNU __null value to be an integral constant expression.
1623 4: return NoDiag();
1624 :
1625 : case Expr::ParenExprClass:
1626 947: return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
1627 : case Expr::IntegerLiteralClass:
1628 : case Expr::CharacterLiteralClass:
1629 : case Expr::CXXBoolLiteralExprClass:
1630 : case Expr::CXXZeroInitValueExprClass:
1631 : case Expr::TypesCompatibleExprClass:
1632 : case Expr::UnaryTypeTraitExprClass:
1633 12736: return NoDiag();
1634 : case Expr::CallExprClass:
1635 : case Expr::CXXOperatorCallExprClass: {
1636 34: const CallExpr *CE = cast<CallExpr>(E);
10: branch 1 taken
24: branch 2 taken
1637 34: if (CE->isBuiltinCall(Ctx))
1638 10: return CheckEvalInICE(E, Ctx);
1639 24: return ICEDiag(2, E->getLocStart());
1640 : }
1641 : case Expr::DeclRefExprClass:
481: branch 3 taken
693: branch 4 taken
1642 1174: if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl()))
1643 481: return NoDiag();
454: branch 1 taken
239: branch 2 taken
432: branch 5 taken
22: branch 6 taken
432: branch 7 taken
261: branch 8 taken
1644 693: if (Ctx.getLangOptions().CPlusPlus &&
1645 : E->getType().getCVRQualifiers() == Qualifiers::Const) {
1646 : // C++ 7.1.5.1p2
1647 : // A variable of non-volatile const-qualified integral or enumeration
1648 : // type initialized by an ICE can be used in ICEs.
432: branch 0 taken
0: branch 1 not taken
1649 432: if (const VarDecl *Dcl =
1650 432: dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
1651 432: Qualifiers Quals = Ctx.getCanonicalType(Dcl->getType()).getQualifiers();
432: branch 1 taken
0: branch 2 not taken
0: branch 4 not taken
432: branch 5 taken
0: branch 6 not taken
432: branch 7 taken
1652 432: if (Quals.hasVolatile() || !Quals.hasConst())
1653 0: return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
1654 :
1655 : // Look for a declaration of this variable that has an initializer.
1656 432: const VarDecl *ID = 0;
1657 432: const Expr *Init = Dcl->getAnyInitializer(ID);
430: branch 0 taken
2: branch 1 taken
1658 432: if (Init) {
244: branch 1 taken
186: branch 2 taken
1659 430: if (ID->isInitKnownICE()) {
1660 : // We have already checked whether this subexpression is an
1661 : // integral constant expression.
244: branch 1 taken
0: branch 2 not taken
1662 244: if (ID->isInitICE())
1663 244: return NoDiag();
1664 : else
1665 0: return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
1666 : }
1667 :
1668 : // It's an ICE whether or not the definition we found is
1669 : // out-of-line. See DR 721 and the discussion in Clang PR
1670 : // 6206 for details.
1671 :
1: branch 1 taken
185: branch 2 taken
1672 186: if (Dcl->isCheckingICE()) {
1673 1: return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
1674 : }
1675 :
1676 185: Dcl->setCheckingICE();
1677 185: ICEDiag Result = CheckICE(Init, Ctx);
1678 : // Cache the result of the ICE test.
1679 185: Dcl->setInitKnownICE(Result.Val == 0);
1680 185: return Result;
1681 : }
1682 : }
1683 : }
1684 263: return ICEDiag(2, E->getLocStart());
1685 : case Expr::UnaryOperatorClass: {
1686 986: const UnaryOperator *Exp = cast<UnaryOperator>(E);
2: branch 1 taken
966: branch 2 taken
18: branch 3 taken
0: branch 4 not taken
1687 986: switch (Exp->getOpcode()) {
1688 : case UnaryOperator::PostInc:
1689 : case UnaryOperator::PostDec:
1690 : case UnaryOperator::PreInc:
1691 : case UnaryOperator::PreDec:
1692 : case UnaryOperator::AddrOf:
1693 : case UnaryOperator::Deref:
1694 2: return ICEDiag(2, E->getLocStart());
1695 :
1696 : case UnaryOperator::Extension:
1697 : case UnaryOperator::LNot:
1698 : case UnaryOperator::Plus:
1699 : case UnaryOperator::Minus:
1700 : case UnaryOperator::Not:
1701 : case UnaryOperator::Real:
1702 : case UnaryOperator::Imag:
1703 966: return CheckICE(Exp->getSubExpr(), Ctx);
1704 : case UnaryOperator::OffsetOf:
1705 : // Note that per C99, offsetof must be an ICE. And AFAIK, using
1706 : // Evaluate matches the proposed gcc behavior for cases like
1707 : // "offsetof(struct s{int x[4];}, x[!.0])". This doesn't affect
1708 : // compliance: we should warn earlier for offsetof expressions with
1709 : // array subscripts that aren't ICEs, and if the array subscripts
1710 : // are ICEs, the value of the offsetof must be an integer constant.
1711 18: return CheckEvalInICE(E, Ctx);
1712 : }
1713 : }
1714 : case Expr::SizeOfAlignOfExprClass: {
1715 457: const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(E);
417: branch 1 taken
40: branch 2 taken
0: branch 6 not taken
417: branch 7 taken
0: branch 8 not taken
457: branch 9 taken
1716 457: if (Exp->isSizeOf() && Exp->getTypeOfArgument()->isVariableArrayType())
1717 0: return ICEDiag(2, E->getLocStart());
1718 457: return NoDiag();
1719 : }
1720 : case Expr::BinaryOperatorClass: {
1721 1923: const BinaryOperator *Exp = cast<BinaryOperator>(E);
5: branch 1 taken
1906: branch 2 taken
12: branch 3 taken
0: branch 4 not taken
1722 1923: switch (Exp->getOpcode()) {
1723 : case BinaryOperator::PtrMemD:
1724 : case BinaryOperator::PtrMemI:
1725 : case BinaryOperator::Assign:
1726 : case BinaryOperator::MulAssign:
1727 : case BinaryOperator::DivAssign:
1728 : case BinaryOperator::RemAssign:
1729 : case BinaryOperator::AddAssign:
1730 : case BinaryOperator::SubAssign:
1731 : case BinaryOperator::ShlAssign:
1732 : case BinaryOperator::ShrAssign:
1733 : case BinaryOperator::AndAssign:
1734 : case BinaryOperator::XorAssign:
1735 : case BinaryOperator::OrAssign:
1736 5: return ICEDiag(2, E->getLocStart());
1737 :
1738 : case BinaryOperator::Mul:
1739 : case BinaryOperator::Div:
1740 : case BinaryOperator::Rem:
1741 : case BinaryOperator::Add:
1742 : case BinaryOperator::Sub:
1743 : case BinaryOperator::Shl:
1744 : case BinaryOperator::Shr:
1745 : case BinaryOperator::LT:
1746 : case BinaryOperator::GT:
1747 : case BinaryOperator::LE:
1748 : case BinaryOperator::GE:
1749 : case BinaryOperator::EQ:
1750 : case BinaryOperator::NE:
1751 : case BinaryOperator::And:
1752 : case BinaryOperator::Xor:
1753 : case BinaryOperator::Or:
1754 : case BinaryOperator::Comma: {
1755 1906: ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
1756 1906: ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
1860: branch 1 taken
46: branch 2 taken
2: branch 4 taken
1858: branch 5 taken
48: branch 6 taken
1858: branch 7 taken
1757 1906: if (Exp->getOpcode() == BinaryOperator::Div ||
1758 : Exp->getOpcode() == BinaryOperator::Rem) {
1759 : // Evaluate gives an error for undefined Div/Rem, so make sure
1760 : // we don't evaluate one.
48: branch 0 taken
0: branch 1 not taken
48: branch 2 taken
0: branch 3 not taken
1761 48: if (LHSResult.Val != 2 && RHSResult.Val != 2) {
1762 48: llvm::APSInt REval = Exp->getRHS()->EvaluateAsInt(Ctx);
4: branch 1 taken
44: branch 2 taken
1763 48: if (REval == 0)
1764 9: return ICEDiag(1, E->getLocStart());
10: branch 1 taken
34: branch 2 taken
1: branch 4 taken
9: branch 5 taken
1: branch 6 taken
43: branch 7 taken
1765 44: if (REval.isSigned() && REval.isAllOnesValue()) {
1766 1: llvm::APSInt LEval = Exp->getLHS()->EvaluateAsInt(Ctx);
1: branch 1 taken
0: branch 2 not taken
1767 1: if (LEval.isMinSignedValue())
0: branch 3 not taken
1: branch 4 taken
1768 1: return ICEDiag(1, E->getLocStart());
43: branch 1 taken
5: branch 2 taken
1769 48: }
1770 : }
1771 : }
6: branch 1 taken
1895: branch 2 taken
1772 1901: if (Exp->getOpcode() == BinaryOperator::Comma) {
6: branch 1 taken
0: branch 2 not taken
1773 6: if (Ctx.getLangOptions().C99) {
1774 : // C99 6.6p3 introduces a strange edge case: comma can be in an ICE
1775 : // if it isn't evaluated.
3: branch 0 taken
3: branch 1 taken
3: branch 2 taken
0: branch 3 not taken
1776 6: if (LHSResult.Val == 0 && RHSResult.Val == 0)
1777 3: return ICEDiag(1, E->getLocStart());
1778 : } else {
1779 : // In both C89 and C++, commas in ICEs are illegal.
1780 0: return ICEDiag(2, E->getLocStart());
1781 : }
1782 : }
1896: branch 0 taken
2: branch 1 taken
1783 1898: if (LHSResult.Val >= RHSResult.Val)
1784 1896: return LHSResult;
1785 2: return RHSResult;
1786 : }
1787 : case BinaryOperator::LAnd:
1788 : case BinaryOperator::LOr: {
1789 12: ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
1790 12: ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
7: branch 0 taken
5: branch 1 taken
2: branch 2 taken
5: branch 3 taken
1791 12: if (LHSResult.Val == 0 && RHSResult.Val == 1) {
1792 : // Rare case where the RHS has a comma "side-effect"; we need
1793 : // to actually check the condition to see whether the side
1794 : // with the comma is evaluated.
0: branch 5 not taken
2: branch 6 taken
1795 2: if ((Exp->getOpcode() == BinaryOperator::LAnd) !=
1796 : (Exp->getLHS()->EvaluateAsInt(Ctx) == 0))
1797 0: return RHSResult;
1798 2: return NoDiag();
1799 : }
1800 :
5: branch 0 taken
5: branch 1 taken
1801 10: if (LHSResult.Val >= RHSResult.Val)
1802 5: return LHSResult;
1803 5: return RHSResult;
1804 : }
1805 : }
1806 : }
1807 : case Expr::ImplicitCastExprClass:
1808 : case Expr::CStyleCastExprClass:
1809 : case Expr::CXXFunctionalCastExprClass:
1810 : case Expr::CXXNamedCastExprClass:
1811 : case Expr::CXXStaticCastExprClass:
1812 : case Expr::CXXReinterpretCastExprClass:
1813 : case Expr::CXXConstCastExprClass: {
1814 1384: const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
1328: branch 3 taken
56: branch 4 taken
1815 1384: if (SubExpr->getType()->isIntegralType())
1816 1328: return CheckICE(SubExpr, Ctx);
21: branch 2 taken
35: branch 3 taken
1817 56: if (isa<FloatingLiteral>(SubExpr->IgnoreParens()))
1818 21: return NoDiag();
1819 35: return ICEDiag(2, E->getLocStart());
1820 : }
1821 : case Expr::ConditionalOperatorClass: {
1822 842: const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
1823 : // If the condition (ignoring parens) is a __builtin_constant_p call,
1824 : // then only the true side is actually considered in an integer constant
1825 : // expression, and it is fully evaluated. This is an important GNU
1826 : // extension. See GCC PR38377 for discussion.
6: branch 3 taken
836: branch 4 taken
1827 842: if (const CallExpr *CallCE = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
6: branch 1 taken
0: branch 2 not taken
1828 6: if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) {
1829 6: Expr::EvalResult EVResult;
5: branch 1 taken
1: branch 2 taken
5: branch 3 taken
0: branch 4 not taken
1: branch 6 taken
4: branch 7 taken
2: branch 8 taken
4: branch 9 taken
1830 6: if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
1831 : !EVResult.Val.isInt()) {
1832 2: return ICEDiag(2, E->getLocStart());
1833 : }
1834 4: return NoDiag();
1835 : }
1836 836: ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
1837 836: ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx);
1838 836: ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
23: branch 0 taken
813: branch 1 taken
1839 836: if (CondResult.Val == 2)
1840 23: return CondResult;
1: branch 0 taken
812: branch 1 taken
1841 813: if (TrueResult.Val == 2)
1842 1: return TrueResult;
0: branch 0 not taken
812: branch 1 taken
1843 812: if (FalseResult.Val == 2)
1844 0: return FalseResult;
0: branch 0 not taken
812: branch 1 taken
1845 812: if (CondResult.Val == 1)
1846 0: return CondResult;
811: branch 0 taken
1: branch 1 taken
811: branch 2 taken
0: branch 3 not taken
1847 812: if (TrueResult.Val == 0 && FalseResult.Val == 0)
1848 811: return NoDiag();
1849 : // Rare case where the diagnostics depend on which side is evaluated
1850 : // Note that if we get here, CondResult is 0, and at least one of
1851 : // TrueResult and FalseResult is non-zero.
1: branch 4 taken
0: branch 5 not taken
1852 1: if (Exp->getCond()->EvaluateAsInt(Ctx) == 0) {
1853 1: return FalseResult;
1854 : }
1855 0: return TrueResult;
1856 : }
1857 : case Expr::CXXDefaultArgExprClass:
1858 0: return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
1859 : case Expr::ChooseExprClass: {
1860 1: return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(Ctx), Ctx);
1861 : }
1862 : }
1863 :
1864 : // Silence a GCC warning
1865 0: return ICEDiag(2, E->getLocStart());
1866 : }
1867 :
1868 : bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
1869 10766: SourceLocation *Loc, bool isEvaluated) const {
1870 10766: ICEDiag d = CheckICE(this, Ctx);
366: branch 0 taken
10400: branch 1 taken
1871 10766: if (d.Val != 0) {
6: branch 0 taken
360: branch 1 taken
1872 366: if (Loc) *Loc = d.Loc;
1873 366: return false;
1874 : }
1875 10400: EvalResult EvalResult;
0: branch 1 not taken
10400: branch 2 taken
1876 10400: if (!Evaluate(EvalResult, Ctx))
1877 0: llvm_unreachable("ICE cannot be evaluated!");
0: branch 0 not taken
10400: branch 1 taken
1878 10400: assert(!EvalResult.HasSideEffects && "ICE with side effects!");
10400: branch 1 taken
0: branch 2 not taken
1879 10400: assert(EvalResult.Val.isInt() && "ICE that isn't integer!");
1880 10400: Result = EvalResult.Val.getInt();
1881 10400: return true;
1882 : }
1883 :
1884 : /// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an
1885 : /// integer constant expression with the value zero, or if this is one that is
1886 : /// cast to void*.
1887 : bool Expr::isNullPointerConstant(ASTContext &Ctx,
1888 9763: NullPointerConstantValueDependence NPC) const {
6: branch 1 taken
9757: branch 2 taken
1889 9763: if (isValueDependent()) {
0: branch 0 not taken
4: branch 1 taken
2: branch 2 taken
0: branch 3 not taken
1890 6: switch (NPC) {
1891 : case NPC_NeverValueDependent:
1892 0: assert(false && "Unexpected value dependent expression!");
1893 : // If the unthinkable happens, fall through to the safest alternative.
1894 :
1895 : case NPC_ValueDependentIsNull:
4: branch 1 taken
0: branch 2 not taken
3: branch 6 taken
1: branch 7 taken
1896 4: return isTypeDependent() || getType()->isIntegralType();
1897 :
1898 : case NPC_ValueDependentIsNotNull:
1899 2: return false;
1900 : }
1901 : }
1902 :
1903 : // Strip off a cast to void*, if it exists. Except in C++.
751: branch 1 taken
9006: branch 2 taken
1904 9757: if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
637: branch 1 taken
114: branch 2 taken
1905 751: if (!Ctx.getLangOptions().CPlusPlus) {
1906 : // Check that it is a cast to void*.
566: branch 3 taken
71: branch 4 taken
1907 637: if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
1908 566: QualType Pointee = PT->getPointeeType();
491: branch 1 taken
75: branch 2 taken
288: branch 5 taken
203: branch 6 taken
265: branch 11 taken
23: branch 12 taken
265: branch 13 taken
301: branch 14 taken
1909 566: if (!Pointee.hasQualifiers() &&
1910 : Pointee->isVoidType() && // to void*
1911 : CE->getSubExpr()->getType()->isIntegerType()) // from int.
1912 265: return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1913 : }
1914 : }
177: branch 1 taken
8829: branch 2 taken
1915 9006: } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1916 : // Ignore the ImplicitCastExpr type entirely.
1917 177: return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
437: branch 1 taken
8392: branch 2 taken
1918 8829: } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1919 : // Accept ((void*)0) as a null pointer constant, as many other
1920 : // implementations do.
1921 437: return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
0: branch 0 not taken
8392: branch 1 taken
1922 8392: } else if (const CXXDefaultArgExpr *DefaultArg
1923 8392: = dyn_cast<CXXDefaultArgExpr>(this)) {
1924 : // See through default argument expressions
1925 0: return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
14: branch 1 taken
8378: branch 2 taken
1926 8392: } else if (isa<GNUNullExpr>(this)) {
1927 : // The GNU __null extension is always a null pointer constant.
1928 14: return true;
1929 : }
1930 :
1931 : // C++0x nullptr_t is always a null pointer constant.
42: branch 3 taken
8822: branch 4 taken
1932 8864: if (getType()->isNullPtrType())
1933 42: return true;
1934 :
1935 : // This expression must be an integer type.
2062: branch 3 taken
6760: branch 4 taken
686: branch 6 taken
1376: branch 7 taken
3: branch 11 taken
683: branch 12 taken
6763: branch 13 taken
2059: branch 14 taken
1936 8822: if (!getType()->isIntegerType() ||
1937 : (Ctx.getLangOptions().CPlusPlus && getType()->isEnumeralType()))
1938 6763: return false;
1939 :
1940 : // If we have an integer constant expression, we need to *evaluate* it and
1941 : // test for the value 0.
1942 2059: llvm::APSInt Result;
1929: branch 1 taken
130: branch 2 taken
1794: branch 4 taken
135: branch 5 taken
1943 2059: return isIntegerConstantExpr(Result, Ctx) && Result == 0;
1944 : }
1945 :
1946 48387: FieldDecl *Expr::getBitField() {
1947 48387: Expr *E = this->IgnoreParens();
1948 :
671: branch 1 taken
47996: branch 2 taken
1949 48947: while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
310: branch 1 taken
361: branch 2 taken
280: branch 4 taken
30: branch 5 taken
280: branch 6 taken
391: branch 7 taken
1950 671: if (ICE->isLvalueCast() && ICE->getCastKind() == CastExpr::CK_NoOp)
1951 280: E = ICE->getSubExpr()->IgnoreParens();
1952 : else
1953 391: break;
1954 : }
1955 :
1241: branch 1 taken
47146: branch 2 taken
1956 48387: if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
1236: branch 2 taken
5: branch 3 taken
1957 1241: if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
113: branch 1 taken
1123: branch 2 taken
1958 1236: if (Field->isBitField())
1959 113: return Field;
1960 :
2540: branch 1 taken
45734: branch 2 taken
1961 48274: if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E))
92: branch 1 taken
2448: branch 2 taken
92: branch 4 taken
0: branch 5 not taken
92: branch 6 taken
2448: branch 7 taken
1962 2540: if (BinOp->isAssignmentOp() && BinOp->getLHS())
1963 92: return BinOp->getLHS()->getBitField();
1964 :
1965 48182: return 0;
1966 : }
1967 :
1968 2492: bool Expr::refersToVectorElement() const {
1969 2492: const Expr *E = this->IgnoreParens();
1970 :
323: branch 1 taken
2449: branch 2 taken
1971 3052: while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
310: branch 1 taken
13: branch 2 taken
280: branch 4 taken
30: branch 5 taken
280: branch 6 taken
43: branch 7 taken
1972 323: if (ICE->isLvalueCast() && ICE->getCastKind() == CastExpr::CK_NoOp)
1973 280: E = ICE->getSubExpr()->IgnoreParens();
1974 : else
1975 43: break;
1976 : }
1977 :
144: branch 1 taken
2348: branch 2 taken
1978 2492: if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
1979 144: return ASE->getBase()->getType()->isVectorType();
1980 :
3: branch 1 taken
2345: branch 2 taken
1981 2348: if (isa<ExtVectorElementExpr>(E))
1982 3: return true;
1983 :
1984 2345: return false;
1985 : }
1986 :
1987 : /// isArrow - Return true if the base expression is a pointer to vector,
1988 : /// return false if the base expression is a vector.
1989 56: bool ExtVectorElementExpr::isArrow() const {
1990 56: return getBase()->getType()->isPointerType();
1991 : }
1992 :
1993 56: unsigned ExtVectorElementExpr::getNumElements() const {
41: branch 3 taken
15: branch 4 taken
1994 56: if (const VectorType *VT = getType()->getAs<VectorType>())
1995 41: return VT->getNumElements();
1996 15: return 1;
1997 : }
1998 :
1999 : /// containsDuplicateElements - Return true if any element access is repeated.
2000 45: bool ExtVectorElementExpr::containsDuplicateElements() const {
2001 : // FIXME: Refactor this code to an accessor on the AST node which returns the
2002 : // "type" of component access, and share with code below and in Sema.
2003 45: llvm::StringRef Comp = Accessor->getName();
2004 :
2005 : // Halving swizzles do not contain duplicate elements.
40: branch 2 taken
5: branch 3 taken
35: branch 6 taken
5: branch 7 taken
24: branch 10 taken
11: branch 11 taken
0: branch 14 not taken
24: branch 15 taken
21: branch 16 taken
24: branch 17 taken
2006 45: if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")
2007 21: return false;
2008 :
2009 : // Advance past s-char prefix on hex swizzles.
24: branch 1 taken
0: branch 2 not taken
0: branch 4 not taken
24: branch 5 taken
0: branch 6 not taken
24: branch 7 taken
2010 24: if (Comp[0] == 's' || Comp[0] == 'S')
2011 0: Comp = Comp.substr(1);
2012 :
37: branch 1 taken
20: branch 2 taken
2013 57: for (unsigned i = 0, e = Comp.size(); i != e; ++i)
4: branch 3 taken
33: branch 4 taken
2014 37: if (Comp.substr(i + 1).find(Comp[i]) != llvm::StringRef::npos)
2015 4: return true;
2016 :
2017 20: return false;
2018 : }
2019 :
2020 : /// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
2021 : void ExtVectorElementExpr::getEncodedElementAccess(
2022 56: llvm::SmallVectorImpl<unsigned> &Elts) const {
2023 56: llvm::StringRef Comp = Accessor->getName();
56: branch 1 taken
0: branch 2 not taken
0: branch 4 not taken
56: branch 5 taken
0: branch 6 not taken
56: branch 7 taken
2024 56: if (Comp[0] == 's' || Comp[0] == 'S')
2025 0: Comp = Comp.substr(1);
2026 :
2027 56: bool isHi = Comp == "hi";
2028 56: bool isLo = Comp == "lo";
2029 56: bool isEven = Comp == "even";
2030 56: bool isOdd = Comp == "odd";
2031 :
117: branch 1 taken
56: branch 2 taken
2032 173: for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
2033 : uint64_t Index;
2034 :
10: branch 0 taken
107: branch 1 taken
2035 117: if (isHi)
2036 10: Index = e + i;
10: branch 0 taken
97: branch 1 taken
2037 107: else if (isLo)
2038 10: Index = i;
5: branch 0 taken
92: branch 1 taken
2039 97: else if (isEven)
2040 5: Index = 2 * i;
0: branch 0 not taken
92: branch 1 taken
2041 92: else if (isOdd)
2042 0: Index = 2 * i + 1;
2043 : else
2044 92: Index = ExtVectorType::getAccessorIdx(Comp[i]);
2045 :
2046 117: Elts.push_back(Index);
2047 : }
2048 56: }
2049 :
2050 : // constructor for instance messages.
2051 : ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
2052 : QualType retType, ObjCMethodDecl *mproto,
2053 : SourceLocation LBrac, SourceLocation RBrac,
2054 1201: Expr **ArgExprs, unsigned nargs)
2055 : : Expr(ObjCMessageExprClass, retType, false, false), SelName(selInfo),
2056 1201: MethodProto(mproto) {
2057 1201: NumArgs = nargs;
2058 1201: SubExprs = new Stmt*[NumArgs+1];
2059 1201: SubExprs[RECEIVER] = receiver;
327: branch 0 taken
874: branch 1 taken
874: branch 2 taken
874: branch 3 taken
2060 1201: if (NumArgs) {
605: branch 0 taken
327: branch 1 taken
327: branch 2 taken
327: branch 3 taken
2061 932: for (unsigned i = 0; i != NumArgs; ++i)
2062 605: SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
2063 : }
2064 1201: LBracloc = LBrac;
2065 1201: RBracloc = RBrac;
2066 1201: }
2067 :
2068 : // constructor for class messages.
2069 : // FIXME: clsName should be typed to ObjCInterfaceType
2070 : ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
2071 : QualType retType, ObjCMethodDecl *mproto,
2072 : SourceLocation LBrac, SourceLocation RBrac,
2073 28: Expr **ArgExprs, unsigned nargs)
2074 : : Expr(ObjCMessageExprClass, retType, false, false), SelName(selInfo),
2075 28: MethodProto(mproto) {
2076 28: NumArgs = nargs;
2077 28: SubExprs = new Stmt*[NumArgs+1];
2078 28: SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown);
4: branch 0 taken
24: branch 1 taken
24: branch 2 taken
24: branch 3 taken
2079 28: if (NumArgs) {
7: branch 0 taken
4: branch 1 taken
4: branch 2 taken
4: branch 3 taken
2080 11: for (unsigned i = 0; i != NumArgs; ++i)
2081 7: SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
2082 : }
2083 28: LBracloc = LBrac;
2084 28: RBracloc = RBrac;
2085 28: }
2086 :
2087 : // constructor for class messages.
2088 : ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo,
2089 : QualType retType, ObjCMethodDecl *mproto,
2090 : SourceLocation LBrac, SourceLocation RBrac,
2091 445: Expr **ArgExprs, unsigned nargs)
2092 : : Expr(ObjCMessageExprClass, retType, false, false), SelName(selInfo),
2093 445: MethodProto(mproto) {
2094 445: NumArgs = nargs;
2095 445: SubExprs = new Stmt*[NumArgs+1];
2096 445: SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown);
76: branch 0 taken
369: branch 1 taken
369: branch 2 taken
369: branch 3 taken
2097 445: if (NumArgs) {
212: branch 0 taken
76: branch 1 taken
76: branch 2 taken
76: branch 3 taken
2098 288: for (unsigned i = 0; i != NumArgs; ++i)
2099 212: SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
2100 : }
2101 445: LBracloc = LBrac;
2102 445: RBracloc = RBrac;
2103 445: }
2104 :
2105 3849: ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const {
2106 3849: uintptr_t x = (uintptr_t) SubExprs[RECEIVER];
0: branch 0 not taken
2036: branch 1 taken
36: branch 2 taken
1777: branch 3 taken
2107 3849: switch (x & Flags) {
2108 : default:
2109 0: assert(false && "Invalid ObjCMessageExpr.");
2110 : case IsInstMeth:
2111 2036: return ClassInfo(0, 0);
2112 : case IsClsMethDeclUnknown:
2113 36: return ClassInfo(0, (IdentifierInfo*) (x & ~Flags));
2114 : case IsClsMethDeclKnown: {
2115 1777: ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags);
2116 1777: return ClassInfo(D, D->getIdentifier());
2117 : }
2118 : }
2119 : }
2120 :
2121 2: void ObjCMessageExpr::setClassInfo(const ObjCMessageExpr::ClassInfo &CI) {
0: branch 0 not taken
2: branch 1 taken
2: branch 2 taken
2: branch 3 taken
2122 2: if (CI.first == 0 && CI.second == 0)
2123 0: SubExprs[RECEIVER] = (Expr*)((uintptr_t)0 | IsInstMeth);
0: branch 0 not taken
2: branch 1 taken
2124 2: else if (CI.first == 0)
2125 0: SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.second | IsClsMethDeclUnknown);
2126 : else
2127 2: SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.first | IsClsMethDeclKnown);
2128 2: }
2129 :
2130 :
2131 10: bool ChooseExpr::isConditionTrue(ASTContext &C) const {
2132 10: return getCond()->EvaluateAsInt(C) != 0;
2133 : }
2134 :
2135 : void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs,
2136 1: unsigned NumExprs) {
0: branch 0 not taken
1: branch 1 taken
2137 1: if (SubExprs) C.Deallocate(SubExprs);
2138 :
2139 1: SubExprs = new (C) Stmt* [NumExprs];
2140 1: this->NumExprs = NumExprs;
2141 1: memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
2142 1: }
2143 :
2144 0: void ShuffleVectorExpr::DoDestroy(ASTContext& C) {
2145 0: DestroyChildren(C);
0: branch 0 not taken
0: branch 1 not taken
2146 0: if (SubExprs) C.Deallocate(SubExprs);
2147 0: this->~ShuffleVectorExpr();
2148 0: C.Deallocate(this);
2149 0: }
2150 :
2151 9: void SizeOfAlignOfExpr::DoDestroy(ASTContext& C) {
2152 : // Override default behavior of traversing children. If this has a type
2153 : // operand and the type is a variable-length array, the child iteration
2154 : // will iterate over the size expression. However, this expression belongs
2155 : // to the type, not to this, so we don't want to delete it.
2156 : // We still want to delete this expression.
8: branch 1 taken
1: branch 2 taken
2157 9: if (isArgumentType()) {
2158 8: this->~SizeOfAlignOfExpr();
2159 8: C.Deallocate(this);
2160 : }
2161 : else
2162 1: Expr::DoDestroy(C);
2163 9: }
2164 :
2165 : //===----------------------------------------------------------------------===//
2166 : // DesignatedInitExpr
2167 : //===----------------------------------------------------------------------===//
2168 :
2169 159: IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
0: branch 0 not taken
159: branch 1 taken
2170 159: assert(Kind == FieldDesignator && "Only valid on a field designator");
146: branch 0 taken
13: branch 1 taken
2171 159: if (Field.NameOrField & 0x01)
2172 146: return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
2173 : else
2174 13: return getField()->getIdentifier();
2175 : }
2176 :
2177 : DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty,
2178 : unsigned NumDesignators,
2179 : const Designator *Designators,
2180 : SourceLocation EqualOrColonLoc,
2181 : bool GNUSyntax,
2182 : Expr **IndexExprs,
2183 : unsigned NumIndexExprs,
2184 164: Expr *Init)
2185 : : Expr(DesignatedInitExprClass, Ty,
2186 : Init->isTypeDependent(), Init->isValueDependent()),
2187 : EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
2188 164: NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) {
164: branch 1 taken
0: branch 2 not taken
217: branch 4 taken
164: branch 5 taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 10 not taken
0: branch 11 not taken
2189 164: this->Designators = new (C) Designator[NumDesignators];
2190 :
2191 : // Record the initializer itself.
2192 164: child_iterator Child = child_begin();
2193 164: *Child++ = Init;
2194 :
2195 : // Copy the designators and their subexpressions, computing
2196 : // value-dependence along the way.
2197 164: unsigned IndexIdx = 0;
217: branch 0 taken
164: branch 1 taken
164: branch 2 taken
164: branch 3 taken
2198 381: for (unsigned I = 0; I != NumDesignators; ++I) {
2199 217: this->Designators[I] = Designators[I];
2200 :
64: branch 1 taken
153: branch 2 taken
0: branch 4 not taken
0: branch 5 not taken
2201 217: if (this->Designators[I].isArrayDesignator()) {
2202 : // Compute type- and value-dependence.
2203 64: Expr *Index = IndexExprs[IndexIdx];
2204 : ValueDependent = ValueDependent ||
62: branch 0 taken
2: branch 1 taken
62: branch 3 taken
0: branch 4 not taken
0: branch 6 not taken
62: branch 7 taken
62: branch 8 taken
62: branch 9 taken
0: branch 11 not taken
0: branch 12 not taken
0: branch 14 not taken
0: branch 15 not taken
2205 64: Index->isTypeDependent() || Index->isValueDependent();
2206 :
2207 : // Copy the index expressions into permanent storage.
2208 64: *Child++ = IndexExprs[IndexIdx++];
9: branch 1 taken
144: branch 2 taken
0: branch 4 not taken
0: branch 5 not taken
2209 153: } else if (this->Designators[I].isArrayRangeDesignator()) {
2210 : // Compute type- and value-dependence.
2211 9: Expr *Start = IndexExprs[IndexIdx];
2212 9: Expr *End = IndexExprs[IndexIdx + 1];
2213 : ValueDependent = ValueDependent ||
2214 : Start->isTypeDependent() || Start->isValueDependent() ||
8: branch 0 taken
1: branch 1 taken
8: branch 3 taken
0: branch 4 not taken
8: branch 6 taken
0: branch 7 not taken
8: branch 9 taken
0: branch 10 not taken
0: branch 12 not taken
8: branch 13 taken
8: branch 14 taken
8: branch 15 taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 20 not taken
0: branch 21 not taken
0: branch 23 not taken
0: branch 24 not taken
0: branch 26 not taken
0: branch 27 not taken
2215 9: End->isTypeDependent() || End->isValueDependent();
2216 :
2217 : // Copy the start/end expressions into permanent storage.
2218 9: *Child++ = IndexExprs[IndexIdx++];
2219 9: *Child++ = IndexExprs[IndexIdx++];
2220 : }
2221 : }
2222 :
0: branch 0 not taken
164: branch 1 taken
0: branch 3 not taken
0: branch 4 not taken
2223 164: assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions");
2224 164: }
2225 :
2226 : DesignatedInitExpr *
2227 : DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
2228 : unsigned NumDesignators,
2229 : Expr **IndexExprs, unsigned NumIndexExprs,
2230 : SourceLocation ColonOrEqualLoc,
2231 164: bool UsesColonSyntax, Expr *Init) {
2232 : void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
2233 164: sizeof(Stmt *) * (NumIndexExprs + 1), 8);
2234 : return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators,
2235 : ColonOrEqualLoc, UsesColonSyntax,
164: branch 2 taken
0: branch 3 not taken
2236 164: IndexExprs, NumIndexExprs, Init);
2237 : }
2238 :
2239 : DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
2240 3: unsigned NumIndexExprs) {
2241 : void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
2242 3: sizeof(Stmt *) * (NumIndexExprs + 1), 8);
3: branch 1 taken
0: branch 2 not taken
2243 3: return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
2244 : }
2245 :
2246 : void DesignatedInitExpr::setDesignators(ASTContext &C,
2247 : const Designator *Desigs,
2248 3: unsigned NumDesigs) {
2249 3: DestroyDesignators(C);
2250 :
3: branch 1 taken
0: branch 2 not taken
5: branch 4 taken
3: branch 5 taken
2251 3: Designators = new (C) Designator[NumDesigs];
2252 3: NumDesignators = NumDesigs;
5: branch 0 taken
3: branch 1 taken
2253 8: for (unsigned I = 0; I != NumDesigs; ++I)
2254 5: Designators[I] = Desigs[I];
2255 3: }
2256 :
2257 61: SourceRange DesignatedInitExpr::getSourceRange() const {
2258 61: SourceLocation StartLoc;
2259 : Designator &First =
2260 61: *const_cast<DesignatedInitExpr*>(this)->designators_begin();
25: branch 1 taken
36: branch 2 taken
2261 61: if (First.isFieldDesignator()) {
0: branch 0 not taken
25: branch 1 taken
2262 25: if (GNUSyntax)
2263 0: StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
2264 : else
2265 25: StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
2266 : } else
2267 : StartLoc =
2268 36: SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
2269 61: return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
2270 : }
2271 :
2272 64: Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
0: branch 0 not taken
64: branch 1 taken
2273 64: assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
2274 64: char* Ptr = static_cast<char*>(static_cast<void *>(this));
2275 64: Ptr += sizeof(DesignatedInitExpr);
2276 64: Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2277 64: return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2278 : }
2279 :
2280 10: Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
2281 : assert(D.Kind == Designator::ArrayRangeDesignator &&
0: branch 0 not taken
10: branch 1 taken
2282 10: "Requires array range designator");
2283 10: char* Ptr = static_cast<char*>(static_cast<void *>(this));
2284 10: Ptr += sizeof(DesignatedInitExpr);
2285 10: Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2286 10: return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2287 : }
2288 :
2289 14: Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
2290 : assert(D.Kind == Designator::ArrayRangeDesignator &&
0: branch 0 not taken
14: branch 1 taken
2291 14: "Requires array range designator");
2292 14: char* Ptr = static_cast<char*>(static_cast<void *>(this));
2293 14: Ptr += sizeof(DesignatedInitExpr);
2294 14: Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2295 14: return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
2296 : }
2297 :
2298 : /// \brief Replaces the designator at index @p Idx with the series
2299 : /// of designators in [First, Last).
2300 : void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx,
2301 : const Designator *First,
2302 3: const Designator *Last) {
2303 3: unsigned NumNewDesignators = Last - First;
0: branch 0 not taken
3: branch 1 taken
2304 3: if (NumNewDesignators == 0) {
2305 : std::copy_backward(Designators + Idx + 1,
2306 : Designators + NumDesignators,
2307 0: Designators + Idx);
2308 0: --NumNewDesignators;
2309 0: return;
0: branch 0 not taken
3: branch 1 taken
2310 3: } else if (NumNewDesignators == 1) {
2311 0: Designators[Idx] = *First;
2312 0: return;
2313 : }
2314 :
2315 : Designator *NewDesignators
3: branch 1 taken
0: branch 2 not taken
9: branch 4 taken
3: branch 5 taken
2316 3: = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
2317 3: std::copy(Designators, Designators + Idx, NewDesignators);
2318 3: std::copy(First, Last, NewDesignators + Idx);
2319 : std::copy(Designators + Idx + 1, Designators + NumDesignators,
2320 3: NewDesignators + Idx + NumNewDesignators);
2321 3: DestroyDesignators(C);
2322 3: Designators = NewDesignators;
2323 3: NumDesignators = NumDesignators - 1 + NumNewDesignators;
2324 : }
2325 :
2326 5: void DesignatedInitExpr::DoDestroy(ASTContext &C) {
2327 5: DestroyDesignators(C);
2328 5: Expr::DoDestroy(C);
2329 5: }
2330 :
2331 11: void DesignatedInitExpr::DestroyDesignators(ASTContext &C) {
10: branch 0 taken
11: branch 1 taken
2332 21: for (unsigned I = 0; I != NumDesignators; ++I)
2333 10: Designators[I].~Designator();
2334 11: C.Deallocate(Designators);
2335 11: Designators = 0;
2336 11: }
2337 :
2338 : ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc,
2339 : Expr **exprs, unsigned nexprs,
2340 164: SourceLocation rparenloc)
2341 : : Expr(ParenListExprClass, QualType(),
2342 : hasAnyTypeDependentArguments(exprs, nexprs),
2343 : hasAnyValueDependentArguments(exprs, nexprs)),
2344 164: NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) {
2345 :
2346 164: Exprs = new (C) Stmt*[nexprs];
175: branch 0 taken
164: branch 1 taken
164: branch 2 taken
164: branch 3 taken
2347 339: for (unsigned i = 0; i != nexprs; ++i)
2348 175: Exprs[i] = exprs[i];
2349 164: }
2350 :
2351 0: void ParenListExpr::DoDestroy(ASTContext& C) {
2352 0: DestroyChildren(C);
0: branch 0 not taken
0: branch 1 not taken
2353 0: if (Exprs) C.Deallocate(Exprs);
2354 0: this->~ParenListExpr();
2355 0: C.Deallocate(this);
2356 0: }
2357 :
2358 : //===----------------------------------------------------------------------===//
2359 : // ExprIterator.
2360 : //===----------------------------------------------------------------------===//
2361 :
2362 0: Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
2363 5546: Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
2364 29: Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
2365 0: const Expr* ConstExprIterator::operator[](size_t idx) const {
2366 0: return cast<Expr>(I[idx]);
2367 : }
2368 5361: const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
2369 2199: const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
2370 :
2371 : //===----------------------------------------------------------------------===//
2372 : // Child Iterators for iterating over subexpressions/substatements
2373 : //===----------------------------------------------------------------------===//
2374 :
2375 : // DeclRefExpr
2376 32541: Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
2377 32541: Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
2378 :
2379 : // ObjCIvarRefExpr
2380 1012: Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
2381 1012: Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
2382 :
2383 : // ObjCPropertyRefExpr
2384 119: Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
2385 119: Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
2386 :
2387 : // ObjCImplicitSetterGetterRefExpr
2388 257: Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_begin() {
2389 257: return &Base;
2390 : }
2391 257: Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_end() {
2392 257: return &Base+1;
2393 : }
2394 :
2395 : // ObjCSuperExpr
2396 224: Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
2397 224: Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
2398 :
2399 : // ObjCIsaExpr
2400 5: Stmt::child_iterator ObjCIsaExpr::child_begin() { return &Base; }
2401 5: Stmt::child_iterator ObjCIsaExpr::child_end() { return &Base+1; }
2402 :
2403 : // PredefinedExpr
2404 97: Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
2405 97: Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
2406 :
2407 : // IntegerLiteral
2408 30115: Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
2409 30115: Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
2410 :
2411 : // CharacterLiteral
2412 245: Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();}
2413 245: Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
2414 :
2415 : // FloatingLiteral
2416 1694: Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
2417 1694: Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
2418 :
2419 : // ImaginaryLiteral
2420 10: Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
2421 10: Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
2422 :
2423 : // StringLiteral
2424 2169: Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
2425 2169: Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
2426 :
2427 : // ParenExpr
2428 5849: Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
2429 5852: Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
2430 :
2431 : // UnaryOperator
2432 7680: Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
2433 7709: Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
2434 :
2435 : // SizeOfAlignOfExpr
2436 389: Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
2437 : // If this is of a type and the type is a VLA type (and not a typedef), the
2438 : // size expression of the VLA needs to be treated as an executable expression.
2439 : // Why isn't this weirdness documented better in StmtIterator?
127: branch 1 taken
262: branch 2 taken
2440 389: if (isArgumentType()) {
55: branch 0 taken
72: branch 1 taken
2441 127: if (VariableArrayType* T = dyn_cast<VariableArrayType>(
2442 127: getArgumentType().getTypePtr()))
2443 55: return child_iterator(T);
2444 72: return child_iterator();
2445 : }
2446 262: return child_iterator(&Argument.Ex);
2447 : }
2448 389: Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
127: branch 1 taken
262: branch 2 taken
2449 389: if (isArgumentType())
2450 127: return child_iterator();
2451 262: return child_iterator(&Argument.Ex + 1);
2452 : }
2453 :
2454 : // ArraySubscriptExpr
2455 1794: Stmt::child_iterator ArraySubscriptExpr::child_begin() {
2456 1794: return &SubExprs[0];
2457 : }
2458 1794: Stmt::child_iterator ArraySubscriptExpr::child_end() {
2459 1794: return &SubExprs[0]+END_EXPR;
2460 : }
2461 :
2462 : // CallExpr
2463 11459: Stmt::child_iterator CallExpr::child_begin() {
2464 11459: return &SubExprs[0];
2465 : }
2466 11468: Stmt::child_iterator CallExpr::child_end() {
2467 11468: return &SubExprs[0]+NumArgs+ARGS_START;
2468 : }
2469 :
2470 : // MemberExpr
2471 3118: Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
2472 3122: Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
2473 :
2474 : // ExtVectorElementExpr
2475 39: Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
2476 39: Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
2477 :
2478 : // CompoundLiteralExpr
2479 383: Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
2480 383: Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
2481 :
2482 : // CastExpr
2483 48512: Stmt::child_iterator CastExpr::child_begin() { return &Op; }
2484 48517: Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
2485 :
2486 : // BinaryOperator
2487 16601: Stmt::child_iterator BinaryOperator::child_begin() {
2488 16601: return &SubExprs[0];
2489 : }
2490 16611: Stmt::child_iterator BinaryOperator::child_end() {
2491 16611: return &SubExprs[0]+END_EXPR;
2492 : }
2493 :
2494 : // ConditionalOperator
2495 758: Stmt::child_iterator ConditionalOperator::child_begin() {
2496 758: return &SubExprs[0];
2497 : }
2498 758: Stmt::child_iterator ConditionalOperator::child_end() {
2499 758: return &SubExprs[0]+END_EXPR;
2500 : }
2501 :
2502 : // AddrLabelExpr
2503 4: Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
2504 4: Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
2505 :
2506 : // StmtExpr
2507 175: Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
2508 175: Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
2509 :
2510 : // TypesCompatibleExpr
2511 2: Stmt::child_iterator TypesCompatibleExpr::child_begin() {
2512 2: return child_iterator();
2513 : }
2514 :
2515 2: Stmt::child_iterator TypesCompatibleExpr::child_end() {
2516 2: return child_iterator();
2517 : }
2518 :
2519 : // ChooseExpr
2520 73: Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
2521 73: Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
2522 :
2523 : // GNUNullExpr
2524 1: Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
2525 1: Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
2526 :
2527 : // ShuffleVectorExpr
2528 88: Stmt::child_iterator ShuffleVectorExpr::child_begin() {
2529 88: return &SubExprs[0];
2530 : }
2531 88: Stmt::child_iterator ShuffleVectorExpr::child_end() {
2532 88: return &SubExprs[0]+NumExprs;
2533 : }
2534 :
2535 : // VAArgExpr
2536 13: Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
2537 13: Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
2538 :
2539 : // InitListExpr
2540 959: Stmt::child_iterator InitListExpr::child_begin() {
934: branch 1 taken
25: branch 2 taken
2541 959: return InitExprs.size() ? &InitExprs[0] : 0;
2542 : }
2543 959: Stmt::child_iterator InitListExpr::child_end() {
934: branch 1 taken
25: branch 2 taken
2544 959: return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
2545 : }
2546 :
2547 : // DesignatedInitExpr
2548 607: Stmt::child_iterator DesignatedInitExpr::child_begin() {
2549 607: char* Ptr = static_cast<char*>(static_cast<void *>(this));
2550 607: Ptr += sizeof(DesignatedInitExpr);
2551 607: return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2552 : }
2553 5: Stmt::child_iterator DesignatedInitExpr::child_end() {
2554 5: return child_iterator(&*child_begin() + NumSubExprs);
2555 : }
2556 :
2557 : // ImplicitValueInitExpr
2558 1438: Stmt::child_iterator ImplicitValueInitExpr::child_begin() {
2559 1438: return child_iterator();
2560 : }
2561 :
2562 1438: Stmt::child_iterator ImplicitValueInitExpr::child_end() {
2563 1438: return child_iterator();
2564 : }
2565 :
2566 : // ParenListExpr
2567 0: Stmt::child_iterator ParenListExpr::child_begin() {
2568 0: return &Exprs[0];
2569 : }
2570 0: Stmt::child_iterator ParenListExpr::child_end() {
2571 0: return &Exprs[0]+NumExprs;
2572 : }
2573 :
2574 : // ObjCStringLiteral
2575 666: Stmt::child_iterator ObjCStringLiteral::child_begin() {
2576 666: return &String;
2577 : }
2578 666: Stmt::child_iterator ObjCStringLiteral::child_end() {
2579 666: return &String+1;
2580 : }
2581 :
2582 : // ObjCEncodeExpr
2583 4: Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
2584 4: Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
2585 :
2586 : // ObjCSelectorExpr
2587 33: Stmt::child_iterator ObjCSelectorExpr::child_begin() {
2588 33: return child_iterator();
2589 : }
2590 33: Stmt::child_iterator ObjCSelectorExpr::child_end() {
2591 33: return child_iterator();
2592 : }
2593 :
2594 : // ObjCProtocolExpr
2595 4: Stmt::child_iterator ObjCProtocolExpr::child_begin() {
2596 4: return child_iterator();
2597 : }
2598 4: Stmt::child_iterator ObjCProtocolExpr::child_end() {
2599 4: return child_iterator();
2600 : }
2601 :
2602 : // ObjCMessageExpr
2603 8415: Stmt::child_iterator ObjCMessageExpr::child_begin() {
5963: branch 1 taken
2452: branch 2 taken
2604 8415: return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
2605 : }
2606 8415: Stmt::child_iterator ObjCMessageExpr::child_end() {
2607 8415: return &SubExprs[0]+ARGS_START+getNumArgs();
2608 : }
2609 :
2610 : // Blocks
2611 404: Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
2612 404: Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
2613 :
2614 298: Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
2615 298: Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }
Generated: 2010-02-10 01:31 by zcov