1 //===--- Expr.cpp - Expression AST Node Implementation --------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Expr class and subclasses.
12 //===----------------------------------------------------------------------===//
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/Lex/LiteralSupport.h"
24 #include "clang/Lex/Lexer.h"
25 #include "clang/Basic/Builtins.h"
26 #include "clang/Basic/SourceManager.h"
27 #include "clang/Basic/TargetInfo.h"
28 #include "llvm/Support/ErrorHandling.h"
29 #include "llvm/Support/raw_ostream.h"
31 using namespace clang
;
33 void Expr::ANCHOR() {} // key function for Expr class.
35 /// isKnownToHaveBooleanValue - Return true if this is an integer expression
36 /// that is known to return 0 or 1. This happens for _Bool/bool expressions
37 /// but also int expressions which are produced by things like comparisons in
39 bool Expr::isKnownToHaveBooleanValue() const {
40 // If this value has _Bool type, it is obvious 0/1.
41 if (getType()->isBooleanType()) return true;
42 // If this is a non-scalar-integer type, we don't care enough to try.
43 if (!getType()->isIntegralOrEnumerationType()) return false;
45 if (const ParenExpr
*PE
= dyn_cast
<ParenExpr
>(this))
46 return PE
->getSubExpr()->isKnownToHaveBooleanValue();
48 if (const UnaryOperator
*UO
= dyn_cast
<UnaryOperator
>(this)) {
49 switch (UO
->getOpcode()) {
52 return UO
->getSubExpr()->isKnownToHaveBooleanValue();
58 // Only look through implicit casts. If the user writes
59 // '(int) (a && b)' treat it as an arbitrary int.
60 if (const ImplicitCastExpr
*CE
= dyn_cast
<ImplicitCastExpr
>(this))
61 return CE
->getSubExpr()->isKnownToHaveBooleanValue();
63 if (const BinaryOperator
*BO
= dyn_cast
<BinaryOperator
>(this)) {
64 switch (BO
->getOpcode()) {
65 default: return false;
66 case BO_LT
: // Relational operators.
70 case BO_EQ
: // Equality operators.
72 case BO_LAnd
: // AND operator.
73 case BO_LOr
: // Logical OR operator.
76 case BO_And
: // Bitwise AND operator.
77 case BO_Xor
: // Bitwise XOR operator.
78 case BO_Or
: // Bitwise OR operator.
79 // Handle things like (x==2)|(y==12).
80 return BO
->getLHS()->isKnownToHaveBooleanValue() &&
81 BO
->getRHS()->isKnownToHaveBooleanValue();
85 return BO
->getRHS()->isKnownToHaveBooleanValue();
89 if (const ConditionalOperator
*CO
= dyn_cast
<ConditionalOperator
>(this))
90 return CO
->getTrueExpr()->isKnownToHaveBooleanValue() &&
91 CO
->getFalseExpr()->isKnownToHaveBooleanValue();
96 //===----------------------------------------------------------------------===//
97 // Primary Expressions.
98 //===----------------------------------------------------------------------===//
100 void ExplicitTemplateArgumentList::initializeFrom(
101 const TemplateArgumentListInfo
&Info
) {
102 LAngleLoc
= Info
.getLAngleLoc();
103 RAngleLoc
= Info
.getRAngleLoc();
104 NumTemplateArgs
= Info
.size();
106 TemplateArgumentLoc
*ArgBuffer
= getTemplateArgs();
107 for (unsigned i
= 0; i
!= NumTemplateArgs
; ++i
)
108 new (&ArgBuffer
[i
]) TemplateArgumentLoc(Info
[i
]);
111 void ExplicitTemplateArgumentList::copyInto(
112 TemplateArgumentListInfo
&Info
) const {
113 Info
.setLAngleLoc(LAngleLoc
);
114 Info
.setRAngleLoc(RAngleLoc
);
115 for (unsigned I
= 0; I
!= NumTemplateArgs
; ++I
)
116 Info
.addArgument(getTemplateArgs()[I
]);
119 std::size_t ExplicitTemplateArgumentList::sizeFor(unsigned NumTemplateArgs
) {
120 return sizeof(ExplicitTemplateArgumentList
) +
121 sizeof(TemplateArgumentLoc
) * NumTemplateArgs
;
124 std::size_t ExplicitTemplateArgumentList::sizeFor(
125 const TemplateArgumentListInfo
&Info
) {
126 return sizeFor(Info
.size());
129 void DeclRefExpr::computeDependence() {
130 ExprBits
.TypeDependent
= false;
131 ExprBits
.ValueDependent
= false;
133 NamedDecl
*D
= getDecl();
135 // (TD) C++ [temp.dep.expr]p3:
136 // An id-expression is type-dependent if it contains:
140 // (VD) C++ [temp.dep.constexpr]p2:
141 // An identifier is value-dependent if it is:
143 // (TD) - an identifier that was declared with dependent type
144 // (VD) - a name declared with a dependent type,
145 if (getType()->isDependentType()) {
146 ExprBits
.TypeDependent
= true;
147 ExprBits
.ValueDependent
= true;
149 // (TD) - a conversion-function-id that specifies a dependent type
150 else if (D
->getDeclName().getNameKind()
151 == DeclarationName::CXXConversionFunctionName
&&
152 D
->getDeclName().getCXXNameType()->isDependentType()) {
153 ExprBits
.TypeDependent
= true;
154 ExprBits
.ValueDependent
= true;
156 // (TD) - a template-id that is dependent,
157 else if (hasExplicitTemplateArgs() &&
158 TemplateSpecializationType::anyDependentTemplateArguments(
160 getNumTemplateArgs())) {
161 ExprBits
.TypeDependent
= true;
162 ExprBits
.ValueDependent
= true;
164 // (VD) - the name of a non-type template parameter,
165 else if (isa
<NonTypeTemplateParmDecl
>(D
))
166 ExprBits
.ValueDependent
= true;
167 // (VD) - a constant with integral or enumeration type and is
168 // initialized with an expression that is value-dependent.
169 else if (VarDecl
*Var
= dyn_cast
<VarDecl
>(D
)) {
170 if (Var
->getType()->isIntegralOrEnumerationType() &&
171 Var
->getType().getCVRQualifiers() == Qualifiers::Const
) {
172 if (const Expr
*Init
= Var
->getAnyInitializer())
173 if (Init
->isValueDependent())
174 ExprBits
.ValueDependent
= true;
176 // (VD) - FIXME: Missing from the standard:
177 // - a member function or a static data member of the current
179 else if (Var
->isStaticDataMember() &&
180 Var
->getDeclContext()->isDependentContext())
181 ExprBits
.ValueDependent
= true;
183 // (VD) - FIXME: Missing from the standard:
184 // - a member function or a static data member of the current
186 else if (isa
<CXXMethodDecl
>(D
) && D
->getDeclContext()->isDependentContext())
187 ExprBits
.ValueDependent
= true;
188 // (TD) - a nested-name-specifier or a qualified-id that names a
189 // member of an unknown specialization.
190 // (handled by DependentScopeDeclRefExpr)
193 DeclRefExpr::DeclRefExpr(NestedNameSpecifier
*Qualifier
,
194 SourceRange QualifierRange
,
195 ValueDecl
*D
, SourceLocation NameLoc
,
196 const TemplateArgumentListInfo
*TemplateArgs
,
197 QualType T
, ExprValueKind VK
)
198 : Expr(DeclRefExprClass
, T
, VK
, OK_Ordinary
, false, false),
200 (Qualifier
? HasQualifierFlag
: 0) |
201 (TemplateArgs
? HasExplicitTemplateArgumentListFlag
: 0)),
204 NameQualifier
*NQ
= getNameQualifier();
206 NQ
->Range
= QualifierRange
;
210 getExplicitTemplateArgs().initializeFrom(*TemplateArgs
);
215 DeclRefExpr::DeclRefExpr(NestedNameSpecifier
*Qualifier
,
216 SourceRange QualifierRange
,
217 ValueDecl
*D
, const DeclarationNameInfo
&NameInfo
,
218 const TemplateArgumentListInfo
*TemplateArgs
,
219 QualType T
, ExprValueKind VK
)
220 : Expr(DeclRefExprClass
, T
, VK
, OK_Ordinary
, false, false),
222 (Qualifier
? HasQualifierFlag
: 0) |
223 (TemplateArgs
? HasExplicitTemplateArgumentListFlag
: 0)),
224 Loc(NameInfo
.getLoc()), DNLoc(NameInfo
.getInfo()) {
226 NameQualifier
*NQ
= getNameQualifier();
228 NQ
->Range
= QualifierRange
;
232 getExplicitTemplateArgs().initializeFrom(*TemplateArgs
);
237 DeclRefExpr
*DeclRefExpr::Create(ASTContext
&Context
,
238 NestedNameSpecifier
*Qualifier
,
239 SourceRange QualifierRange
,
241 SourceLocation NameLoc
,
244 const TemplateArgumentListInfo
*TemplateArgs
) {
245 return Create(Context
, Qualifier
, QualifierRange
, D
,
246 DeclarationNameInfo(D
->getDeclName(), NameLoc
),
247 T
, VK
, TemplateArgs
);
250 DeclRefExpr
*DeclRefExpr::Create(ASTContext
&Context
,
251 NestedNameSpecifier
*Qualifier
,
252 SourceRange QualifierRange
,
254 const DeclarationNameInfo
&NameInfo
,
257 const TemplateArgumentListInfo
*TemplateArgs
) {
258 std::size_t Size
= sizeof(DeclRefExpr
);
260 Size
+= sizeof(NameQualifier
);
263 Size
+= ExplicitTemplateArgumentList::sizeFor(*TemplateArgs
);
265 void *Mem
= Context
.Allocate(Size
, llvm::alignOf
<DeclRefExpr
>());
266 return new (Mem
) DeclRefExpr(Qualifier
, QualifierRange
, D
, NameInfo
,
267 TemplateArgs
, T
, VK
);
270 DeclRefExpr
*DeclRefExpr::CreateEmpty(ASTContext
&Context
, bool HasQualifier
,
271 unsigned NumTemplateArgs
) {
272 std::size_t Size
= sizeof(DeclRefExpr
);
274 Size
+= sizeof(NameQualifier
);
277 Size
+= ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs
);
279 void *Mem
= Context
.Allocate(Size
, llvm::alignOf
<DeclRefExpr
>());
280 return new (Mem
) DeclRefExpr(EmptyShell());
283 SourceRange
DeclRefExpr::getSourceRange() const {
284 SourceRange R
= getNameInfo().getSourceRange();
286 R
.setBegin(getQualifierRange().getBegin());
287 if (hasExplicitTemplateArgs())
288 R
.setEnd(getRAngleLoc());
292 // FIXME: Maybe this should use DeclPrinter with a special "print predefined
293 // expr" policy instead.
294 std::string
PredefinedExpr::ComputeName(IdentType IT
, const Decl
*CurrentDecl
) {
295 ASTContext
&Context
= CurrentDecl
->getASTContext();
297 if (const FunctionDecl
*FD
= dyn_cast
<FunctionDecl
>(CurrentDecl
)) {
298 if (IT
!= PrettyFunction
&& IT
!= PrettyFunctionNoVirtual
)
299 return FD
->getNameAsString();
301 llvm::SmallString
<256> Name
;
302 llvm::raw_svector_ostream
Out(Name
);
304 if (const CXXMethodDecl
*MD
= dyn_cast
<CXXMethodDecl
>(FD
)) {
305 if (MD
->isVirtual() && IT
!= PrettyFunctionNoVirtual
)
311 PrintingPolicy
Policy(Context
.getLangOptions());
313 std::string Proto
= FD
->getQualifiedNameAsString(Policy
);
315 const FunctionType
*AFT
= FD
->getType()->getAs
<FunctionType
>();
316 const FunctionProtoType
*FT
= 0;
317 if (FD
->hasWrittenPrototype())
318 FT
= dyn_cast
<FunctionProtoType
>(AFT
);
322 llvm::raw_string_ostream
POut(Proto
);
323 for (unsigned i
= 0, e
= FD
->getNumParams(); i
!= e
; ++i
) {
326 FD
->getParamDecl(i
)->getType().getAsStringInternal(Param
, Policy
);
330 if (FT
->isVariadic()) {
331 if (FD
->getNumParams()) POut
<< ", ";
337 if (const CXXMethodDecl
*MD
= dyn_cast
<CXXMethodDecl
>(FD
)) {
338 Qualifiers ThisQuals
= Qualifiers::fromCVRMask(MD
->getTypeQualifiers());
339 if (ThisQuals
.hasConst())
341 if (ThisQuals
.hasVolatile())
342 Proto
+= " volatile";
345 if (!isa
<CXXConstructorDecl
>(FD
) && !isa
<CXXDestructorDecl
>(FD
))
346 AFT
->getResultType().getAsStringInternal(Proto
, Policy
);
351 return Name
.str().str();
353 if (const ObjCMethodDecl
*MD
= dyn_cast
<ObjCMethodDecl
>(CurrentDecl
)) {
354 llvm::SmallString
<256> Name
;
355 llvm::raw_svector_ostream
Out(Name
);
356 Out
<< (MD
->isInstanceMethod() ? '-' : '+');
359 // For incorrect code, there might not be an ObjCInterfaceDecl. Do
360 // a null check to avoid a crash.
361 if (const ObjCInterfaceDecl
*ID
= MD
->getClassInterface())
364 if (const ObjCCategoryImplDecl
*CID
=
365 dyn_cast
<ObjCCategoryImplDecl
>(MD
->getDeclContext()))
366 Out
<< '(' << CID
<< ')';
369 Out
<< MD
->getSelector().getAsString();
373 return Name
.str().str();
375 if (isa
<TranslationUnitDecl
>(CurrentDecl
) && IT
== PrettyFunction
) {
376 // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
382 void APNumericStorage::setIntValue(ASTContext
&C
, const llvm::APInt
&Val
) {
386 BitWidth
= Val
.getBitWidth();
387 unsigned NumWords
= Val
.getNumWords();
388 const uint64_t* Words
= Val
.getRawData();
390 pVal
= new (C
) uint64_t[NumWords
];
391 std::copy(Words
, Words
+ NumWords
, pVal
);
392 } else if (NumWords
== 1)
399 IntegerLiteral::Create(ASTContext
&C
, const llvm::APInt
&V
,
400 QualType type
, SourceLocation l
) {
401 return new (C
) IntegerLiteral(C
, V
, type
, l
);
405 IntegerLiteral::Create(ASTContext
&C
, EmptyShell Empty
) {
406 return new (C
) IntegerLiteral(Empty
);
410 FloatingLiteral::Create(ASTContext
&C
, const llvm::APFloat
&V
,
411 bool isexact
, QualType Type
, SourceLocation L
) {
412 return new (C
) FloatingLiteral(C
, V
, isexact
, Type
, L
);
416 FloatingLiteral::Create(ASTContext
&C
, EmptyShell Empty
) {
417 return new (C
) FloatingLiteral(Empty
);
420 /// getValueAsApproximateDouble - This returns the value as an inaccurate
421 /// double. Note that this may cause loss of precision, but is useful for
422 /// debugging dumps, etc.
423 double FloatingLiteral::getValueAsApproximateDouble() const {
424 llvm::APFloat V
= getValue();
426 V
.convert(llvm::APFloat::IEEEdouble
, llvm::APFloat::rmNearestTiesToEven
,
428 return V
.convertToDouble();
431 StringLiteral
*StringLiteral::Create(ASTContext
&C
, const char *StrData
,
432 unsigned ByteLength
, bool Wide
,
434 const SourceLocation
*Loc
,
436 // Allocate enough space for the StringLiteral plus an array of locations for
437 // any concatenated string tokens.
438 void *Mem
= C
.Allocate(sizeof(StringLiteral
)+
439 sizeof(SourceLocation
)*(NumStrs
-1),
440 llvm::alignOf
<StringLiteral
>());
441 StringLiteral
*SL
= new (Mem
) StringLiteral(Ty
);
443 // OPTIMIZE: could allocate this appended to the StringLiteral.
444 char *AStrData
= new (C
, 1) char[ByteLength
];
445 memcpy(AStrData
, StrData
, ByteLength
);
446 SL
->StrData
= AStrData
;
447 SL
->ByteLength
= ByteLength
;
449 SL
->TokLocs
[0] = Loc
[0];
450 SL
->NumConcatenated
= NumStrs
;
453 memcpy(&SL
->TokLocs
[1], Loc
+1, sizeof(SourceLocation
)*(NumStrs
-1));
457 StringLiteral
*StringLiteral::CreateEmpty(ASTContext
&C
, unsigned NumStrs
) {
458 void *Mem
= C
.Allocate(sizeof(StringLiteral
)+
459 sizeof(SourceLocation
)*(NumStrs
-1),
460 llvm::alignOf
<StringLiteral
>());
461 StringLiteral
*SL
= new (Mem
) StringLiteral(QualType());
464 SL
->NumConcatenated
= NumStrs
;
468 void StringLiteral::setString(ASTContext
&C
, llvm::StringRef Str
) {
469 char *AStrData
= new (C
, 1) char[Str
.size()];
470 memcpy(AStrData
, Str
.data(), Str
.size());
472 ByteLength
= Str
.size();
475 /// getLocationOfByte - Return a source location that points to the specified
476 /// byte of this string literal.
478 /// Strings are amazingly complex. They can be formed from multiple tokens and
479 /// can have escape sequences in them in addition to the usual trigraph and
480 /// escaped newline business. This routine handles this complexity.
482 SourceLocation
StringLiteral::
483 getLocationOfByte(unsigned ByteNo
, const SourceManager
&SM
,
484 const LangOptions
&Features
, const TargetInfo
&Target
) const {
485 assert(!isWide() && "This doesn't work for wide strings yet");
487 // Loop over all of the tokens in this string until we find the one that
488 // contains the byte we're looking for.
491 assert(TokNo
< getNumConcatenated() && "Invalid byte number!");
492 SourceLocation StrTokLoc
= getStrTokenLoc(TokNo
);
494 // Get the spelling of the string so that we can get the data that makes up
495 // the string literal, not the identifier for the macro it is potentially
497 SourceLocation StrTokSpellingLoc
= SM
.getSpellingLoc(StrTokLoc
);
499 // Re-lex the token to get its length and original spelling.
500 std::pair
<FileID
, unsigned> LocInfo
=SM
.getDecomposedLoc(StrTokSpellingLoc
);
501 bool Invalid
= false;
502 llvm::StringRef Buffer
= SM
.getBufferData(LocInfo
.first
, &Invalid
);
504 return StrTokSpellingLoc
;
506 const char *StrData
= Buffer
.data()+LocInfo
.second
;
508 // Create a langops struct and enable trigraphs. This is sufficient for
510 LangOptions LangOpts
;
511 LangOpts
.Trigraphs
= true;
513 // Create a lexer starting at the beginning of this token.
514 Lexer
TheLexer(StrTokSpellingLoc
, Features
, Buffer
.begin(), StrData
,
517 TheLexer
.LexFromRawLexer(TheTok
);
519 // Use the StringLiteralParser to compute the length of the string in bytes.
520 StringLiteralParser
SLP(&TheTok
, 1, SM
, Features
, Target
);
521 unsigned TokNumBytes
= SLP
.GetStringLength();
523 // If the byte is in this token, return the location of the byte.
524 if (ByteNo
< TokNumBytes
||
525 (ByteNo
== TokNumBytes
&& TokNo
== getNumConcatenated())) {
526 unsigned Offset
= SLP
.getOffsetOfStringByte(TheTok
, ByteNo
);
528 // Now that we know the offset of the token in the spelling, use the
529 // preprocessor to get the offset in the original source.
530 return Lexer::AdvanceToTokenCharacter(StrTokLoc
, Offset
, SM
, Features
);
533 // Move to the next string token.
535 ByteNo
-= TokNumBytes
;
541 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
542 /// corresponds to, e.g. "sizeof" or "[pre]++".
543 const char *UnaryOperator::getOpcodeStr(Opcode Op
) {
545 default: assert(0 && "Unknown unary operator");
546 case UO_PostInc
: return "++";
547 case UO_PostDec
: return "--";
548 case UO_PreInc
: return "++";
549 case UO_PreDec
: return "--";
550 case UO_AddrOf
: return "&";
551 case UO_Deref
: return "*";
552 case UO_Plus
: return "+";
553 case UO_Minus
: return "-";
554 case UO_Not
: return "~";
555 case UO_LNot
: return "!";
556 case UO_Real
: return "__real";
557 case UO_Imag
: return "__imag";
558 case UO_Extension
: return "__extension__";
563 UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO
, bool Postfix
) {
565 default: assert(false && "No unary operator for overloaded function");
566 case OO_PlusPlus
: return Postfix
? UO_PostInc
: UO_PreInc
;
567 case OO_MinusMinus
: return Postfix
? UO_PostDec
: UO_PreDec
;
568 case OO_Amp
: return UO_AddrOf
;
569 case OO_Star
: return UO_Deref
;
570 case OO_Plus
: return UO_Plus
;
571 case OO_Minus
: return UO_Minus
;
572 case OO_Tilde
: return UO_Not
;
573 case OO_Exclaim
: return UO_LNot
;
577 OverloadedOperatorKind
UnaryOperator::getOverloadedOperator(Opcode Opc
) {
579 case UO_PostInc
: case UO_PreInc
: return OO_PlusPlus
;
580 case UO_PostDec
: case UO_PreDec
: return OO_MinusMinus
;
581 case UO_AddrOf
: return OO_Amp
;
582 case UO_Deref
: return OO_Star
;
583 case UO_Plus
: return OO_Plus
;
584 case UO_Minus
: return OO_Minus
;
585 case UO_Not
: return OO_Tilde
;
586 case UO_LNot
: return OO_Exclaim
;
587 default: return OO_None
;
592 //===----------------------------------------------------------------------===//
593 // Postfix Operators.
594 //===----------------------------------------------------------------------===//
596 CallExpr::CallExpr(ASTContext
& C
, StmtClass SC
, Expr
*fn
, Expr
**args
,
597 unsigned numargs
, QualType t
, ExprValueKind VK
,
598 SourceLocation rparenloc
)
599 : Expr(SC
, t
, VK
, OK_Ordinary
,
600 fn
->isTypeDependent() || hasAnyTypeDependentArguments(args
, numargs
),
601 fn
->isValueDependent() || hasAnyValueDependentArguments(args
,numargs
)),
604 SubExprs
= new (C
) Stmt
*[numargs
+1];
606 for (unsigned i
= 0; i
!= numargs
; ++i
)
607 SubExprs
[i
+ARGS_START
] = args
[i
];
609 RParenLoc
= rparenloc
;
612 CallExpr::CallExpr(ASTContext
& C
, Expr
*fn
, Expr
**args
, unsigned numargs
,
613 QualType t
, ExprValueKind VK
, SourceLocation rparenloc
)
614 : Expr(CallExprClass
, t
, VK
, OK_Ordinary
,
615 fn
->isTypeDependent() || hasAnyTypeDependentArguments(args
, numargs
),
616 fn
->isValueDependent() || hasAnyValueDependentArguments(args
,numargs
)),
619 SubExprs
= new (C
) Stmt
*[numargs
+1];
621 for (unsigned i
= 0; i
!= numargs
; ++i
)
622 SubExprs
[i
+ARGS_START
] = args
[i
];
624 RParenLoc
= rparenloc
;
627 CallExpr::CallExpr(ASTContext
&C
, StmtClass SC
, EmptyShell Empty
)
628 : Expr(SC
, Empty
), SubExprs(0), NumArgs(0) {
629 SubExprs
= new (C
) Stmt
*[1];
632 Decl
*CallExpr::getCalleeDecl() {
633 Expr
*CEE
= getCallee()->IgnoreParenCasts();
634 // If we're calling a dereference, look at the pointer instead.
635 if (BinaryOperator
*BO
= dyn_cast
<BinaryOperator
>(CEE
)) {
636 if (BO
->isPtrMemOp())
637 CEE
= BO
->getRHS()->IgnoreParenCasts();
638 } else if (UnaryOperator
*UO
= dyn_cast
<UnaryOperator
>(CEE
)) {
639 if (UO
->getOpcode() == UO_Deref
)
640 CEE
= UO
->getSubExpr()->IgnoreParenCasts();
642 if (DeclRefExpr
*DRE
= dyn_cast
<DeclRefExpr
>(CEE
))
643 return DRE
->getDecl();
644 if (MemberExpr
*ME
= dyn_cast
<MemberExpr
>(CEE
))
645 return ME
->getMemberDecl();
650 FunctionDecl
*CallExpr::getDirectCallee() {
651 return dyn_cast_or_null
<FunctionDecl
>(getCalleeDecl());
654 /// setNumArgs - This changes the number of arguments present in this call.
655 /// Any orphaned expressions are deleted by this, and any new operands are set
657 void CallExpr::setNumArgs(ASTContext
& C
, unsigned NumArgs
) {
658 // No change, just return.
659 if (NumArgs
== getNumArgs()) return;
661 // If shrinking # arguments, just delete the extras and forgot them.
662 if (NumArgs
< getNumArgs()) {
663 this->NumArgs
= NumArgs
;
667 // Otherwise, we are growing the # arguments. New an bigger argument array.
668 Stmt
**NewSubExprs
= new (C
) Stmt
*[NumArgs
+1];
670 for (unsigned i
= 0; i
!= getNumArgs()+ARGS_START
; ++i
)
671 NewSubExprs
[i
] = SubExprs
[i
];
672 // Null out new args.
673 for (unsigned i
= getNumArgs()+ARGS_START
; i
!= NumArgs
+ARGS_START
; ++i
)
676 if (SubExprs
) C
.Deallocate(SubExprs
);
677 SubExprs
= NewSubExprs
;
678 this->NumArgs
= NumArgs
;
681 /// isBuiltinCall - If this is a call to a builtin, return the builtin ID. If
683 unsigned CallExpr::isBuiltinCall(ASTContext
&Context
) const {
684 // All simple function calls (e.g. func()) are implicitly cast to pointer to
685 // function. As a result, we try and obtain the DeclRefExpr from the
687 const ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(getCallee());
688 if (!ICE
) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
691 const DeclRefExpr
*DRE
= dyn_cast
<DeclRefExpr
>(ICE
->getSubExpr());
695 const FunctionDecl
*FDecl
= dyn_cast
<FunctionDecl
>(DRE
->getDecl());
699 if (!FDecl
->getIdentifier())
702 return FDecl
->getBuiltinID();
705 QualType
CallExpr::getCallReturnType() const {
706 QualType CalleeType
= getCallee()->getType();
707 if (const PointerType
*FnTypePtr
= CalleeType
->getAs
<PointerType
>())
708 CalleeType
= FnTypePtr
->getPointeeType();
709 else if (const BlockPointerType
*BPT
= CalleeType
->getAs
<BlockPointerType
>())
710 CalleeType
= BPT
->getPointeeType();
711 else if (const MemberPointerType
*MPT
712 = CalleeType
->getAs
<MemberPointerType
>())
713 CalleeType
= MPT
->getPointeeType();
715 const FunctionType
*FnType
= CalleeType
->getAs
<FunctionType
>();
716 return FnType
->getResultType();
719 OffsetOfExpr
*OffsetOfExpr::Create(ASTContext
&C
, QualType type
,
720 SourceLocation OperatorLoc
,
722 OffsetOfNode
* compsPtr
, unsigned numComps
,
723 Expr
** exprsPtr
, unsigned numExprs
,
724 SourceLocation RParenLoc
) {
725 void *Mem
= C
.Allocate(sizeof(OffsetOfExpr
) +
726 sizeof(OffsetOfNode
) * numComps
+
727 sizeof(Expr
*) * numExprs
);
729 return new (Mem
) OffsetOfExpr(C
, type
, OperatorLoc
, tsi
, compsPtr
, numComps
,
730 exprsPtr
, numExprs
, RParenLoc
);
733 OffsetOfExpr
*OffsetOfExpr::CreateEmpty(ASTContext
&C
,
734 unsigned numComps
, unsigned numExprs
) {
735 void *Mem
= C
.Allocate(sizeof(OffsetOfExpr
) +
736 sizeof(OffsetOfNode
) * numComps
+
737 sizeof(Expr
*) * numExprs
);
738 return new (Mem
) OffsetOfExpr(numComps
, numExprs
);
741 OffsetOfExpr::OffsetOfExpr(ASTContext
&C
, QualType type
,
742 SourceLocation OperatorLoc
, TypeSourceInfo
*tsi
,
743 OffsetOfNode
* compsPtr
, unsigned numComps
,
744 Expr
** exprsPtr
, unsigned numExprs
,
745 SourceLocation RParenLoc
)
746 : Expr(OffsetOfExprClass
, type
, VK_RValue
, OK_Ordinary
,
747 /*TypeDependent=*/false,
748 /*ValueDependent=*/tsi
->getType()->isDependentType() ||
749 hasAnyTypeDependentArguments(exprsPtr
, numExprs
) ||
750 hasAnyValueDependentArguments(exprsPtr
, numExprs
)),
751 OperatorLoc(OperatorLoc
), RParenLoc(RParenLoc
), TSInfo(tsi
),
752 NumComps(numComps
), NumExprs(numExprs
)
754 for(unsigned i
= 0; i
< numComps
; ++i
) {
755 setComponent(i
, compsPtr
[i
]);
758 for(unsigned i
= 0; i
< numExprs
; ++i
) {
759 setIndexExpr(i
, exprsPtr
[i
]);
763 IdentifierInfo
*OffsetOfExpr::OffsetOfNode::getFieldName() const {
764 assert(getKind() == Field
|| getKind() == Identifier
);
765 if (getKind() == Field
)
766 return getField()->getIdentifier();
768 return reinterpret_cast<IdentifierInfo
*> (Data
& ~(uintptr_t)Mask
);
771 MemberExpr
*MemberExpr::Create(ASTContext
&C
, Expr
*base
, bool isarrow
,
772 NestedNameSpecifier
*qual
,
773 SourceRange qualrange
,
774 ValueDecl
*memberdecl
,
775 DeclAccessPair founddecl
,
776 DeclarationNameInfo nameinfo
,
777 const TemplateArgumentListInfo
*targs
,
781 std::size_t Size
= sizeof(MemberExpr
);
783 bool hasQualOrFound
= (qual
!= 0 ||
784 founddecl
.getDecl() != memberdecl
||
785 founddecl
.getAccess() != memberdecl
->getAccess());
787 Size
+= sizeof(MemberNameQualifier
);
790 Size
+= ExplicitTemplateArgumentList::sizeFor(*targs
);
792 void *Mem
= C
.Allocate(Size
, llvm::alignOf
<MemberExpr
>());
793 MemberExpr
*E
= new (Mem
) MemberExpr(base
, isarrow
, memberdecl
, nameinfo
,
796 if (hasQualOrFound
) {
797 if (qual
&& qual
->isDependent()) {
798 E
->setValueDependent(true);
799 E
->setTypeDependent(true);
801 E
->HasQualifierOrFoundDecl
= true;
803 MemberNameQualifier
*NQ
= E
->getMemberQualifier();
805 NQ
->Range
= qualrange
;
806 NQ
->FoundDecl
= founddecl
;
810 E
->HasExplicitTemplateArgumentList
= true;
811 E
->getExplicitTemplateArgs().initializeFrom(*targs
);
817 const char *CastExpr::getCastKindName() const {
818 switch (getCastKind()) {
823 case CK_LValueBitCast
:
824 return "LValueBitCast";
825 case CK_LValueToRValue
:
826 return "LValueToRValue";
827 case CK_GetObjCProperty
:
828 return "GetObjCProperty";
831 case CK_BaseToDerived
:
832 return "BaseToDerived";
833 case CK_DerivedToBase
:
834 return "DerivedToBase";
835 case CK_UncheckedDerivedToBase
:
836 return "UncheckedDerivedToBase";
841 case CK_ArrayToPointerDecay
:
842 return "ArrayToPointerDecay";
843 case CK_FunctionToPointerDecay
:
844 return "FunctionToPointerDecay";
845 case CK_NullToMemberPointer
:
846 return "NullToMemberPointer";
847 case CK_NullToPointer
:
848 return "NullToPointer";
849 case CK_BaseToDerivedMemberPointer
:
850 return "BaseToDerivedMemberPointer";
851 case CK_DerivedToBaseMemberPointer
:
852 return "DerivedToBaseMemberPointer";
853 case CK_UserDefinedConversion
:
854 return "UserDefinedConversion";
855 case CK_ConstructorConversion
:
856 return "ConstructorConversion";
857 case CK_IntegralToPointer
:
858 return "IntegralToPointer";
859 case CK_PointerToIntegral
:
860 return "PointerToIntegral";
861 case CK_PointerToBoolean
:
862 return "PointerToBoolean";
866 return "VectorSplat";
867 case CK_IntegralCast
:
868 return "IntegralCast";
869 case CK_IntegralToBoolean
:
870 return "IntegralToBoolean";
871 case CK_IntegralToFloating
:
872 return "IntegralToFloating";
873 case CK_FloatingToIntegral
:
874 return "FloatingToIntegral";
875 case CK_FloatingCast
:
876 return "FloatingCast";
877 case CK_FloatingToBoolean
:
878 return "FloatingToBoolean";
879 case CK_MemberPointerToBoolean
:
880 return "MemberPointerToBoolean";
881 case CK_AnyPointerToObjCPointerCast
:
882 return "AnyPointerToObjCPointerCast";
883 case CK_AnyPointerToBlockPointerCast
:
884 return "AnyPointerToBlockPointerCast";
885 case CK_ObjCObjectLValueCast
:
886 return "ObjCObjectLValueCast";
887 case CK_FloatingRealToComplex
:
888 return "FloatingRealToComplex";
889 case CK_FloatingComplexToReal
:
890 return "FloatingComplexToReal";
891 case CK_FloatingComplexToBoolean
:
892 return "FloatingComplexToBoolean";
893 case CK_FloatingComplexCast
:
894 return "FloatingComplexCast";
895 case CK_FloatingComplexToIntegralComplex
:
896 return "FloatingComplexToIntegralComplex";
897 case CK_IntegralRealToComplex
:
898 return "IntegralRealToComplex";
899 case CK_IntegralComplexToReal
:
900 return "IntegralComplexToReal";
901 case CK_IntegralComplexToBoolean
:
902 return "IntegralComplexToBoolean";
903 case CK_IntegralComplexCast
:
904 return "IntegralComplexCast";
905 case CK_IntegralComplexToFloatingComplex
:
906 return "IntegralComplexToFloatingComplex";
909 llvm_unreachable("Unhandled cast kind!");
913 Expr
*CastExpr::getSubExprAsWritten() {
917 SubExpr
= E
->getSubExpr();
919 // Skip any temporary bindings; they're implicit.
920 if (CXXBindTemporaryExpr
*Binder
= dyn_cast
<CXXBindTemporaryExpr
>(SubExpr
))
921 SubExpr
= Binder
->getSubExpr();
923 // Conversions by constructor and conversion functions have a
924 // subexpression describing the call; strip it off.
925 if (E
->getCastKind() == CK_ConstructorConversion
)
926 SubExpr
= cast
<CXXConstructExpr
>(SubExpr
)->getArg(0);
927 else if (E
->getCastKind() == CK_UserDefinedConversion
)
928 SubExpr
= cast
<CXXMemberCallExpr
>(SubExpr
)->getImplicitObjectArgument();
930 // If the subexpression we're left with is an implicit cast, look
931 // through that, too.
932 } while ((E
= dyn_cast
<ImplicitCastExpr
>(SubExpr
)));
937 CXXBaseSpecifier
**CastExpr::path_buffer() {
938 switch (getStmtClass()) {
939 #define ABSTRACT_STMT(x)
940 #define CASTEXPR(Type, Base) \
941 case Stmt::Type##Class: \
942 return reinterpret_cast<CXXBaseSpecifier**>(static_cast<Type*>(this)+1);
943 #define STMT(Type, Base)
944 #include "clang/AST/StmtNodes.inc"
946 llvm_unreachable("non-cast expressions not possible here");
951 void CastExpr::setCastPath(const CXXCastPath
&Path
) {
952 assert(Path
.size() == path_size());
953 memcpy(path_buffer(), Path
.data(), Path
.size() * sizeof(CXXBaseSpecifier
*));
956 ImplicitCastExpr
*ImplicitCastExpr::Create(ASTContext
&C
, QualType T
,
957 CastKind Kind
, Expr
*Operand
,
958 const CXXCastPath
*BasePath
,
960 unsigned PathSize
= (BasePath
? BasePath
->size() : 0);
962 C
.Allocate(sizeof(ImplicitCastExpr
) + PathSize
* sizeof(CXXBaseSpecifier
*));
963 ImplicitCastExpr
*E
=
964 new (Buffer
) ImplicitCastExpr(T
, Kind
, Operand
, PathSize
, VK
);
965 if (PathSize
) E
->setCastPath(*BasePath
);
969 ImplicitCastExpr
*ImplicitCastExpr::CreateEmpty(ASTContext
&C
,
972 C
.Allocate(sizeof(ImplicitCastExpr
) + PathSize
* sizeof(CXXBaseSpecifier
*));
973 return new (Buffer
) ImplicitCastExpr(EmptyShell(), PathSize
);
977 CStyleCastExpr
*CStyleCastExpr::Create(ASTContext
&C
, QualType T
,
978 ExprValueKind VK
, CastKind K
, Expr
*Op
,
979 const CXXCastPath
*BasePath
,
980 TypeSourceInfo
*WrittenTy
,
981 SourceLocation L
, SourceLocation R
) {
982 unsigned PathSize
= (BasePath
? BasePath
->size() : 0);
984 C
.Allocate(sizeof(CStyleCastExpr
) + PathSize
* sizeof(CXXBaseSpecifier
*));
986 new (Buffer
) CStyleCastExpr(T
, VK
, K
, Op
, PathSize
, WrittenTy
, L
, R
);
987 if (PathSize
) E
->setCastPath(*BasePath
);
991 CStyleCastExpr
*CStyleCastExpr::CreateEmpty(ASTContext
&C
, unsigned PathSize
) {
993 C
.Allocate(sizeof(CStyleCastExpr
) + PathSize
* sizeof(CXXBaseSpecifier
*));
994 return new (Buffer
) CStyleCastExpr(EmptyShell(), PathSize
);
997 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
998 /// corresponds to, e.g. "<<=".
999 const char *BinaryOperator::getOpcodeStr(Opcode Op
) {
1001 case BO_PtrMemD
: return ".*";
1002 case BO_PtrMemI
: return "->*";
1003 case BO_Mul
: return "*";
1004 case BO_Div
: return "/";
1005 case BO_Rem
: return "%";
1006 case BO_Add
: return "+";
1007 case BO_Sub
: return "-";
1008 case BO_Shl
: return "<<";
1009 case BO_Shr
: return ">>";
1010 case BO_LT
: return "<";
1011 case BO_GT
: return ">";
1012 case BO_LE
: return "<=";
1013 case BO_GE
: return ">=";
1014 case BO_EQ
: return "==";
1015 case BO_NE
: return "!=";
1016 case BO_And
: return "&";
1017 case BO_Xor
: return "^";
1018 case BO_Or
: return "|";
1019 case BO_LAnd
: return "&&";
1020 case BO_LOr
: return "||";
1021 case BO_Assign
: return "=";
1022 case BO_MulAssign
: return "*=";
1023 case BO_DivAssign
: return "/=";
1024 case BO_RemAssign
: return "%=";
1025 case BO_AddAssign
: return "+=";
1026 case BO_SubAssign
: return "-=";
1027 case BO_ShlAssign
: return "<<=";
1028 case BO_ShrAssign
: return ">>=";
1029 case BO_AndAssign
: return "&=";
1030 case BO_XorAssign
: return "^=";
1031 case BO_OrAssign
: return "|=";
1032 case BO_Comma
: return ",";
1039 BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO
) {
1041 default: assert(false && "Not an overloadable binary operator");
1042 case OO_Plus
: return BO_Add
;
1043 case OO_Minus
: return BO_Sub
;
1044 case OO_Star
: return BO_Mul
;
1045 case OO_Slash
: return BO_Div
;
1046 case OO_Percent
: return BO_Rem
;
1047 case OO_Caret
: return BO_Xor
;
1048 case OO_Amp
: return BO_And
;
1049 case OO_Pipe
: return BO_Or
;
1050 case OO_Equal
: return BO_Assign
;
1051 case OO_Less
: return BO_LT
;
1052 case OO_Greater
: return BO_GT
;
1053 case OO_PlusEqual
: return BO_AddAssign
;
1054 case OO_MinusEqual
: return BO_SubAssign
;
1055 case OO_StarEqual
: return BO_MulAssign
;
1056 case OO_SlashEqual
: return BO_DivAssign
;
1057 case OO_PercentEqual
: return BO_RemAssign
;
1058 case OO_CaretEqual
: return BO_XorAssign
;
1059 case OO_AmpEqual
: return BO_AndAssign
;
1060 case OO_PipeEqual
: return BO_OrAssign
;
1061 case OO_LessLess
: return BO_Shl
;
1062 case OO_GreaterGreater
: return BO_Shr
;
1063 case OO_LessLessEqual
: return BO_ShlAssign
;
1064 case OO_GreaterGreaterEqual
: return BO_ShrAssign
;
1065 case OO_EqualEqual
: return BO_EQ
;
1066 case OO_ExclaimEqual
: return BO_NE
;
1067 case OO_LessEqual
: return BO_LE
;
1068 case OO_GreaterEqual
: return BO_GE
;
1069 case OO_AmpAmp
: return BO_LAnd
;
1070 case OO_PipePipe
: return BO_LOr
;
1071 case OO_Comma
: return BO_Comma
;
1072 case OO_ArrowStar
: return BO_PtrMemI
;
1076 OverloadedOperatorKind
BinaryOperator::getOverloadedOperator(Opcode Opc
) {
1077 static const OverloadedOperatorKind OverOps
[] = {
1078 /* .* Cannot be overloaded */OO_None
, OO_ArrowStar
,
1079 OO_Star
, OO_Slash
, OO_Percent
,
1081 OO_LessLess
, OO_GreaterGreater
,
1082 OO_Less
, OO_Greater
, OO_LessEqual
, OO_GreaterEqual
,
1083 OO_EqualEqual
, OO_ExclaimEqual
,
1089 OO_Equal
, OO_StarEqual
,
1090 OO_SlashEqual
, OO_PercentEqual
,
1091 OO_PlusEqual
, OO_MinusEqual
,
1092 OO_LessLessEqual
, OO_GreaterGreaterEqual
,
1093 OO_AmpEqual
, OO_CaretEqual
,
1097 return OverOps
[Opc
];
1100 InitListExpr::InitListExpr(ASTContext
&C
, SourceLocation lbraceloc
,
1101 Expr
**initExprs
, unsigned numInits
,
1102 SourceLocation rbraceloc
)
1103 : Expr(InitListExprClass
, QualType(), VK_RValue
, OK_Ordinary
, false, false),
1104 InitExprs(C
, numInits
),
1105 LBraceLoc(lbraceloc
), RBraceLoc(rbraceloc
), SyntacticForm(0),
1106 UnionFieldInit(0), HadArrayRangeDesignator(false)
1108 for (unsigned I
= 0; I
!= numInits
; ++I
) {
1109 if (initExprs
[I
]->isTypeDependent())
1110 ExprBits
.TypeDependent
= true;
1111 if (initExprs
[I
]->isValueDependent())
1112 ExprBits
.ValueDependent
= true;
1115 InitExprs
.insert(C
, InitExprs
.end(), initExprs
, initExprs
+numInits
);
1118 void InitListExpr::reserveInits(ASTContext
&C
, unsigned NumInits
) {
1119 if (NumInits
> InitExprs
.size())
1120 InitExprs
.reserve(C
, NumInits
);
1123 void InitListExpr::resizeInits(ASTContext
&C
, unsigned NumInits
) {
1124 InitExprs
.resize(C
, NumInits
, 0);
1127 Expr
*InitListExpr::updateInit(ASTContext
&C
, unsigned Init
, Expr
*expr
) {
1128 if (Init
>= InitExprs
.size()) {
1129 InitExprs
.insert(C
, InitExprs
.end(), Init
- InitExprs
.size() + 1, 0);
1130 InitExprs
.back() = expr
;
1134 Expr
*Result
= cast_or_null
<Expr
>(InitExprs
[Init
]);
1135 InitExprs
[Init
] = expr
;
1139 SourceRange
InitListExpr::getSourceRange() const {
1141 return SyntacticForm
->getSourceRange();
1142 SourceLocation Beg
= LBraceLoc
, End
= RBraceLoc
;
1143 if (Beg
.isInvalid()) {
1144 // Find the first non-null initializer.
1145 for (InitExprsTy::const_iterator I
= InitExprs
.begin(),
1146 E
= InitExprs
.end();
1149 Beg
= S
->getLocStart();
1154 if (End
.isInvalid()) {
1155 // Find the first non-null initializer from the end.
1156 for (InitExprsTy::const_reverse_iterator I
= InitExprs
.rbegin(),
1157 E
= InitExprs
.rend();
1160 End
= S
->getSourceRange().getEnd();
1165 return SourceRange(Beg
, End
);
1168 /// getFunctionType - Return the underlying function type for this block.
1170 const FunctionType
*BlockExpr::getFunctionType() const {
1171 return getType()->getAs
<BlockPointerType
>()->
1172 getPointeeType()->getAs
<FunctionType
>();
1175 SourceLocation
BlockExpr::getCaretLocation() const {
1176 return TheBlock
->getCaretLocation();
1178 const Stmt
*BlockExpr::getBody() const {
1179 return TheBlock
->getBody();
1181 Stmt
*BlockExpr::getBody() {
1182 return TheBlock
->getBody();
1186 //===----------------------------------------------------------------------===//
1187 // Generic Expression Routines
1188 //===----------------------------------------------------------------------===//
1190 /// isUnusedResultAWarning - Return true if this immediate expression should
1191 /// be warned about if the result is unused. If so, fill in Loc and Ranges
1192 /// with location to warn on and the source range[s] to report with the
1194 bool Expr::isUnusedResultAWarning(SourceLocation
&Loc
, SourceRange
&R1
,
1195 SourceRange
&R2
, ASTContext
&Ctx
) const {
1196 // Don't warn if the expr is type dependent. The type could end up
1197 // instantiating to void.
1198 if (isTypeDependent())
1201 switch (getStmtClass()) {
1203 if (getType()->isVoidType())
1206 R1
= getSourceRange();
1208 case ParenExprClass
:
1209 return cast
<ParenExpr
>(this)->getSubExpr()->
1210 isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
);
1211 case UnaryOperatorClass
: {
1212 const UnaryOperator
*UO
= cast
<UnaryOperator
>(this);
1214 switch (UO
->getOpcode()) {
1219 case UO_PreDec
: // ++/--
1220 return false; // Not a warning.
1222 // Dereferencing a volatile pointer is a side-effect.
1223 if (Ctx
.getCanonicalType(getType()).isVolatileQualified())
1228 // accessing a piece of a volatile complex is a side-effect.
1229 if (Ctx
.getCanonicalType(UO
->getSubExpr()->getType())
1230 .isVolatileQualified())
1234 return UO
->getSubExpr()->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
);
1236 Loc
= UO
->getOperatorLoc();
1237 R1
= UO
->getSubExpr()->getSourceRange();
1240 case BinaryOperatorClass
: {
1241 const BinaryOperator
*BO
= cast
<BinaryOperator
>(this);
1242 switch (BO
->getOpcode()) {
1245 // Consider the RHS of comma for side effects. LHS was checked by
1246 // Sema::CheckCommaOperands.
1248 // ((foo = <blah>), 0) is an idiom for hiding the result (and
1249 // lvalue-ness) of an assignment written in a macro.
1250 if (IntegerLiteral
*IE
=
1251 dyn_cast
<IntegerLiteral
>(BO
->getRHS()->IgnoreParens()))
1252 if (IE
->getValue() == 0)
1254 return BO
->getRHS()->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
);
1255 // Consider '||', '&&' to have side effects if the LHS or RHS does.
1258 if (!BO
->getLHS()->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
) ||
1259 !BO
->getRHS()->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
))
1263 if (BO
->isAssignmentOp())
1265 Loc
= BO
->getOperatorLoc();
1266 R1
= BO
->getLHS()->getSourceRange();
1267 R2
= BO
->getRHS()->getSourceRange();
1270 case CompoundAssignOperatorClass
:
1271 case VAArgExprClass
:
1274 case ConditionalOperatorClass
: {
1275 // The condition must be evaluated, but if either the LHS or RHS is a
1276 // warning, warn about them.
1277 const ConditionalOperator
*Exp
= cast
<ConditionalOperator
>(this);
1278 if (Exp
->getLHS() &&
1279 Exp
->getLHS()->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
))
1281 return Exp
->getRHS()->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
);
1284 case MemberExprClass
:
1285 // If the base pointer or element is to a volatile pointer/field, accessing
1286 // it is a side effect.
1287 if (Ctx
.getCanonicalType(getType()).isVolatileQualified())
1289 Loc
= cast
<MemberExpr
>(this)->getMemberLoc();
1290 R1
= SourceRange(Loc
, Loc
);
1291 R2
= cast
<MemberExpr
>(this)->getBase()->getSourceRange();
1294 case ArraySubscriptExprClass
:
1295 // If the base pointer or element is to a volatile pointer/field, accessing
1296 // it is a side effect.
1297 if (Ctx
.getCanonicalType(getType()).isVolatileQualified())
1299 Loc
= cast
<ArraySubscriptExpr
>(this)->getRBracketLoc();
1300 R1
= cast
<ArraySubscriptExpr
>(this)->getLHS()->getSourceRange();
1301 R2
= cast
<ArraySubscriptExpr
>(this)->getRHS()->getSourceRange();
1305 case CXXOperatorCallExprClass
:
1306 case CXXMemberCallExprClass
: {
1307 // If this is a direct call, get the callee.
1308 const CallExpr
*CE
= cast
<CallExpr
>(this);
1309 if (const Decl
*FD
= CE
->getCalleeDecl()) {
1310 // If the callee has attribute pure, const, or warn_unused_result, warn
1311 // about it. void foo() { strlen("bar"); } should warn.
1313 // Note: If new cases are added here, DiagnoseUnusedExprResult should be
1314 // updated to match for QoI.
1315 if (FD
->getAttr
<WarnUnusedResultAttr
>() ||
1316 FD
->getAttr
<PureAttr
>() || FD
->getAttr
<ConstAttr
>()) {
1317 Loc
= CE
->getCallee()->getLocStart();
1318 R1
= CE
->getCallee()->getSourceRange();
1320 if (unsigned NumArgs
= CE
->getNumArgs())
1321 R2
= SourceRange(CE
->getArg(0)->getLocStart(),
1322 CE
->getArg(NumArgs
-1)->getLocEnd());
1329 case CXXTemporaryObjectExprClass
:
1330 case CXXConstructExprClass
:
1333 case ObjCMessageExprClass
: {
1334 const ObjCMessageExpr
*ME
= cast
<ObjCMessageExpr
>(this);
1335 const ObjCMethodDecl
*MD
= ME
->getMethodDecl();
1336 if (MD
&& MD
->getAttr
<WarnUnusedResultAttr
>()) {
1343 case ObjCPropertyRefExprClass
:
1345 R1
= getSourceRange();
1348 case StmtExprClass
: {
1349 // Statement exprs don't logically have side effects themselves, but are
1350 // sometimes used in macros in ways that give them a type that is unused.
1351 // For example ({ blah; foo(); }) will end up with a type if foo has a type.
1352 // however, if the result of the stmt expr is dead, we don't want to emit a
1354 const CompoundStmt
*CS
= cast
<StmtExpr
>(this)->getSubStmt();
1355 if (!CS
->body_empty()) {
1356 if (const Expr
*E
= dyn_cast
<Expr
>(CS
->body_back()))
1357 return E
->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
);
1358 if (const LabelStmt
*Label
= dyn_cast
<LabelStmt
>(CS
->body_back()))
1359 if (const Expr
*E
= dyn_cast
<Expr
>(Label
->getSubStmt()))
1360 return E
->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
);
1363 if (getType()->isVoidType())
1365 Loc
= cast
<StmtExpr
>(this)->getLParenLoc();
1366 R1
= getSourceRange();
1369 case CStyleCastExprClass
:
1370 // If this is an explicit cast to void, allow it. People do this when they
1371 // think they know what they're doing :).
1372 if (getType()->isVoidType())
1374 Loc
= cast
<CStyleCastExpr
>(this)->getLParenLoc();
1375 R1
= cast
<CStyleCastExpr
>(this)->getSubExpr()->getSourceRange();
1377 case CXXFunctionalCastExprClass
: {
1378 if (getType()->isVoidType())
1380 const CastExpr
*CE
= cast
<CastExpr
>(this);
1382 // If this is a cast to void or a constructor conversion, check the operand.
1383 // Otherwise, the result of the cast is unused.
1384 if (CE
->getCastKind() == CK_ToVoid
||
1385 CE
->getCastKind() == CK_ConstructorConversion
)
1386 return (cast
<CastExpr
>(this)->getSubExpr()
1387 ->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
));
1388 Loc
= cast
<CXXFunctionalCastExpr
>(this)->getTypeBeginLoc();
1389 R1
= cast
<CXXFunctionalCastExpr
>(this)->getSubExpr()->getSourceRange();
1393 case ImplicitCastExprClass
:
1394 // Check the operand, since implicit casts are inserted by Sema
1395 return (cast
<ImplicitCastExpr
>(this)
1396 ->getSubExpr()->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
));
1398 case CXXDefaultArgExprClass
:
1399 return (cast
<CXXDefaultArgExpr
>(this)
1400 ->getExpr()->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
));
1402 case CXXNewExprClass
:
1403 // FIXME: In theory, there might be new expressions that don't have side
1404 // effects (e.g. a placement new with an uninitialized POD).
1405 case CXXDeleteExprClass
:
1407 case CXXBindTemporaryExprClass
:
1408 return (cast
<CXXBindTemporaryExpr
>(this)
1409 ->getSubExpr()->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
));
1410 case ExprWithCleanupsClass
:
1411 return (cast
<ExprWithCleanups
>(this)
1412 ->getSubExpr()->isUnusedResultAWarning(Loc
, R1
, R2
, Ctx
));
1416 /// isOBJCGCCandidate - Check if an expression is objc gc'able.
1417 /// returns true, if it is; false otherwise.
1418 bool Expr::isOBJCGCCandidate(ASTContext
&Ctx
) const {
1419 switch (getStmtClass()) {
1422 case ObjCIvarRefExprClass
:
1424 case Expr::UnaryOperatorClass
:
1425 return cast
<UnaryOperator
>(this)->getSubExpr()->isOBJCGCCandidate(Ctx
);
1426 case ParenExprClass
:
1427 return cast
<ParenExpr
>(this)->getSubExpr()->isOBJCGCCandidate(Ctx
);
1428 case ImplicitCastExprClass
:
1429 return cast
<ImplicitCastExpr
>(this)->getSubExpr()->isOBJCGCCandidate(Ctx
);
1430 case CStyleCastExprClass
:
1431 return cast
<CStyleCastExpr
>(this)->getSubExpr()->isOBJCGCCandidate(Ctx
);
1432 case DeclRefExprClass
: {
1433 const Decl
*D
= cast
<DeclRefExpr
>(this)->getDecl();
1434 if (const VarDecl
*VD
= dyn_cast
<VarDecl
>(D
)) {
1435 if (VD
->hasGlobalStorage())
1437 QualType T
= VD
->getType();
1438 // dereferencing to a pointer is always a gc'able candidate,
1439 // unless it is __weak.
1440 return T
->isPointerType() &&
1441 (Ctx
.getObjCGCAttrKind(T
) != Qualifiers::Weak
);
1445 case MemberExprClass
: {
1446 const MemberExpr
*M
= cast
<MemberExpr
>(this);
1447 return M
->getBase()->isOBJCGCCandidate(Ctx
);
1449 case ArraySubscriptExprClass
:
1450 return cast
<ArraySubscriptExpr
>(this)->getBase()->isOBJCGCCandidate(Ctx
);
1454 bool Expr::isBoundMemberFunction(ASTContext
&Ctx
) const {
1455 if (isTypeDependent())
1457 return ClassifyLValue(Ctx
) == Expr::LV_MemberFunction
;
1460 static Expr::CanThrowResult
MergeCanThrow(Expr::CanThrowResult CT1
,
1461 Expr::CanThrowResult CT2
) {
1462 // CanThrowResult constants are ordered so that the maximum is the correct
1464 return CT1
> CT2
? CT1
: CT2
;
1467 static Expr::CanThrowResult
CanSubExprsThrow(ASTContext
&C
, const Expr
*CE
) {
1468 Expr
*E
= const_cast<Expr
*>(CE
);
1469 Expr::CanThrowResult R
= Expr::CT_Cannot
;
1470 for (Expr::child_iterator I
= E
->child_begin(), IE
= E
->child_end();
1471 I
!= IE
&& R
!= Expr::CT_Can
; ++I
) {
1472 R
= MergeCanThrow(R
, cast
<Expr
>(*I
)->CanThrow(C
));
1477 static Expr::CanThrowResult
CanCalleeThrow(const Decl
*D
,
1478 bool NullThrows
= true) {
1480 return NullThrows
? Expr::CT_Can
: Expr::CT_Cannot
;
1482 // See if we can get a function type from the decl somehow.
1483 const ValueDecl
*VD
= dyn_cast
<ValueDecl
>(D
);
1484 if (!VD
) // If we have no clue what we're calling, assume the worst.
1485 return Expr::CT_Can
;
1487 // As an extension, we assume that __attribute__((nothrow)) functions don't
1489 if (isa
<FunctionDecl
>(D
) && D
->hasAttr
<NoThrowAttr
>())
1490 return Expr::CT_Cannot
;
1492 QualType T
= VD
->getType();
1493 const FunctionProtoType
*FT
;
1494 if ((FT
= T
->getAs
<FunctionProtoType
>())) {
1495 } else if (const PointerType
*PT
= T
->getAs
<PointerType
>())
1496 FT
= PT
->getPointeeType()->getAs
<FunctionProtoType
>();
1497 else if (const ReferenceType
*RT
= T
->getAs
<ReferenceType
>())
1498 FT
= RT
->getPointeeType()->getAs
<FunctionProtoType
>();
1499 else if (const MemberPointerType
*MT
= T
->getAs
<MemberPointerType
>())
1500 FT
= MT
->getPointeeType()->getAs
<FunctionProtoType
>();
1501 else if (const BlockPointerType
*BT
= T
->getAs
<BlockPointerType
>())
1502 FT
= BT
->getPointeeType()->getAs
<FunctionProtoType
>();
1505 return Expr::CT_Can
;
1507 return FT
->hasEmptyExceptionSpec() ? Expr::CT_Cannot
: Expr::CT_Can
;
1510 static Expr::CanThrowResult
CanDynamicCastThrow(const CXXDynamicCastExpr
*DC
) {
1511 if (DC
->isTypeDependent())
1512 return Expr::CT_Dependent
;
1514 if (!DC
->getTypeAsWritten()->isReferenceType())
1515 return Expr::CT_Cannot
;
1517 return DC
->getCastKind() == clang::CK_Dynamic
? Expr::CT_Can
: Expr::CT_Cannot
;
1520 static Expr::CanThrowResult
CanTypeidThrow(ASTContext
&C
,
1521 const CXXTypeidExpr
*DC
) {
1522 if (DC
->isTypeOperand())
1523 return Expr::CT_Cannot
;
1525 Expr
*Op
= DC
->getExprOperand();
1526 if (Op
->isTypeDependent())
1527 return Expr::CT_Dependent
;
1529 const RecordType
*RT
= Op
->getType()->getAs
<RecordType
>();
1531 return Expr::CT_Cannot
;
1533 if (!cast
<CXXRecordDecl
>(RT
->getDecl())->isPolymorphic())
1534 return Expr::CT_Cannot
;
1536 if (Op
->Classify(C
).isPRValue())
1537 return Expr::CT_Cannot
;
1539 return Expr::CT_Can
;
1542 Expr::CanThrowResult
Expr::CanThrow(ASTContext
&C
) const {
1543 // C++ [expr.unary.noexcept]p3:
1544 // [Can throw] if in a potentially-evaluated context the expression would
1546 switch (getStmtClass()) {
1547 case CXXThrowExprClass
:
1548 // - a potentially evaluated throw-expression
1551 case CXXDynamicCastExprClass
: {
1552 // - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1553 // where T is a reference type, that requires a run-time check
1554 CanThrowResult CT
= CanDynamicCastThrow(cast
<CXXDynamicCastExpr
>(this));
1557 return MergeCanThrow(CT
, CanSubExprsThrow(C
, this));
1560 case CXXTypeidExprClass
:
1561 // - a potentially evaluated typeid expression applied to a glvalue
1562 // expression whose type is a polymorphic class type
1563 return CanTypeidThrow(C
, cast
<CXXTypeidExpr
>(this));
1565 // - a potentially evaluated call to a function, member function, function
1566 // pointer, or member function pointer that does not have a non-throwing
1567 // exception-specification
1569 case CXXOperatorCallExprClass
:
1570 case CXXMemberCallExprClass
: {
1571 CanThrowResult CT
= CanCalleeThrow(cast
<CallExpr
>(this)->getCalleeDecl());
1574 return MergeCanThrow(CT
, CanSubExprsThrow(C
, this));
1577 case CXXConstructExprClass
:
1578 case CXXTemporaryObjectExprClass
: {
1579 CanThrowResult CT
= CanCalleeThrow(
1580 cast
<CXXConstructExpr
>(this)->getConstructor());
1583 return MergeCanThrow(CT
, CanSubExprsThrow(C
, this));
1586 case CXXNewExprClass
: {
1587 CanThrowResult CT
= MergeCanThrow(
1588 CanCalleeThrow(cast
<CXXNewExpr
>(this)->getOperatorNew()),
1589 CanCalleeThrow(cast
<CXXNewExpr
>(this)->getConstructor(),
1590 /*NullThrows*/false));
1593 return MergeCanThrow(CT
, CanSubExprsThrow(C
, this));
1596 case CXXDeleteExprClass
: {
1597 CanThrowResult CT
= CanCalleeThrow(
1598 cast
<CXXDeleteExpr
>(this)->getOperatorDelete());
1601 const Expr
*Arg
= cast
<CXXDeleteExpr
>(this)->getArgument();
1602 // Unwrap exactly one implicit cast, which converts all pointers to void*.
1603 if (const ImplicitCastExpr
*Cast
= dyn_cast
<ImplicitCastExpr
>(Arg
))
1604 Arg
= Cast
->getSubExpr();
1605 if (const PointerType
*PT
= Arg
->getType()->getAs
<PointerType
>()) {
1606 if (const RecordType
*RT
= PT
->getPointeeType()->getAs
<RecordType
>()) {
1607 CanThrowResult CT2
= CanCalleeThrow(
1608 cast
<CXXRecordDecl
>(RT
->getDecl())->getDestructor());
1611 CT
= MergeCanThrow(CT
, CT2
);
1614 return MergeCanThrow(CT
, CanSubExprsThrow(C
, this));
1617 case CXXBindTemporaryExprClass
: {
1618 // The bound temporary has to be destroyed again, which might throw.
1619 CanThrowResult CT
= CanCalleeThrow(
1620 cast
<CXXBindTemporaryExpr
>(this)->getTemporary()->getDestructor());
1623 return MergeCanThrow(CT
, CanSubExprsThrow(C
, this));
1626 // ObjC message sends are like function calls, but never have exception
1628 case ObjCMessageExprClass
:
1629 case ObjCPropertyRefExprClass
:
1632 // Many other things have subexpressions, so we have to test those.
1634 case ParenExprClass
:
1635 case MemberExprClass
:
1636 case CXXReinterpretCastExprClass
:
1637 case CXXConstCastExprClass
:
1638 case ConditionalOperatorClass
:
1639 case CompoundLiteralExprClass
:
1640 case ExtVectorElementExprClass
:
1641 case InitListExprClass
:
1642 case DesignatedInitExprClass
:
1643 case ParenListExprClass
:
1644 case VAArgExprClass
:
1645 case CXXDefaultArgExprClass
:
1646 case ExprWithCleanupsClass
:
1647 case ObjCIvarRefExprClass
:
1648 case ObjCIsaExprClass
:
1649 case ShuffleVectorExprClass
:
1650 return CanSubExprsThrow(C
, this);
1652 // Some might be dependent for other reasons.
1653 case UnaryOperatorClass
:
1654 case ArraySubscriptExprClass
:
1655 case ImplicitCastExprClass
:
1656 case CStyleCastExprClass
:
1657 case CXXStaticCastExprClass
:
1658 case CXXFunctionalCastExprClass
:
1659 case BinaryOperatorClass
:
1660 case CompoundAssignOperatorClass
: {
1661 CanThrowResult CT
= isTypeDependent() ? CT_Dependent
: CT_Cannot
;
1662 return MergeCanThrow(CT
, CanSubExprsThrow(C
, this));
1665 // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms.
1669 case ChooseExprClass
:
1670 if (isTypeDependent() || isValueDependent())
1671 return CT_Dependent
;
1672 return cast
<ChooseExpr
>(this)->getChosenSubExpr(C
)->CanThrow(C
);
1674 // Some expressions are always dependent.
1675 case DependentScopeDeclRefExprClass
:
1676 case CXXUnresolvedConstructExprClass
:
1677 case CXXDependentScopeMemberExprClass
:
1678 return CT_Dependent
;
1681 // All other expressions don't have subexpressions, or else they are
1687 Expr
* Expr::IgnoreParens() {
1690 if (ParenExpr
* P
= dyn_cast
<ParenExpr
>(E
)) {
1691 E
= P
->getSubExpr();
1694 if (UnaryOperator
* P
= dyn_cast
<UnaryOperator
>(E
)) {
1695 if (P
->getOpcode() == UO_Extension
) {
1696 E
= P
->getSubExpr();
1704 /// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr
1705 /// or CastExprs or ImplicitCastExprs, returning their operand.
1706 Expr
*Expr::IgnoreParenCasts() {
1709 if (ParenExpr
* P
= dyn_cast
<ParenExpr
>(E
)) {
1710 E
= P
->getSubExpr();
1713 if (CastExpr
*P
= dyn_cast
<CastExpr
>(E
)) {
1714 E
= P
->getSubExpr();
1717 if (UnaryOperator
* P
= dyn_cast
<UnaryOperator
>(E
)) {
1718 if (P
->getOpcode() == UO_Extension
) {
1719 E
= P
->getSubExpr();
1727 /// IgnoreParenLValueCasts - Ignore parentheses and lvalue-to-rvalue
1728 /// casts. This is intended purely as a temporary workaround for code
1729 /// that hasn't yet been rewritten to do the right thing about those
1730 /// casts, and may disappear along with the last internal use.
1731 Expr
*Expr::IgnoreParenLValueCasts() {
1734 if (ParenExpr
*P
= dyn_cast
<ParenExpr
>(E
)) {
1735 E
= P
->getSubExpr();
1737 } else if (CastExpr
*P
= dyn_cast
<CastExpr
>(E
)) {
1738 if (P
->getCastKind() == CK_LValueToRValue
) {
1739 E
= P
->getSubExpr();
1742 } else if (UnaryOperator
* P
= dyn_cast
<UnaryOperator
>(E
)) {
1743 if (P
->getOpcode() == UO_Extension
) {
1744 E
= P
->getSubExpr();
1753 Expr
*Expr::IgnoreParenImpCasts() {
1756 if (ParenExpr
*P
= dyn_cast
<ParenExpr
>(E
)) {
1757 E
= P
->getSubExpr();
1760 if (ImplicitCastExpr
*P
= dyn_cast
<ImplicitCastExpr
>(E
)) {
1761 E
= P
->getSubExpr();
1764 if (UnaryOperator
* P
= dyn_cast
<UnaryOperator
>(E
)) {
1765 if (P
->getOpcode() == UO_Extension
) {
1766 E
= P
->getSubExpr();
1774 /// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
1775 /// value (including ptr->int casts of the same size). Strip off any
1776 /// ParenExpr or CastExprs, returning their operand.
1777 Expr
*Expr::IgnoreParenNoopCasts(ASTContext
&Ctx
) {
1780 if (ParenExpr
*P
= dyn_cast
<ParenExpr
>(E
)) {
1781 E
= P
->getSubExpr();
1785 if (CastExpr
*P
= dyn_cast
<CastExpr
>(E
)) {
1786 // We ignore integer <-> casts that are of the same width, ptr<->ptr and
1787 // ptr<->int casts of the same width. We also ignore all identity casts.
1788 Expr
*SE
= P
->getSubExpr();
1790 if (Ctx
.hasSameUnqualifiedType(E
->getType(), SE
->getType())) {
1795 if ((E
->getType()->isPointerType() ||
1796 E
->getType()->isIntegralType(Ctx
)) &&
1797 (SE
->getType()->isPointerType() ||
1798 SE
->getType()->isIntegralType(Ctx
)) &&
1799 Ctx
.getTypeSize(E
->getType()) == Ctx
.getTypeSize(SE
->getType())) {
1805 if (UnaryOperator
* P
= dyn_cast
<UnaryOperator
>(E
)) {
1806 if (P
->getOpcode() == UO_Extension
) {
1807 E
= P
->getSubExpr();
1816 bool Expr::isDefaultArgument() const {
1817 const Expr
*E
= this;
1818 while (const ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(E
))
1819 E
= ICE
->getSubExprAsWritten();
1821 return isa
<CXXDefaultArgExpr
>(E
);
1824 /// \brief Skip over any no-op casts and any temporary-binding
1826 static const Expr
*skipTemporaryBindingsNoOpCastsAndParens(const Expr
*E
) {
1827 while (const ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(E
)) {
1828 if (ICE
->getCastKind() == CK_NoOp
)
1829 E
= ICE
->getSubExpr();
1834 while (const CXXBindTemporaryExpr
*BE
= dyn_cast
<CXXBindTemporaryExpr
>(E
))
1835 E
= BE
->getSubExpr();
1837 while (const ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(E
)) {
1838 if (ICE
->getCastKind() == CK_NoOp
)
1839 E
= ICE
->getSubExpr();
1844 return E
->IgnoreParens();
1847 /// isTemporaryObject - Determines if this expression produces a
1848 /// temporary of the given class type.
1849 bool Expr::isTemporaryObject(ASTContext
&C
, const CXXRecordDecl
*TempTy
) const {
1850 if (!C
.hasSameUnqualifiedType(getType(), C
.getTypeDeclType(TempTy
)))
1853 const Expr
*E
= skipTemporaryBindingsNoOpCastsAndParens(this);
1855 // Temporaries are by definition pr-values of class type.
1856 if (!E
->Classify(C
).isPRValue()) {
1857 // In this context, property reference is a message call and is pr-value.
1858 if (!isa
<ObjCPropertyRefExpr
>(E
))
1862 // Black-list a few cases which yield pr-values of class type that don't
1863 // refer to temporaries of that type:
1865 // - implicit derived-to-base conversions
1866 if (isa
<ImplicitCastExpr
>(E
)) {
1867 switch (cast
<ImplicitCastExpr
>(E
)->getCastKind()) {
1868 case CK_DerivedToBase
:
1869 case CK_UncheckedDerivedToBase
:
1876 // - member expressions (all)
1877 if (isa
<MemberExpr
>(E
))
1883 /// hasAnyTypeDependentArguments - Determines if any of the expressions
1884 /// in Exprs is type-dependent.
1885 bool Expr::hasAnyTypeDependentArguments(Expr
** Exprs
, unsigned NumExprs
) {
1886 for (unsigned I
= 0; I
< NumExprs
; ++I
)
1887 if (Exprs
[I
]->isTypeDependent())
1893 /// hasAnyValueDependentArguments - Determines if any of the expressions
1894 /// in Exprs is value-dependent.
1895 bool Expr::hasAnyValueDependentArguments(Expr
** Exprs
, unsigned NumExprs
) {
1896 for (unsigned I
= 0; I
< NumExprs
; ++I
)
1897 if (Exprs
[I
]->isValueDependent())
1903 bool Expr::isConstantInitializer(ASTContext
&Ctx
, bool IsForRef
) const {
1904 // This function is attempting whether an expression is an initializer
1905 // which can be evaluated at compile-time. isEvaluatable handles most
1906 // of the cases, but it can't deal with some initializer-specific
1907 // expressions, and it can't deal with aggregates; we deal with those here,
1908 // and fall back to isEvaluatable for the other cases.
1910 // If we ever capture reference-binding directly in the AST, we can
1911 // kill the second parameter.
1915 return EvaluateAsLValue(Result
, Ctx
) && !Result
.HasSideEffects
;
1918 switch (getStmtClass()) {
1920 case StringLiteralClass
:
1921 case ObjCStringLiteralClass
:
1922 case ObjCEncodeExprClass
:
1924 case CXXTemporaryObjectExprClass
:
1925 case CXXConstructExprClass
: {
1926 const CXXConstructExpr
*CE
= cast
<CXXConstructExpr
>(this);
1929 // 1) an application of the trivial default constructor or
1930 if (!CE
->getConstructor()->isTrivial()) return false;
1931 if (!CE
->getNumArgs()) return true;
1933 // 2) an elidable trivial copy construction of an operand which is
1934 // itself a constant initializer. Note that we consider the
1935 // operand on its own, *not* as a reference binding.
1936 return CE
->isElidable() &&
1937 CE
->getArg(0)->isConstantInitializer(Ctx
, false);
1939 case CompoundLiteralExprClass
: {
1940 // This handles gcc's extension that allows global initializers like
1941 // "struct x {int x;} x = (struct x) {};".
1942 // FIXME: This accepts other cases it shouldn't!
1943 const Expr
*Exp
= cast
<CompoundLiteralExpr
>(this)->getInitializer();
1944 return Exp
->isConstantInitializer(Ctx
, false);
1946 case InitListExprClass
: {
1947 // FIXME: This doesn't deal with fields with reference types correctly.
1948 // FIXME: This incorrectly allows pointers cast to integers to be assigned
1950 const InitListExpr
*Exp
= cast
<InitListExpr
>(this);
1951 unsigned numInits
= Exp
->getNumInits();
1952 for (unsigned i
= 0; i
< numInits
; i
++) {
1953 if (!Exp
->getInit(i
)->isConstantInitializer(Ctx
, false))
1958 case ImplicitValueInitExprClass
:
1960 case ParenExprClass
:
1961 return cast
<ParenExpr
>(this)->getSubExpr()
1962 ->isConstantInitializer(Ctx
, IsForRef
);
1963 case ChooseExprClass
:
1964 return cast
<ChooseExpr
>(this)->getChosenSubExpr(Ctx
)
1965 ->isConstantInitializer(Ctx
, IsForRef
);
1966 case UnaryOperatorClass
: {
1967 const UnaryOperator
* Exp
= cast
<UnaryOperator
>(this);
1968 if (Exp
->getOpcode() == UO_Extension
)
1969 return Exp
->getSubExpr()->isConstantInitializer(Ctx
, false);
1972 case BinaryOperatorClass
: {
1973 // Special case &&foo - &&bar. It would be nice to generalize this somehow
1974 // but this handles the common case.
1975 const BinaryOperator
*Exp
= cast
<BinaryOperator
>(this);
1976 if (Exp
->getOpcode() == BO_Sub
&&
1977 isa
<AddrLabelExpr
>(Exp
->getLHS()->IgnoreParenNoopCasts(Ctx
)) &&
1978 isa
<AddrLabelExpr
>(Exp
->getRHS()->IgnoreParenNoopCasts(Ctx
)))
1982 case CXXFunctionalCastExprClass
:
1983 case CXXStaticCastExprClass
:
1984 case ImplicitCastExprClass
:
1985 case CStyleCastExprClass
:
1986 // Handle casts with a destination that's a struct or union; this
1987 // deals with both the gcc no-op struct cast extension and the
1988 // cast-to-union extension.
1989 if (getType()->isRecordType())
1990 return cast
<CastExpr
>(this)->getSubExpr()
1991 ->isConstantInitializer(Ctx
, false);
1993 // Integer->integer casts can be handled here, which is important for
1994 // things like (int)(&&x-&&y). Scary but true.
1995 if (getType()->isIntegerType() &&
1996 cast
<CastExpr
>(this)->getSubExpr()->getType()->isIntegerType())
1997 return cast
<CastExpr
>(this)->getSubExpr()
1998 ->isConstantInitializer(Ctx
, false);
2002 return isEvaluatable(Ctx
);
2005 /// isNullPointerConstant - C99 6.3.2.3p3 - Return true if this is either an
2006 /// integer constant expression with the value zero, or if this is one that is
2008 bool Expr::isNullPointerConstant(ASTContext
&Ctx
,
2009 NullPointerConstantValueDependence NPC
) const {
2010 if (isValueDependent()) {
2012 case NPC_NeverValueDependent
:
2013 assert(false && "Unexpected value dependent expression!");
2014 // If the unthinkable happens, fall through to the safest alternative.
2016 case NPC_ValueDependentIsNull
:
2017 return isTypeDependent() || getType()->isIntegralType(Ctx
);
2019 case NPC_ValueDependentIsNotNull
:
2024 // Strip off a cast to void*, if it exists. Except in C++.
2025 if (const ExplicitCastExpr
*CE
= dyn_cast
<ExplicitCastExpr
>(this)) {
2026 if (!Ctx
.getLangOptions().CPlusPlus
) {
2027 // Check that it is a cast to void*.
2028 if (const PointerType
*PT
= CE
->getType()->getAs
<PointerType
>()) {
2029 QualType Pointee
= PT
->getPointeeType();
2030 if (!Pointee
.hasQualifiers() &&
2031 Pointee
->isVoidType() && // to void*
2032 CE
->getSubExpr()->getType()->isIntegerType()) // from int.
2033 return CE
->getSubExpr()->isNullPointerConstant(Ctx
, NPC
);
2036 } else if (const ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(this)) {
2037 // Ignore the ImplicitCastExpr type entirely.
2038 return ICE
->getSubExpr()->isNullPointerConstant(Ctx
, NPC
);
2039 } else if (const ParenExpr
*PE
= dyn_cast
<ParenExpr
>(this)) {
2040 // Accept ((void*)0) as a null pointer constant, as many other
2041 // implementations do.
2042 return PE
->getSubExpr()->isNullPointerConstant(Ctx
, NPC
);
2043 } else if (const CXXDefaultArgExpr
*DefaultArg
2044 = dyn_cast
<CXXDefaultArgExpr
>(this)) {
2045 // See through default argument expressions
2046 return DefaultArg
->getExpr()->isNullPointerConstant(Ctx
, NPC
);
2047 } else if (isa
<GNUNullExpr
>(this)) {
2048 // The GNU __null extension is always a null pointer constant.
2052 // C++0x nullptr_t is always a null pointer constant.
2053 if (getType()->isNullPtrType())
2056 if (const RecordType
*UT
= getType()->getAsUnionType())
2057 if (UT
&& UT
->getDecl()->hasAttr
<TransparentUnionAttr
>())
2058 if (const CompoundLiteralExpr
*CLE
= dyn_cast
<CompoundLiteralExpr
>(this)){
2059 const Expr
*InitExpr
= CLE
->getInitializer();
2060 if (const InitListExpr
*ILE
= dyn_cast
<InitListExpr
>(InitExpr
))
2061 return ILE
->getInit(0)->isNullPointerConstant(Ctx
, NPC
);
2063 // This expression must be an integer type.
2064 if (!getType()->isIntegerType() ||
2065 (Ctx
.getLangOptions().CPlusPlus
&& getType()->isEnumeralType()))
2068 // If we have an integer constant expression, we need to *evaluate* it and
2069 // test for the value 0.
2070 llvm::APSInt Result
;
2071 return isIntegerConstantExpr(Result
, Ctx
) && Result
== 0;
2074 /// \brief If this expression is an l-value for an Objective C
2075 /// property, find the underlying property reference expression.
2076 const ObjCPropertyRefExpr
*Expr::getObjCProperty() const {
2077 const Expr
*E
= this;
2079 assert((E
->getValueKind() == VK_LValue
&&
2080 E
->getObjectKind() == OK_ObjCProperty
) &&
2081 "expression is not a property reference");
2082 E
= E
->IgnoreParenCasts();
2083 if (const BinaryOperator
*BO
= dyn_cast
<BinaryOperator
>(E
)) {
2084 if (BO
->getOpcode() == BO_Comma
) {
2093 return cast
<ObjCPropertyRefExpr
>(E
);
2096 FieldDecl
*Expr::getBitField() {
2097 Expr
*E
= this->IgnoreParens();
2099 while (ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(E
)) {
2100 if (ICE
->getCastKind() == CK_LValueToRValue
||
2101 (ICE
->getValueKind() != VK_RValue
&& ICE
->getCastKind() == CK_NoOp
))
2102 E
= ICE
->getSubExpr()->IgnoreParens();
2107 if (MemberExpr
*MemRef
= dyn_cast
<MemberExpr
>(E
))
2108 if (FieldDecl
*Field
= dyn_cast
<FieldDecl
>(MemRef
->getMemberDecl()))
2109 if (Field
->isBitField())
2112 if (DeclRefExpr
*DeclRef
= dyn_cast
<DeclRefExpr
>(E
))
2113 if (FieldDecl
*Field
= dyn_cast
<FieldDecl
>(DeclRef
->getDecl()))
2114 if (Field
->isBitField())
2117 if (BinaryOperator
*BinOp
= dyn_cast
<BinaryOperator
>(E
))
2118 if (BinOp
->isAssignmentOp() && BinOp
->getLHS())
2119 return BinOp
->getLHS()->getBitField();
2124 bool Expr::refersToVectorElement() const {
2125 const Expr
*E
= this->IgnoreParens();
2127 while (const ImplicitCastExpr
*ICE
= dyn_cast
<ImplicitCastExpr
>(E
)) {
2128 if (ICE
->getValueKind() != VK_RValue
&&
2129 ICE
->getCastKind() == CK_NoOp
)
2130 E
= ICE
->getSubExpr()->IgnoreParens();
2135 if (const ArraySubscriptExpr
*ASE
= dyn_cast
<ArraySubscriptExpr
>(E
))
2136 return ASE
->getBase()->getType()->isVectorType();
2138 if (isa
<ExtVectorElementExpr
>(E
))
2144 /// isArrow - Return true if the base expression is a pointer to vector,
2145 /// return false if the base expression is a vector.
2146 bool ExtVectorElementExpr::isArrow() const {
2147 return getBase()->getType()->isPointerType();
2150 unsigned ExtVectorElementExpr::getNumElements() const {
2151 if (const VectorType
*VT
= getType()->getAs
<VectorType
>())
2152 return VT
->getNumElements();
2156 /// containsDuplicateElements - Return true if any element access is repeated.
2157 bool ExtVectorElementExpr::containsDuplicateElements() const {
2158 // FIXME: Refactor this code to an accessor on the AST node which returns the
2159 // "type" of component access, and share with code below and in Sema.
2160 llvm::StringRef Comp
= Accessor
->getName();
2162 // Halving swizzles do not contain duplicate elements.
2163 if (Comp
== "hi" || Comp
== "lo" || Comp
== "even" || Comp
== "odd")
2166 // Advance past s-char prefix on hex swizzles.
2167 if (Comp
[0] == 's' || Comp
[0] == 'S')
2168 Comp
= Comp
.substr(1);
2170 for (unsigned i
= 0, e
= Comp
.size(); i
!= e
; ++i
)
2171 if (Comp
.substr(i
+ 1).find(Comp
[i
]) != llvm::StringRef::npos
)
2177 /// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
2178 void ExtVectorElementExpr::getEncodedElementAccess(
2179 llvm::SmallVectorImpl
<unsigned> &Elts
) const {
2180 llvm::StringRef Comp
= Accessor
->getName();
2181 if (Comp
[0] == 's' || Comp
[0] == 'S')
2182 Comp
= Comp
.substr(1);
2184 bool isHi
= Comp
== "hi";
2185 bool isLo
= Comp
== "lo";
2186 bool isEven
= Comp
== "even";
2187 bool isOdd
= Comp
== "odd";
2189 for (unsigned i
= 0, e
= getNumElements(); i
!= e
; ++i
) {
2201 Index
= ExtVectorType::getAccessorIdx(Comp
[i
]);
2203 Elts
.push_back(Index
);
2207 ObjCMessageExpr::ObjCMessageExpr(QualType T
,
2209 SourceLocation LBracLoc
,
2210 SourceLocation SuperLoc
,
2211 bool IsInstanceSuper
,
2214 SourceLocation SelLoc
,
2215 ObjCMethodDecl
*Method
,
2216 Expr
**Args
, unsigned NumArgs
,
2217 SourceLocation RBracLoc
)
2218 : Expr(ObjCMessageExprClass
, T
, VK
, OK_Ordinary
,
2219 /*TypeDependent=*/false, /*ValueDependent=*/false),
2220 NumArgs(NumArgs
), Kind(IsInstanceSuper
? SuperInstance
: SuperClass
),
2221 HasMethod(Method
!= 0), SuperLoc(SuperLoc
),
2222 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method
? Method
2223 : Sel
.getAsOpaquePtr())),
2224 SelectorLoc(SelLoc
), LBracLoc(LBracLoc
), RBracLoc(RBracLoc
)
2226 setReceiverPointer(SuperType
.getAsOpaquePtr());
2228 memcpy(getArgs(), Args
, NumArgs
* sizeof(Expr
*));
2231 ObjCMessageExpr::ObjCMessageExpr(QualType T
,
2233 SourceLocation LBracLoc
,
2234 TypeSourceInfo
*Receiver
,
2236 SourceLocation SelLoc
,
2237 ObjCMethodDecl
*Method
,
2238 Expr
**Args
, unsigned NumArgs
,
2239 SourceLocation RBracLoc
)
2240 : Expr(ObjCMessageExprClass
, T
, VK
, OK_Ordinary
, T
->isDependentType(),
2241 (T
->isDependentType() ||
2242 hasAnyValueDependentArguments(Args
, NumArgs
))),
2243 NumArgs(NumArgs
), Kind(Class
), HasMethod(Method
!= 0),
2244 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method
? Method
2245 : Sel
.getAsOpaquePtr())),
2246 SelectorLoc(SelLoc
), LBracLoc(LBracLoc
), RBracLoc(RBracLoc
)
2248 setReceiverPointer(Receiver
);
2250 memcpy(getArgs(), Args
, NumArgs
* sizeof(Expr
*));
2253 ObjCMessageExpr::ObjCMessageExpr(QualType T
,
2255 SourceLocation LBracLoc
,
2258 SourceLocation SelLoc
,
2259 ObjCMethodDecl
*Method
,
2260 Expr
**Args
, unsigned NumArgs
,
2261 SourceLocation RBracLoc
)
2262 : Expr(ObjCMessageExprClass
, T
, VK
, OK_Ordinary
, Receiver
->isTypeDependent(),
2263 (Receiver
->isTypeDependent() ||
2264 hasAnyValueDependentArguments(Args
, NumArgs
))),
2265 NumArgs(NumArgs
), Kind(Instance
), HasMethod(Method
!= 0),
2266 SelectorOrMethod(reinterpret_cast<uintptr_t>(Method
? Method
2267 : Sel
.getAsOpaquePtr())),
2268 SelectorLoc(SelLoc
), LBracLoc(LBracLoc
), RBracLoc(RBracLoc
)
2270 setReceiverPointer(Receiver
);
2272 memcpy(getArgs(), Args
, NumArgs
* sizeof(Expr
*));
2275 ObjCMessageExpr
*ObjCMessageExpr::Create(ASTContext
&Context
, QualType T
,
2277 SourceLocation LBracLoc
,
2278 SourceLocation SuperLoc
,
2279 bool IsInstanceSuper
,
2282 SourceLocation SelLoc
,
2283 ObjCMethodDecl
*Method
,
2284 Expr
**Args
, unsigned NumArgs
,
2285 SourceLocation RBracLoc
) {
2286 unsigned Size
= sizeof(ObjCMessageExpr
) + sizeof(void *) +
2287 NumArgs
* sizeof(Expr
*);
2288 void *Mem
= Context
.Allocate(Size
, llvm::AlignOf
<ObjCMessageExpr
>::Alignment
);
2289 return new (Mem
) ObjCMessageExpr(T
, VK
, LBracLoc
, SuperLoc
, IsInstanceSuper
,
2290 SuperType
, Sel
, SelLoc
, Method
, Args
,NumArgs
,
2294 ObjCMessageExpr
*ObjCMessageExpr::Create(ASTContext
&Context
, QualType T
,
2296 SourceLocation LBracLoc
,
2297 TypeSourceInfo
*Receiver
,
2299 SourceLocation SelLoc
,
2300 ObjCMethodDecl
*Method
,
2301 Expr
**Args
, unsigned NumArgs
,
2302 SourceLocation RBracLoc
) {
2303 unsigned Size
= sizeof(ObjCMessageExpr
) + sizeof(void *) +
2304 NumArgs
* sizeof(Expr
*);
2305 void *Mem
= Context
.Allocate(Size
, llvm::AlignOf
<ObjCMessageExpr
>::Alignment
);
2306 return new (Mem
) ObjCMessageExpr(T
, VK
, LBracLoc
, Receiver
, Sel
, SelLoc
,
2307 Method
, Args
, NumArgs
, RBracLoc
);
2310 ObjCMessageExpr
*ObjCMessageExpr::Create(ASTContext
&Context
, QualType T
,
2312 SourceLocation LBracLoc
,
2315 SourceLocation SelLoc
,
2316 ObjCMethodDecl
*Method
,
2317 Expr
**Args
, unsigned NumArgs
,
2318 SourceLocation RBracLoc
) {
2319 unsigned Size
= sizeof(ObjCMessageExpr
) + sizeof(void *) +
2320 NumArgs
* sizeof(Expr
*);
2321 void *Mem
= Context
.Allocate(Size
, llvm::AlignOf
<ObjCMessageExpr
>::Alignment
);
2322 return new (Mem
) ObjCMessageExpr(T
, VK
, LBracLoc
, Receiver
, Sel
, SelLoc
,
2323 Method
, Args
, NumArgs
, RBracLoc
);
2326 ObjCMessageExpr
*ObjCMessageExpr::CreateEmpty(ASTContext
&Context
,
2328 unsigned Size
= sizeof(ObjCMessageExpr
) + sizeof(void *) +
2329 NumArgs
* sizeof(Expr
*);
2330 void *Mem
= Context
.Allocate(Size
, llvm::AlignOf
<ObjCMessageExpr
>::Alignment
);
2331 return new (Mem
) ObjCMessageExpr(EmptyShell(), NumArgs
);
2334 Selector
ObjCMessageExpr::getSelector() const {
2336 return reinterpret_cast<const ObjCMethodDecl
*>(SelectorOrMethod
)
2338 return Selector(SelectorOrMethod
);
2341 ObjCInterfaceDecl
*ObjCMessageExpr::getReceiverInterface() const {
2342 switch (getReceiverKind()) {
2344 if (const ObjCObjectPointerType
*Ptr
2345 = getInstanceReceiver()->getType()->getAs
<ObjCObjectPointerType
>())
2346 return Ptr
->getInterfaceDecl();
2350 if (const ObjCObjectType
*Ty
2351 = getClassReceiver()->getAs
<ObjCObjectType
>())
2352 return Ty
->getInterface();
2356 if (const ObjCObjectPointerType
*Ptr
2357 = getSuperType()->getAs
<ObjCObjectPointerType
>())
2358 return Ptr
->getInterfaceDecl();
2362 if (const ObjCObjectPointerType
*Iface
2363 = getSuperType()->getAs
<ObjCObjectPointerType
>())
2364 return Iface
->getInterfaceDecl();
2371 bool ChooseExpr::isConditionTrue(ASTContext
&C
) const {
2372 return getCond()->EvaluateAsInt(C
) != 0;
2375 void ShuffleVectorExpr::setExprs(ASTContext
&C
, Expr
** Exprs
,
2376 unsigned NumExprs
) {
2377 if (SubExprs
) C
.Deallocate(SubExprs
);
2379 SubExprs
= new (C
) Stmt
* [NumExprs
];
2380 this->NumExprs
= NumExprs
;
2381 memcpy(SubExprs
, Exprs
, sizeof(Expr
*) * NumExprs
);
2384 //===----------------------------------------------------------------------===//
2385 // DesignatedInitExpr
2386 //===----------------------------------------------------------------------===//
2388 IdentifierInfo
*DesignatedInitExpr::Designator::getFieldName() {
2389 assert(Kind
== FieldDesignator
&& "Only valid on a field designator");
2390 if (Field
.NameOrField
& 0x01)
2391 return reinterpret_cast<IdentifierInfo
*>(Field
.NameOrField
&~0x01);
2393 return getField()->getIdentifier();
2396 DesignatedInitExpr::DesignatedInitExpr(ASTContext
&C
, QualType Ty
,
2397 unsigned NumDesignators
,
2398 const Designator
*Designators
,
2399 SourceLocation EqualOrColonLoc
,
2402 unsigned NumIndexExprs
,
2404 : Expr(DesignatedInitExprClass
, Ty
,
2405 Init
->getValueKind(), Init
->getObjectKind(),
2406 Init
->isTypeDependent(), Init
->isValueDependent()),
2407 EqualOrColonLoc(EqualOrColonLoc
), GNUSyntax(GNUSyntax
),
2408 NumDesignators(NumDesignators
), NumSubExprs(NumIndexExprs
+ 1) {
2409 this->Designators
= new (C
) Designator
[NumDesignators
];
2411 // Record the initializer itself.
2412 child_iterator Child
= child_begin();
2415 // Copy the designators and their subexpressions, computing
2416 // value-dependence along the way.
2417 unsigned IndexIdx
= 0;
2418 for (unsigned I
= 0; I
!= NumDesignators
; ++I
) {
2419 this->Designators
[I
] = Designators
[I
];
2421 if (this->Designators
[I
].isArrayDesignator()) {
2422 // Compute type- and value-dependence.
2423 Expr
*Index
= IndexExprs
[IndexIdx
];
2424 ExprBits
.ValueDependent
= ExprBits
.ValueDependent
||
2425 Index
->isTypeDependent() || Index
->isValueDependent();
2427 // Copy the index expressions into permanent storage.
2428 *Child
++ = IndexExprs
[IndexIdx
++];
2429 } else if (this->Designators
[I
].isArrayRangeDesignator()) {
2430 // Compute type- and value-dependence.
2431 Expr
*Start
= IndexExprs
[IndexIdx
];
2432 Expr
*End
= IndexExprs
[IndexIdx
+ 1];
2433 ExprBits
.ValueDependent
= ExprBits
.ValueDependent
||
2434 Start
->isTypeDependent() || Start
->isValueDependent() ||
2435 End
->isTypeDependent() || End
->isValueDependent();
2437 // Copy the start/end expressions into permanent storage.
2438 *Child
++ = IndexExprs
[IndexIdx
++];
2439 *Child
++ = IndexExprs
[IndexIdx
++];
2443 assert(IndexIdx
== NumIndexExprs
&& "Wrong number of index expressions");
2446 DesignatedInitExpr
*
2447 DesignatedInitExpr::Create(ASTContext
&C
, Designator
*Designators
,
2448 unsigned NumDesignators
,
2449 Expr
**IndexExprs
, unsigned NumIndexExprs
,
2450 SourceLocation ColonOrEqualLoc
,
2451 bool UsesColonSyntax
, Expr
*Init
) {
2452 void *Mem
= C
.Allocate(sizeof(DesignatedInitExpr
) +
2453 sizeof(Stmt
*) * (NumIndexExprs
+ 1), 8);
2454 return new (Mem
) DesignatedInitExpr(C
, C
.VoidTy
, NumDesignators
, Designators
,
2455 ColonOrEqualLoc
, UsesColonSyntax
,
2456 IndexExprs
, NumIndexExprs
, Init
);
2459 DesignatedInitExpr
*DesignatedInitExpr::CreateEmpty(ASTContext
&C
,
2460 unsigned NumIndexExprs
) {
2461 void *Mem
= C
.Allocate(sizeof(DesignatedInitExpr
) +
2462 sizeof(Stmt
*) * (NumIndexExprs
+ 1), 8);
2463 return new (Mem
) DesignatedInitExpr(NumIndexExprs
+ 1);
2466 void DesignatedInitExpr::setDesignators(ASTContext
&C
,
2467 const Designator
*Desigs
,
2468 unsigned NumDesigs
) {
2469 Designators
= new (C
) Designator
[NumDesigs
];
2470 NumDesignators
= NumDesigs
;
2471 for (unsigned I
= 0; I
!= NumDesigs
; ++I
)
2472 Designators
[I
] = Desigs
[I
];
2475 SourceRange
DesignatedInitExpr::getSourceRange() const {
2476 SourceLocation StartLoc
;
2478 *const_cast<DesignatedInitExpr
*>(this)->designators_begin();
2479 if (First
.isFieldDesignator()) {
2481 StartLoc
= SourceLocation::getFromRawEncoding(First
.Field
.FieldLoc
);
2483 StartLoc
= SourceLocation::getFromRawEncoding(First
.Field
.DotLoc
);
2486 SourceLocation::getFromRawEncoding(First
.ArrayOrRange
.LBracketLoc
);
2487 return SourceRange(StartLoc
, getInit()->getSourceRange().getEnd());
2490 Expr
*DesignatedInitExpr::getArrayIndex(const Designator
& D
) {
2491 assert(D
.Kind
== Designator::ArrayDesignator
&& "Requires array designator");
2492 char* Ptr
= static_cast<char*>(static_cast<void *>(this));
2493 Ptr
+= sizeof(DesignatedInitExpr
);
2494 Stmt
**SubExprs
= reinterpret_cast<Stmt
**>(reinterpret_cast<void**>(Ptr
));
2495 return cast
<Expr
>(*(SubExprs
+ D
.ArrayOrRange
.Index
+ 1));
2498 Expr
*DesignatedInitExpr::getArrayRangeStart(const Designator
& D
) {
2499 assert(D
.Kind
== Designator::ArrayRangeDesignator
&&
2500 "Requires array range designator");
2501 char* Ptr
= static_cast<char*>(static_cast<void *>(this));
2502 Ptr
+= sizeof(DesignatedInitExpr
);
2503 Stmt
**SubExprs
= reinterpret_cast<Stmt
**>(reinterpret_cast<void**>(Ptr
));
2504 return cast
<Expr
>(*(SubExprs
+ D
.ArrayOrRange
.Index
+ 1));
2507 Expr
*DesignatedInitExpr::getArrayRangeEnd(const Designator
& D
) {
2508 assert(D
.Kind
== Designator::ArrayRangeDesignator
&&
2509 "Requires array range designator");
2510 char* Ptr
= static_cast<char*>(static_cast<void *>(this));
2511 Ptr
+= sizeof(DesignatedInitExpr
);
2512 Stmt
**SubExprs
= reinterpret_cast<Stmt
**>(reinterpret_cast<void**>(Ptr
));
2513 return cast
<Expr
>(*(SubExprs
+ D
.ArrayOrRange
.Index
+ 2));
2516 /// \brief Replaces the designator at index @p Idx with the series
2517 /// of designators in [First, Last).
2518 void DesignatedInitExpr::ExpandDesignator(ASTContext
&C
, unsigned Idx
,
2519 const Designator
*First
,
2520 const Designator
*Last
) {
2521 unsigned NumNewDesignators
= Last
- First
;
2522 if (NumNewDesignators
== 0) {
2523 std::copy_backward(Designators
+ Idx
+ 1,
2524 Designators
+ NumDesignators
,
2526 --NumNewDesignators
;
2528 } else if (NumNewDesignators
== 1) {
2529 Designators
[Idx
] = *First
;
2533 Designator
*NewDesignators
2534 = new (C
) Designator
[NumDesignators
- 1 + NumNewDesignators
];
2535 std::copy(Designators
, Designators
+ Idx
, NewDesignators
);
2536 std::copy(First
, Last
, NewDesignators
+ Idx
);
2537 std::copy(Designators
+ Idx
+ 1, Designators
+ NumDesignators
,
2538 NewDesignators
+ Idx
+ NumNewDesignators
);
2539 Designators
= NewDesignators
;
2540 NumDesignators
= NumDesignators
- 1 + NumNewDesignators
;
2543 ParenListExpr::ParenListExpr(ASTContext
& C
, SourceLocation lparenloc
,
2544 Expr
**exprs
, unsigned nexprs
,
2545 SourceLocation rparenloc
)
2546 : Expr(ParenListExprClass
, QualType(), VK_RValue
, OK_Ordinary
,
2547 hasAnyTypeDependentArguments(exprs
, nexprs
),
2548 hasAnyValueDependentArguments(exprs
, nexprs
)),
2549 NumExprs(nexprs
), LParenLoc(lparenloc
), RParenLoc(rparenloc
) {
2551 Exprs
= new (C
) Stmt
*[nexprs
];
2552 for (unsigned i
= 0; i
!= nexprs
; ++i
)
2553 Exprs
[i
] = exprs
[i
];
2556 //===----------------------------------------------------------------------===//
2558 //===----------------------------------------------------------------------===//
2560 Expr
* ExprIterator::operator[](size_t idx
) { return cast
<Expr
>(I
[idx
]); }
2561 Expr
* ExprIterator::operator*() const { return cast
<Expr
>(*I
); }
2562 Expr
* ExprIterator::operator->() const { return cast
<Expr
>(*I
); }
2563 const Expr
* ConstExprIterator::operator[](size_t idx
) const {
2564 return cast
<Expr
>(I
[idx
]);
2566 const Expr
* ConstExprIterator::operator*() const { return cast
<Expr
>(*I
); }
2567 const Expr
* ConstExprIterator::operator->() const { return cast
<Expr
>(*I
); }
2569 //===----------------------------------------------------------------------===//
2570 // Child Iterators for iterating over subexpressions/substatements
2571 //===----------------------------------------------------------------------===//
2574 Stmt::child_iterator
DeclRefExpr::child_begin() { return child_iterator(); }
2575 Stmt::child_iterator
DeclRefExpr::child_end() { return child_iterator(); }
2578 Stmt::child_iterator
ObjCIvarRefExpr::child_begin() { return &Base
; }
2579 Stmt::child_iterator
ObjCIvarRefExpr::child_end() { return &Base
+1; }
2581 // ObjCPropertyRefExpr
2582 Stmt::child_iterator
ObjCPropertyRefExpr::child_begin()
2584 if (Receiver
.is
<Stmt
*>()) {
2586 return reinterpret_cast<Stmt
**> (&Receiver
);
2588 return child_iterator();
2591 Stmt::child_iterator
ObjCPropertyRefExpr::child_end()
2592 { return Receiver
.is
<Stmt
*>() ?
2593 reinterpret_cast<Stmt
**> (&Receiver
)+1 :
2598 Stmt::child_iterator
ObjCIsaExpr::child_begin() { return &Base
; }
2599 Stmt::child_iterator
ObjCIsaExpr::child_end() { return &Base
+1; }
2602 Stmt::child_iterator
PredefinedExpr::child_begin() { return child_iterator(); }
2603 Stmt::child_iterator
PredefinedExpr::child_end() { return child_iterator(); }
2606 Stmt::child_iterator
IntegerLiteral::child_begin() { return child_iterator(); }
2607 Stmt::child_iterator
IntegerLiteral::child_end() { return child_iterator(); }
2610 Stmt::child_iterator
CharacterLiteral::child_begin() { return child_iterator();}
2611 Stmt::child_iterator
CharacterLiteral::child_end() { return child_iterator(); }
2614 Stmt::child_iterator
FloatingLiteral::child_begin() { return child_iterator(); }
2615 Stmt::child_iterator
FloatingLiteral::child_end() { return child_iterator(); }
2618 Stmt::child_iterator
ImaginaryLiteral::child_begin() { return &Val
; }
2619 Stmt::child_iterator
ImaginaryLiteral::child_end() { return &Val
+1; }
2622 Stmt::child_iterator
StringLiteral::child_begin() { return child_iterator(); }
2623 Stmt::child_iterator
StringLiteral::child_end() { return child_iterator(); }
2626 Stmt::child_iterator
ParenExpr::child_begin() { return &Val
; }
2627 Stmt::child_iterator
ParenExpr::child_end() { return &Val
+1; }
2630 Stmt::child_iterator
UnaryOperator::child_begin() { return &Val
; }
2631 Stmt::child_iterator
UnaryOperator::child_end() { return &Val
+1; }
2634 Stmt::child_iterator
OffsetOfExpr::child_begin() {
2635 return reinterpret_cast<Stmt
**> (reinterpret_cast<OffsetOfNode
*> (this + 1)
2638 Stmt::child_iterator
OffsetOfExpr::child_end() {
2639 return child_iterator(&*child_begin() + NumExprs
);
2642 // SizeOfAlignOfExpr
2643 Stmt::child_iterator
SizeOfAlignOfExpr::child_begin() {
2644 // If this is of a type and the type is a VLA type (and not a typedef), the
2645 // size expression of the VLA needs to be treated as an executable expression.
2646 // Why isn't this weirdness documented better in StmtIterator?
2647 if (isArgumentType()) {
2648 if (VariableArrayType
* T
= dyn_cast
<VariableArrayType
>(
2649 getArgumentType().getTypePtr()))
2650 return child_iterator(T
);
2651 return child_iterator();
2653 return child_iterator(&Argument
.Ex
);
2655 Stmt::child_iterator
SizeOfAlignOfExpr::child_end() {
2656 if (isArgumentType())
2657 return child_iterator();
2658 return child_iterator(&Argument
.Ex
+ 1);
2661 // ArraySubscriptExpr
2662 Stmt::child_iterator
ArraySubscriptExpr::child_begin() {
2663 return &SubExprs
[0];
2665 Stmt::child_iterator
ArraySubscriptExpr::child_end() {
2666 return &SubExprs
[0]+END_EXPR
;
2670 Stmt::child_iterator
CallExpr::child_begin() {
2671 return &SubExprs
[0];
2673 Stmt::child_iterator
CallExpr::child_end() {
2674 return &SubExprs
[0]+NumArgs
+ARGS_START
;
2678 Stmt::child_iterator
MemberExpr::child_begin() { return &Base
; }
2679 Stmt::child_iterator
MemberExpr::child_end() { return &Base
+1; }
2681 // ExtVectorElementExpr
2682 Stmt::child_iterator
ExtVectorElementExpr::child_begin() { return &Base
; }
2683 Stmt::child_iterator
ExtVectorElementExpr::child_end() { return &Base
+1; }
2685 // CompoundLiteralExpr
2686 Stmt::child_iterator
CompoundLiteralExpr::child_begin() { return &Init
; }
2687 Stmt::child_iterator
CompoundLiteralExpr::child_end() { return &Init
+1; }
2690 Stmt::child_iterator
CastExpr::child_begin() { return &Op
; }
2691 Stmt::child_iterator
CastExpr::child_end() { return &Op
+1; }
2694 Stmt::child_iterator
BinaryOperator::child_begin() {
2695 return &SubExprs
[0];
2697 Stmt::child_iterator
BinaryOperator::child_end() {
2698 return &SubExprs
[0]+END_EXPR
;
2701 // ConditionalOperator
2702 Stmt::child_iterator
ConditionalOperator::child_begin() {
2703 return &SubExprs
[0];
2705 Stmt::child_iterator
ConditionalOperator::child_end() {
2706 return &SubExprs
[0]+END_EXPR
;
2710 Stmt::child_iterator
AddrLabelExpr::child_begin() { return child_iterator(); }
2711 Stmt::child_iterator
AddrLabelExpr::child_end() { return child_iterator(); }
2714 Stmt::child_iterator
StmtExpr::child_begin() { return &SubStmt
; }
2715 Stmt::child_iterator
StmtExpr::child_end() { return &SubStmt
+1; }
2719 Stmt::child_iterator
ChooseExpr::child_begin() { return &SubExprs
[0]; }
2720 Stmt::child_iterator
ChooseExpr::child_end() { return &SubExprs
[0]+END_EXPR
; }
2723 Stmt::child_iterator
GNUNullExpr::child_begin() { return child_iterator(); }
2724 Stmt::child_iterator
GNUNullExpr::child_end() { return child_iterator(); }
2726 // ShuffleVectorExpr
2727 Stmt::child_iterator
ShuffleVectorExpr::child_begin() {
2728 return &SubExprs
[0];
2730 Stmt::child_iterator
ShuffleVectorExpr::child_end() {
2731 return &SubExprs
[0]+NumExprs
;
2735 Stmt::child_iterator
VAArgExpr::child_begin() { return &Val
; }
2736 Stmt::child_iterator
VAArgExpr::child_end() { return &Val
+1; }
2739 Stmt::child_iterator
InitListExpr::child_begin() {
2740 return InitExprs
.size() ? &InitExprs
[0] : 0;
2742 Stmt::child_iterator
InitListExpr::child_end() {
2743 return InitExprs
.size() ? &InitExprs
[0] + InitExprs
.size() : 0;
2746 // DesignatedInitExpr
2747 Stmt::child_iterator
DesignatedInitExpr::child_begin() {
2748 char* Ptr
= static_cast<char*>(static_cast<void *>(this));
2749 Ptr
+= sizeof(DesignatedInitExpr
);
2750 return reinterpret_cast<Stmt
**>(reinterpret_cast<void**>(Ptr
));
2752 Stmt::child_iterator
DesignatedInitExpr::child_end() {
2753 return child_iterator(&*child_begin() + NumSubExprs
);
2756 // ImplicitValueInitExpr
2757 Stmt::child_iterator
ImplicitValueInitExpr::child_begin() {
2758 return child_iterator();
2761 Stmt::child_iterator
ImplicitValueInitExpr::child_end() {
2762 return child_iterator();
2766 Stmt::child_iterator
ParenListExpr::child_begin() {
2769 Stmt::child_iterator
ParenListExpr::child_end() {
2770 return &Exprs
[0]+NumExprs
;
2773 // ObjCStringLiteral
2774 Stmt::child_iterator
ObjCStringLiteral::child_begin() {
2777 Stmt::child_iterator
ObjCStringLiteral::child_end() {
2782 Stmt::child_iterator
ObjCEncodeExpr::child_begin() { return child_iterator(); }
2783 Stmt::child_iterator
ObjCEncodeExpr::child_end() { return child_iterator(); }
2786 Stmt::child_iterator
ObjCSelectorExpr::child_begin() {
2787 return child_iterator();
2789 Stmt::child_iterator
ObjCSelectorExpr::child_end() {
2790 return child_iterator();
2794 Stmt::child_iterator
ObjCProtocolExpr::child_begin() {
2795 return child_iterator();
2797 Stmt::child_iterator
ObjCProtocolExpr::child_end() {
2798 return child_iterator();
2802 Stmt::child_iterator
ObjCMessageExpr::child_begin() {
2803 if (getReceiverKind() == Instance
)
2804 return reinterpret_cast<Stmt
**>(this + 1);
2807 Stmt::child_iterator
ObjCMessageExpr::child_end() {
2808 return getArgs() + getNumArgs();
2812 Stmt::child_iterator
BlockExpr::child_begin() { return child_iterator(); }
2813 Stmt::child_iterator
BlockExpr::child_end() { return child_iterator(); }
2815 Stmt::child_iterator
BlockDeclRefExpr::child_begin() { return child_iterator();}
2816 Stmt::child_iterator
BlockDeclRefExpr::child_end() { return child_iterator(); }
2819 SourceRange
OpaqueValueExpr::getSourceRange() const { return SourceRange(); }
2820 Stmt::child_iterator
OpaqueValueExpr::child_begin() { return child_iterator(); }
2821 Stmt::child_iterator
OpaqueValueExpr::child_end() { return child_iterator(); }