clang  3.9.0
Expr.cpp
Go to the documentation of this file.
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/APValue.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclTemplate.h"
21 #include "clang/AST/Expr.h"
22 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/Mangle.h"
24 #include "clang/AST/RecordLayout.h"
25 #include "clang/AST/StmtVisitor.h"
26 #include "clang/Basic/Builtins.h"
27 #include "clang/Basic/CharInfo.h"
29 #include "clang/Basic/TargetInfo.h"
30 #include "clang/Lex/Lexer.h"
33 #include "llvm/Support/ErrorHandling.h"
34 #include "llvm/Support/raw_ostream.h"
35 #include <algorithm>
36 #include <cstring>
37 using namespace clang;
38 
40  const Expr *E = ignoreParenBaseCasts();
41 
42  QualType DerivedType = E->getType();
43  if (const PointerType *PTy = DerivedType->getAs<PointerType>())
44  DerivedType = PTy->getPointeeType();
45 
46  if (DerivedType->isDependentType())
47  return nullptr;
48 
49  const RecordType *Ty = DerivedType->castAs<RecordType>();
50  Decl *D = Ty->getDecl();
51  return cast<CXXRecordDecl>(D);
52 }
53 
56  SmallVectorImpl<SubobjectAdjustment> &Adjustments) const {
57  const Expr *E = this;
58  while (true) {
59  E = E->IgnoreParens();
60 
61  if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
62  if ((CE->getCastKind() == CK_DerivedToBase ||
63  CE->getCastKind() == CK_UncheckedDerivedToBase) &&
64  E->getType()->isRecordType()) {
65  E = CE->getSubExpr();
66  CXXRecordDecl *Derived
67  = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
68  Adjustments.push_back(SubobjectAdjustment(CE, Derived));
69  continue;
70  }
71 
72  if (CE->getCastKind() == CK_NoOp) {
73  E = CE->getSubExpr();
74  continue;
75  }
76  } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
77  if (!ME->isArrow()) {
78  assert(ME->getBase()->getType()->isRecordType());
79  if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
80  if (!Field->isBitField() && !Field->getType()->isReferenceType()) {
81  E = ME->getBase();
82  Adjustments.push_back(SubobjectAdjustment(Field));
83  continue;
84  }
85  }
86  }
87  } else if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
88  if (BO->isPtrMemOp()) {
89  assert(BO->getRHS()->isRValue());
90  E = BO->getLHS();
91  const MemberPointerType *MPT =
92  BO->getRHS()->getType()->getAs<MemberPointerType>();
93  Adjustments.push_back(SubobjectAdjustment(MPT, BO->getRHS()));
94  continue;
95  } else if (BO->getOpcode() == BO_Comma) {
96  CommaLHSs.push_back(BO->getLHS());
97  E = BO->getRHS();
98  continue;
99  }
100  }
101 
102  // Nothing changed.
103  break;
104  }
105  return E;
106 }
107 
108 /// isKnownToHaveBooleanValue - Return true if this is an integer expression
109 /// that is known to return 0 or 1. This happens for _Bool/bool expressions
110 /// but also int expressions which are produced by things like comparisons in
111 /// C.
113  const Expr *E = IgnoreParens();
114 
115  // If this value has _Bool type, it is obvious 0/1.
116  if (E->getType()->isBooleanType()) return true;
117  // If this is a non-scalar-integer type, we don't care enough to try.
118  if (!E->getType()->isIntegralOrEnumerationType()) return false;
119 
120  if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
121  switch (UO->getOpcode()) {
122  case UO_Plus:
123  return UO->getSubExpr()->isKnownToHaveBooleanValue();
124  case UO_LNot:
125  return true;
126  default:
127  return false;
128  }
129  }
130 
131  // Only look through implicit casts. If the user writes
132  // '(int) (a && b)' treat it as an arbitrary int.
133  if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
134  return CE->getSubExpr()->isKnownToHaveBooleanValue();
135 
136  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
137  switch (BO->getOpcode()) {
138  default: return false;
139  case BO_LT: // Relational operators.
140  case BO_GT:
141  case BO_LE:
142  case BO_GE:
143  case BO_EQ: // Equality operators.
144  case BO_NE:
145  case BO_LAnd: // AND operator.
146  case BO_LOr: // Logical OR operator.
147  return true;
148 
149  case BO_And: // Bitwise AND operator.
150  case BO_Xor: // Bitwise XOR operator.
151  case BO_Or: // Bitwise OR operator.
152  // Handle things like (x==2)|(y==12).
153  return BO->getLHS()->isKnownToHaveBooleanValue() &&
154  BO->getRHS()->isKnownToHaveBooleanValue();
155 
156  case BO_Comma:
157  case BO_Assign:
158  return BO->getRHS()->isKnownToHaveBooleanValue();
159  }
160  }
161 
162  if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
163  return CO->getTrueExpr()->isKnownToHaveBooleanValue() &&
164  CO->getFalseExpr()->isKnownToHaveBooleanValue();
165 
166  return false;
167 }
168 
169 // Amusing macro metaprogramming hack: check whether a class provides
170 // a more specific implementation of getExprLoc().
171 //
172 // See also Stmt.cpp:{getLocStart(),getLocEnd()}.
173 namespace {
174  /// This implementation is used when a class provides a custom
175  /// implementation of getExprLoc.
176  template <class E, class T>
177  SourceLocation getExprLocImpl(const Expr *expr,
178  SourceLocation (T::*v)() const) {
179  return static_cast<const E*>(expr)->getExprLoc();
180  }
181 
182  /// This implementation is used when a class doesn't provide
183  /// a custom implementation of getExprLoc. Overload resolution
184  /// should pick it over the implementation above because it's
185  /// more specialized according to function template partial ordering.
186  template <class E>
187  SourceLocation getExprLocImpl(const Expr *expr,
188  SourceLocation (Expr::*v)() const) {
189  return static_cast<const E*>(expr)->getLocStart();
190  }
191 }
192 
194  switch (getStmtClass()) {
195  case Stmt::NoStmtClass: llvm_unreachable("statement without class");
196 #define ABSTRACT_STMT(type)
197 #define STMT(type, base) \
198  case Stmt::type##Class: break;
199 #define EXPR(type, base) \
200  case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc);
201 #include "clang/AST/StmtNodes.inc"
202  }
203  llvm_unreachable("unknown expression kind");
204 }
205 
206 //===----------------------------------------------------------------------===//
207 // Primary Expressions.
208 //===----------------------------------------------------------------------===//
209 
210 /// \brief Compute the type-, value-, and instantiation-dependence of a
211 /// declaration reference
212 /// based on the declaration being referenced.
213 static void computeDeclRefDependence(const ASTContext &Ctx, NamedDecl *D,
214  QualType T, bool &TypeDependent,
215  bool &ValueDependent,
216  bool &InstantiationDependent) {
217  TypeDependent = false;
218  ValueDependent = false;
219  InstantiationDependent = false;
220 
221  // (TD) C++ [temp.dep.expr]p3:
222  // An id-expression is type-dependent if it contains:
223  //
224  // and
225  //
226  // (VD) C++ [temp.dep.constexpr]p2:
227  // An identifier is value-dependent if it is:
228 
229  // (TD) - an identifier that was declared with dependent type
230  // (VD) - a name declared with a dependent type,
231  if (T->isDependentType()) {
232  TypeDependent = true;
233  ValueDependent = true;
234  InstantiationDependent = true;
235  return;
236  } else if (T->isInstantiationDependentType()) {
237  InstantiationDependent = true;
238  }
239 
240  // (TD) - a conversion-function-id that specifies a dependent type
241  if (D->getDeclName().getNameKind()
244  if (T->isDependentType()) {
245  TypeDependent = true;
246  ValueDependent = true;
247  InstantiationDependent = true;
248  return;
249  }
250 
252  InstantiationDependent = true;
253  }
254 
255  // (VD) - the name of a non-type template parameter,
256  if (isa<NonTypeTemplateParmDecl>(D)) {
257  ValueDependent = true;
258  InstantiationDependent = true;
259  return;
260  }
261 
262  // (VD) - a constant with integral or enumeration type and is
263  // initialized with an expression that is value-dependent.
264  // (VD) - a constant with literal type and is initialized with an
265  // expression that is value-dependent [C++11].
266  // (VD) - FIXME: Missing from the standard:
267  // - an entity with reference type and is initialized with an
268  // expression that is value-dependent [C++11]
269  if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
270  if ((Ctx.getLangOpts().CPlusPlus11 ?
271  Var->getType()->isLiteralType(Ctx) :
272  Var->getType()->isIntegralOrEnumerationType()) &&
273  (Var->getType().isConstQualified() ||
274  Var->getType()->isReferenceType())) {
275  if (const Expr *Init = Var->getAnyInitializer())
276  if (Init->isValueDependent()) {
277  ValueDependent = true;
278  InstantiationDependent = true;
279  }
280  }
281 
282  // (VD) - FIXME: Missing from the standard:
283  // - a member function or a static data member of the current
284  // instantiation
285  if (Var->isStaticDataMember() &&
286  Var->getDeclContext()->isDependentContext()) {
287  ValueDependent = true;
288  InstantiationDependent = true;
289  TypeSourceInfo *TInfo = Var->getFirstDecl()->getTypeSourceInfo();
290  if (TInfo->getType()->isIncompleteArrayType())
291  TypeDependent = true;
292  }
293 
294  return;
295  }
296 
297  // (VD) - FIXME: Missing from the standard:
298  // - a member function or a static data member of the current
299  // instantiation
300  if (isa<CXXMethodDecl>(D) && D->getDeclContext()->isDependentContext()) {
301  ValueDependent = true;
302  InstantiationDependent = true;
303  }
304 }
305 
306 void DeclRefExpr::computeDependence(const ASTContext &Ctx) {
307  bool TypeDependent = false;
308  bool ValueDependent = false;
309  bool InstantiationDependent = false;
310  computeDeclRefDependence(Ctx, getDecl(), getType(), TypeDependent,
311  ValueDependent, InstantiationDependent);
312 
313  ExprBits.TypeDependent |= TypeDependent;
314  ExprBits.ValueDependent |= ValueDependent;
315  ExprBits.InstantiationDependent |= InstantiationDependent;
316 
317  // Is the declaration a parameter pack?
318  if (getDecl()->isParameterPack())
319  ExprBits.ContainsUnexpandedParameterPack = true;
320 }
321 
322 DeclRefExpr::DeclRefExpr(const ASTContext &Ctx,
323  NestedNameSpecifierLoc QualifierLoc,
324  SourceLocation TemplateKWLoc,
325  ValueDecl *D, bool RefersToEnclosingVariableOrCapture,
326  const DeclarationNameInfo &NameInfo,
327  NamedDecl *FoundD,
328  const TemplateArgumentListInfo *TemplateArgs,
329  QualType T, ExprValueKind VK)
330  : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false),
331  D(D), Loc(NameInfo.getLoc()), DNLoc(NameInfo.getInfo()) {
332  DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0;
333  if (QualifierLoc) {
334  new (getTrailingObjects<NestedNameSpecifierLoc>())
335  NestedNameSpecifierLoc(QualifierLoc);
336  auto *NNS = QualifierLoc.getNestedNameSpecifier();
337  if (NNS->isInstantiationDependent())
338  ExprBits.InstantiationDependent = true;
339  if (NNS->containsUnexpandedParameterPack())
340  ExprBits.ContainsUnexpandedParameterPack = true;
341  }
342  DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0;
343  if (FoundD)
344  *getTrailingObjects<NamedDecl *>() = FoundD;
345  DeclRefExprBits.HasTemplateKWAndArgsInfo
346  = (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0;
347  DeclRefExprBits.RefersToEnclosingVariableOrCapture =
348  RefersToEnclosingVariableOrCapture;
349  if (TemplateArgs) {
350  bool Dependent = false;
351  bool InstantiationDependent = false;
352  bool ContainsUnexpandedParameterPack = false;
353  getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
354  TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
355  Dependent, InstantiationDependent, ContainsUnexpandedParameterPack);
356  assert(!Dependent && "built a DeclRefExpr with dependent template args");
357  ExprBits.InstantiationDependent |= InstantiationDependent;
358  ExprBits.ContainsUnexpandedParameterPack |= ContainsUnexpandedParameterPack;
359  } else if (TemplateKWLoc.isValid()) {
360  getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
361  TemplateKWLoc);
362  }
363  DeclRefExprBits.HadMultipleCandidates = 0;
364 
365  computeDependence(Ctx);
366 }
367 
369  NestedNameSpecifierLoc QualifierLoc,
370  SourceLocation TemplateKWLoc,
371  ValueDecl *D,
372  bool RefersToEnclosingVariableOrCapture,
373  SourceLocation NameLoc,
374  QualType T,
375  ExprValueKind VK,
376  NamedDecl *FoundD,
377  const TemplateArgumentListInfo *TemplateArgs) {
378  return Create(Context, QualifierLoc, TemplateKWLoc, D,
379  RefersToEnclosingVariableOrCapture,
380  DeclarationNameInfo(D->getDeclName(), NameLoc),
381  T, VK, FoundD, TemplateArgs);
382 }
383 
385  NestedNameSpecifierLoc QualifierLoc,
386  SourceLocation TemplateKWLoc,
387  ValueDecl *D,
388  bool RefersToEnclosingVariableOrCapture,
389  const DeclarationNameInfo &NameInfo,
390  QualType T,
391  ExprValueKind VK,
392  NamedDecl *FoundD,
393  const TemplateArgumentListInfo *TemplateArgs) {
394  // Filter out cases where the found Decl is the same as the value refenenced.
395  if (D == FoundD)
396  FoundD = nullptr;
397 
398  bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid();
399  std::size_t Size =
400  totalSizeToAlloc<NestedNameSpecifierLoc, NamedDecl *,
401  ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
402  QualifierLoc ? 1 : 0, FoundD ? 1 : 0,
403  HasTemplateKWAndArgsInfo ? 1 : 0,
404  TemplateArgs ? TemplateArgs->size() : 0);
405 
406  void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
407  return new (Mem) DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D,
408  RefersToEnclosingVariableOrCapture,
409  NameInfo, FoundD, TemplateArgs, T, VK);
410 }
411 
413  bool HasQualifier,
414  bool HasFoundDecl,
415  bool HasTemplateKWAndArgsInfo,
416  unsigned NumTemplateArgs) {
417  assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
418  std::size_t Size =
419  totalSizeToAlloc<NestedNameSpecifierLoc, NamedDecl *,
420  ASTTemplateKWAndArgsInfo, TemplateArgumentLoc>(
421  HasQualifier ? 1 : 0, HasFoundDecl ? 1 : 0, HasTemplateKWAndArgsInfo,
422  NumTemplateArgs);
423  void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
424  return new (Mem) DeclRefExpr(EmptyShell());
425 }
426 
428  if (hasQualifier())
429  return getQualifierLoc().getBeginLoc();
430  return getNameInfo().getLocStart();
431 }
434  return getRAngleLoc();
435  return getNameInfo().getLocEnd();
436 }
437 
439  StringLiteral *SL)
440  : Expr(PredefinedExprClass, FNTy, VK_LValue, OK_Ordinary,
441  FNTy->isDependentType(), FNTy->isDependentType(),
442  FNTy->isInstantiationDependentType(),
443  /*ContainsUnexpandedParameterPack=*/false),
444  Loc(L), Type(IT), FnName(SL) {}
445 
447  return cast_or_null<StringLiteral>(FnName);
448 }
449 
451  switch (IT) {
452  case Func:
453  return "__func__";
454  case Function:
455  return "__FUNCTION__";
456  case FuncDName:
457  return "__FUNCDNAME__";
458  case LFunction:
459  return "L__FUNCTION__";
460  case PrettyFunction:
461  return "__PRETTY_FUNCTION__";
462  case FuncSig:
463  return "__FUNCSIG__";
465  break;
466  }
467  llvm_unreachable("Unknown ident type for PredefinedExpr");
468 }
469 
470 // FIXME: Maybe this should use DeclPrinter with a special "print predefined
471 // expr" policy instead.
472 std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) {
473  ASTContext &Context = CurrentDecl->getASTContext();
474 
475  if (IT == PredefinedExpr::FuncDName) {
476  if (const NamedDecl *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
477  std::unique_ptr<MangleContext> MC;
478  MC.reset(Context.createMangleContext());
479 
480  if (MC->shouldMangleDeclName(ND)) {
482  llvm::raw_svector_ostream Out(Buffer);
483  if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(ND))
484  MC->mangleCXXCtor(CD, Ctor_Base, Out);
485  else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(ND))
486  MC->mangleCXXDtor(DD, Dtor_Base, Out);
487  else
488  MC->mangleName(ND, Out);
489 
490  if (!Buffer.empty() && Buffer.front() == '\01')
491  return Buffer.substr(1);
492  return Buffer.str();
493  } else
494  return ND->getIdentifier()->getName();
495  }
496  return "";
497  }
498  if (auto *BD = dyn_cast<BlockDecl>(CurrentDecl)) {
499  std::unique_ptr<MangleContext> MC;
500  MC.reset(Context.createMangleContext());
502  llvm::raw_svector_ostream Out(Buffer);
503  auto DC = CurrentDecl->getDeclContext();
504  if (DC->isFileContext())
505  MC->mangleGlobalBlock(BD, /*ID*/ nullptr, Out);
506  else if (const auto *CD = dyn_cast<CXXConstructorDecl>(DC))
507  MC->mangleCtorBlock(CD, /*CT*/ Ctor_Complete, BD, Out);
508  else if (const auto *DD = dyn_cast<CXXDestructorDecl>(DC))
509  MC->mangleDtorBlock(DD, /*DT*/ Dtor_Complete, BD, Out);
510  else
511  MC->mangleBlock(DC, BD, Out);
512  return Out.str();
513  }
514  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
515  if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual && IT != FuncSig)
516  return FD->getNameAsString();
517 
519  llvm::raw_svector_ostream Out(Name);
520 
521  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
522  if (MD->isVirtual() && IT != PrettyFunctionNoVirtual)
523  Out << "virtual ";
524  if (MD->isStatic())
525  Out << "static ";
526  }
527 
528  PrintingPolicy Policy(Context.getLangOpts());
529  std::string Proto;
530  llvm::raw_string_ostream POut(Proto);
531 
532  const FunctionDecl *Decl = FD;
533  if (const FunctionDecl* Pattern = FD->getTemplateInstantiationPattern())
534  Decl = Pattern;
535  const FunctionType *AFT = Decl->getType()->getAs<FunctionType>();
536  const FunctionProtoType *FT = nullptr;
537  if (FD->hasWrittenPrototype())
538  FT = dyn_cast<FunctionProtoType>(AFT);
539 
540  if (IT == FuncSig) {
541  switch (FT->getCallConv()) {
542  case CC_C: POut << "__cdecl "; break;
543  case CC_X86StdCall: POut << "__stdcall "; break;
544  case CC_X86FastCall: POut << "__fastcall "; break;
545  case CC_X86ThisCall: POut << "__thiscall "; break;
546  case CC_X86VectorCall: POut << "__vectorcall "; break;
547  // Only bother printing the conventions that MSVC knows about.
548  default: break;
549  }
550  }
551 
552  FD->printQualifiedName(POut, Policy);
553 
554  POut << "(";
555  if (FT) {
556  for (unsigned i = 0, e = Decl->getNumParams(); i != e; ++i) {
557  if (i) POut << ", ";
558  POut << Decl->getParamDecl(i)->getType().stream(Policy);
559  }
560 
561  if (FT->isVariadic()) {
562  if (FD->getNumParams()) POut << ", ";
563  POut << "...";
564  }
565  }
566  POut << ")";
567 
568  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
569  const FunctionType *FT = MD->getType()->castAs<FunctionType>();
570  if (FT->isConst())
571  POut << " const";
572  if (FT->isVolatile())
573  POut << " volatile";
574  RefQualifierKind Ref = MD->getRefQualifier();
575  if (Ref == RQ_LValue)
576  POut << " &";
577  else if (Ref == RQ_RValue)
578  POut << " &&";
579  }
580 
582  SpecsTy Specs;
583  const DeclContext *Ctx = FD->getDeclContext();
584  while (Ctx && isa<NamedDecl>(Ctx)) {
586  = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
587  if (Spec && !Spec->isExplicitSpecialization())
588  Specs.push_back(Spec);
589  Ctx = Ctx->getParent();
590  }
591 
592  std::string TemplateParams;
593  llvm::raw_string_ostream TOut(TemplateParams);
594  for (SpecsTy::reverse_iterator I = Specs.rbegin(), E = Specs.rend();
595  I != E; ++I) {
596  const TemplateParameterList *Params
597  = (*I)->getSpecializedTemplate()->getTemplateParameters();
598  const TemplateArgumentList &Args = (*I)->getTemplateArgs();
599  assert(Params->size() == Args.size());
600  for (unsigned i = 0, numParams = Params->size(); i != numParams; ++i) {
601  StringRef Param = Params->getParam(i)->getName();
602  if (Param.empty()) continue;
603  TOut << Param << " = ";
604  Args.get(i).print(Policy, TOut);
605  TOut << ", ";
606  }
607  }
608 
610  = FD->getTemplateSpecializationInfo();
611  if (FSI && !FSI->isExplicitSpecialization()) {
612  const TemplateParameterList* Params
614  const TemplateArgumentList* Args = FSI->TemplateArguments;
615  assert(Params->size() == Args->size());
616  for (unsigned i = 0, e = Params->size(); i != e; ++i) {
617  StringRef Param = Params->getParam(i)->getName();
618  if (Param.empty()) continue;
619  TOut << Param << " = ";
620  Args->get(i).print(Policy, TOut);
621  TOut << ", ";
622  }
623  }
624 
625  TOut.flush();
626  if (!TemplateParams.empty()) {
627  // remove the trailing comma and space
628  TemplateParams.resize(TemplateParams.size() - 2);
629  POut << " [" << TemplateParams << "]";
630  }
631 
632  POut.flush();
633 
634  // Print "auto" for all deduced return types. This includes C++1y return
635  // type deduction and lambdas. For trailing return types resolve the
636  // decltype expression. Otherwise print the real type when this is
637  // not a constructor or destructor.
638  if (isa<CXXMethodDecl>(FD) &&
639  cast<CXXMethodDecl>(FD)->getParent()->isLambda())
640  Proto = "auto " + Proto;
641  else if (FT && FT->getReturnType()->getAs<DecltypeType>())
642  FT->getReturnType()
643  ->getAs<DecltypeType>()
645  .getAsStringInternal(Proto, Policy);
646  else if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
647  AFT->getReturnType().getAsStringInternal(Proto, Policy);
648 
649  Out << Proto;
650 
651  return Name.str().str();
652  }
653  if (const CapturedDecl *CD = dyn_cast<CapturedDecl>(CurrentDecl)) {
654  for (const DeclContext *DC = CD->getParent(); DC; DC = DC->getParent())
655  // Skip to its enclosing function or method, but not its enclosing
656  // CapturedDecl.
657  if (DC->isFunctionOrMethod() && (DC->getDeclKind() != Decl::Captured)) {
658  const Decl *D = Decl::castFromDeclContext(DC);
659  return ComputeName(IT, D);
660  }
661  llvm_unreachable("CapturedDecl not inside a function or method");
662  }
663  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
665  llvm::raw_svector_ostream Out(Name);
666  Out << (MD->isInstanceMethod() ? '-' : '+');
667  Out << '[';
668 
669  // For incorrect code, there might not be an ObjCInterfaceDecl. Do
670  // a null check to avoid a crash.
671  if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
672  Out << *ID;
673 
674  if (const ObjCCategoryImplDecl *CID =
675  dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
676  Out << '(' << *CID << ')';
677 
678  Out << ' ';
679  MD->getSelector().print(Out);
680  Out << ']';
681 
682  return Name.str().str();
683  }
684  if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) {
685  // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
686  return "top level";
687  }
688  return "";
689 }
690 
692  const llvm::APInt &Val) {
693  if (hasAllocation())
694  C.Deallocate(pVal);
695 
696  BitWidth = Val.getBitWidth();
697  unsigned NumWords = Val.getNumWords();
698  const uint64_t* Words = Val.getRawData();
699  if (NumWords > 1) {
700  pVal = new (C) uint64_t[NumWords];
701  std::copy(Words, Words + NumWords, pVal);
702  } else if (NumWords == 1)
703  VAL = Words[0];
704  else
705  VAL = 0;
706 }
707 
708 IntegerLiteral::IntegerLiteral(const ASTContext &C, const llvm::APInt &V,
710  : Expr(IntegerLiteralClass, type, VK_RValue, OK_Ordinary, false, false,
711  false, false),
712  Loc(l) {
713  assert(type->isIntegerType() && "Illegal type in IntegerLiteral");
714  assert(V.getBitWidth() == C.getIntWidth(type) &&
715  "Integer type is not the correct size for constant.");
716  setValue(C, V);
717 }
718 
720 IntegerLiteral::Create(const ASTContext &C, const llvm::APInt &V,
722  return new (C) IntegerLiteral(C, V, type, l);
723 }
724 
726 IntegerLiteral::Create(const ASTContext &C, EmptyShell Empty) {
727  return new (C) IntegerLiteral(Empty);
728 }
729 
730 FloatingLiteral::FloatingLiteral(const ASTContext &C, const llvm::APFloat &V,
731  bool isexact, QualType Type, SourceLocation L)
732  : Expr(FloatingLiteralClass, Type, VK_RValue, OK_Ordinary, false, false,
733  false, false), Loc(L) {
734  setSemantics(V.getSemantics());
735  FloatingLiteralBits.IsExact = isexact;
736  setValue(C, V);
737 }
738 
739 FloatingLiteral::FloatingLiteral(const ASTContext &C, EmptyShell Empty)
740  : Expr(FloatingLiteralClass, Empty) {
741  setRawSemantics(IEEEhalf);
742  FloatingLiteralBits.IsExact = false;
743 }
744 
746 FloatingLiteral::Create(const ASTContext &C, const llvm::APFloat &V,
747  bool isexact, QualType Type, SourceLocation L) {
748  return new (C) FloatingLiteral(C, V, isexact, Type, L);
749 }
750 
752 FloatingLiteral::Create(const ASTContext &C, EmptyShell Empty) {
753  return new (C) FloatingLiteral(C, Empty);
754 }
755 
756 const llvm::fltSemantics &FloatingLiteral::getSemantics() const {
757  switch(FloatingLiteralBits.Semantics) {
758  case IEEEhalf:
759  return llvm::APFloat::IEEEhalf;
760  case IEEEsingle:
761  return llvm::APFloat::IEEEsingle;
762  case IEEEdouble:
763  return llvm::APFloat::IEEEdouble;
764  case x87DoubleExtended:
765  return llvm::APFloat::x87DoubleExtended;
766  case IEEEquad:
767  return llvm::APFloat::IEEEquad;
768  case PPCDoubleDouble:
769  return llvm::APFloat::PPCDoubleDouble;
770  }
771  llvm_unreachable("Unrecognised floating semantics");
772 }
773 
774 void FloatingLiteral::setSemantics(const llvm::fltSemantics &Sem) {
775  if (&Sem == &llvm::APFloat::IEEEhalf)
776  FloatingLiteralBits.Semantics = IEEEhalf;
777  else if (&Sem == &llvm::APFloat::IEEEsingle)
778  FloatingLiteralBits.Semantics = IEEEsingle;
779  else if (&Sem == &llvm::APFloat::IEEEdouble)
780  FloatingLiteralBits.Semantics = IEEEdouble;
781  else if (&Sem == &llvm::APFloat::x87DoubleExtended)
782  FloatingLiteralBits.Semantics = x87DoubleExtended;
783  else if (&Sem == &llvm::APFloat::IEEEquad)
784  FloatingLiteralBits.Semantics = IEEEquad;
785  else if (&Sem == &llvm::APFloat::PPCDoubleDouble)
786  FloatingLiteralBits.Semantics = PPCDoubleDouble;
787  else
788  llvm_unreachable("Unknown floating semantics");
789 }
790 
791 /// getValueAsApproximateDouble - This returns the value as an inaccurate
792 /// double. Note that this may cause loss of precision, but is useful for
793 /// debugging dumps, etc.
795  llvm::APFloat V = getValue();
796  bool ignored;
797  V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
798  &ignored);
799  return V.convertToDouble();
800 }
801 
802 int StringLiteral::mapCharByteWidth(TargetInfo const &target,StringKind k) {
803  int CharByteWidth = 0;
804  switch(k) {
805  case Ascii:
806  case UTF8:
807  CharByteWidth = target.getCharWidth();
808  break;
809  case Wide:
810  CharByteWidth = target.getWCharWidth();
811  break;
812  case UTF16:
813  CharByteWidth = target.getChar16Width();
814  break;
815  case UTF32:
816  CharByteWidth = target.getChar32Width();
817  break;
818  }
819  assert((CharByteWidth & 7) == 0 && "Assumes character size is byte multiple");
820  CharByteWidth /= 8;
821  assert((CharByteWidth==1 || CharByteWidth==2 || CharByteWidth==4)
822  && "character byte widths supported are 1, 2, and 4 only");
823  return CharByteWidth;
824 }
825 
827  StringKind Kind, bool Pascal, QualType Ty,
828  const SourceLocation *Loc,
829  unsigned NumStrs) {
830  assert(C.getAsConstantArrayType(Ty) &&
831  "StringLiteral must be of constant array type!");
832 
833  // Allocate enough space for the StringLiteral plus an array of locations for
834  // any concatenated string tokens.
835  void *Mem = C.Allocate(sizeof(StringLiteral)+
836  sizeof(SourceLocation)*(NumStrs-1),
837  llvm::alignOf<StringLiteral>());
838  StringLiteral *SL = new (Mem) StringLiteral(Ty);
839 
840  // OPTIMIZE: could allocate this appended to the StringLiteral.
841  SL->setString(C,Str,Kind,Pascal);
842 
843  SL->TokLocs[0] = Loc[0];
844  SL->NumConcatenated = NumStrs;
845 
846  if (NumStrs != 1)
847  memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1));
848  return SL;
849 }
850 
852  unsigned NumStrs) {
853  void *Mem = C.Allocate(sizeof(StringLiteral)+
854  sizeof(SourceLocation)*(NumStrs-1),
855  llvm::alignOf<StringLiteral>());
856  StringLiteral *SL = new (Mem) StringLiteral(QualType());
857  SL->CharByteWidth = 0;
858  SL->Length = 0;
859  SL->NumConcatenated = NumStrs;
860  return SL;
861 }
862 
863 void StringLiteral::outputString(raw_ostream &OS) const {
864  switch (getKind()) {
865  case Ascii: break; // no prefix.
866  case Wide: OS << 'L'; break;
867  case UTF8: OS << "u8"; break;
868  case UTF16: OS << 'u'; break;
869  case UTF32: OS << 'U'; break;
870  }
871  OS << '"';
872  static const char Hex[] = "0123456789ABCDEF";
873 
874  unsigned LastSlashX = getLength();
875  for (unsigned I = 0, N = getLength(); I != N; ++I) {
876  switch (uint32_t Char = getCodeUnit(I)) {
877  default:
878  // FIXME: Convert UTF-8 back to codepoints before rendering.
879 
880  // Convert UTF-16 surrogate pairs back to codepoints before rendering.
881  // Leave invalid surrogates alone; we'll use \x for those.
882  if (getKind() == UTF16 && I != N - 1 && Char >= 0xd800 &&
883  Char <= 0xdbff) {
884  uint32_t Trail = getCodeUnit(I + 1);
885  if (Trail >= 0xdc00 && Trail <= 0xdfff) {
886  Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00);
887  ++I;
888  }
889  }
890 
891  if (Char > 0xff) {
892  // If this is a wide string, output characters over 0xff using \x
893  // escapes. Otherwise, this is a UTF-16 or UTF-32 string, and Char is a
894  // codepoint: use \x escapes for invalid codepoints.
895  if (getKind() == Wide ||
896  (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) {
897  // FIXME: Is this the best way to print wchar_t?
898  OS << "\\x";
899  int Shift = 28;
900  while ((Char >> Shift) == 0)
901  Shift -= 4;
902  for (/**/; Shift >= 0; Shift -= 4)
903  OS << Hex[(Char >> Shift) & 15];
904  LastSlashX = I;
905  break;
906  }
907 
908  if (Char > 0xffff)
909  OS << "\\U00"
910  << Hex[(Char >> 20) & 15]
911  << Hex[(Char >> 16) & 15];
912  else
913  OS << "\\u";
914  OS << Hex[(Char >> 12) & 15]
915  << Hex[(Char >> 8) & 15]
916  << Hex[(Char >> 4) & 15]
917  << Hex[(Char >> 0) & 15];
918  break;
919  }
920 
921  // If we used \x... for the previous character, and this character is a
922  // hexadecimal digit, prevent it being slurped as part of the \x.
923  if (LastSlashX + 1 == I) {
924  switch (Char) {
925  case '0': case '1': case '2': case '3': case '4':
926  case '5': case '6': case '7': case '8': case '9':
927  case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
928  case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
929  OS << "\"\"";
930  }
931  }
932 
933  assert(Char <= 0xff &&
934  "Characters above 0xff should already have been handled.");
935 
936  if (isPrintable(Char))
937  OS << (char)Char;
938  else // Output anything hard as an octal escape.
939  OS << '\\'
940  << (char)('0' + ((Char >> 6) & 7))
941  << (char)('0' + ((Char >> 3) & 7))
942  << (char)('0' + ((Char >> 0) & 7));
943  break;
944  // Handle some common non-printable cases to make dumps prettier.
945  case '\\': OS << "\\\\"; break;
946  case '"': OS << "\\\""; break;
947  case '\n': OS << "\\n"; break;
948  case '\t': OS << "\\t"; break;
949  case '\a': OS << "\\a"; break;
950  case '\b': OS << "\\b"; break;
951  }
952  }
953  OS << '"';
954 }
955 
956 void StringLiteral::setString(const ASTContext &C, StringRef Str,
957  StringKind Kind, bool IsPascal) {
958  //FIXME: we assume that the string data comes from a target that uses the same
959  // code unit size and endianess for the type of string.
960  this->Kind = Kind;
961  this->IsPascal = IsPascal;
962 
963  CharByteWidth = mapCharByteWidth(C.getTargetInfo(),Kind);
964  assert((Str.size()%CharByteWidth == 0)
965  && "size of data must be multiple of CharByteWidth");
966  Length = Str.size()/CharByteWidth;
967 
968  switch(CharByteWidth) {
969  case 1: {
970  char *AStrData = new (C) char[Length];
971  std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData));
972  StrData.asChar = AStrData;
973  break;
974  }
975  case 2: {
976  uint16_t *AStrData = new (C) uint16_t[Length];
977  std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData));
978  StrData.asUInt16 = AStrData;
979  break;
980  }
981  case 4: {
982  uint32_t *AStrData = new (C) uint32_t[Length];
983  std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData));
984  StrData.asUInt32 = AStrData;
985  break;
986  }
987  default:
988  llvm_unreachable("unsupported CharByteWidth");
989  }
990 }
991 
992 /// getLocationOfByte - Return a source location that points to the specified
993 /// byte of this string literal.
994 ///
995 /// Strings are amazingly complex. They can be formed from multiple tokens and
996 /// can have escape sequences in them in addition to the usual trigraph and
997 /// escaped newline business. This routine handles this complexity.
998 ///
999 /// The *StartToken sets the first token to be searched in this function and
1000 /// the *StartTokenByteOffset is the byte offset of the first token. Before
1001 /// returning, it updates the *StartToken to the TokNo of the token being found
1002 /// and sets *StartTokenByteOffset to the byte offset of the token in the
1003 /// string.
1004 /// Using these two parameters can reduce the time complexity from O(n^2) to
1005 /// O(n) if one wants to get the location of byte for all the tokens in a
1006 /// string.
1007 ///
1010  const LangOptions &Features,
1011  const TargetInfo &Target, unsigned *StartToken,
1012  unsigned *StartTokenByteOffset) const {
1013  assert((Kind == StringLiteral::Ascii || Kind == StringLiteral::UTF8) &&
1014  "Only narrow string literals are currently supported");
1015 
1016  // Loop over all of the tokens in this string until we find the one that
1017  // contains the byte we're looking for.
1018  unsigned TokNo = 0;
1019  unsigned StringOffset = 0;
1020  if (StartToken)
1021  TokNo = *StartToken;
1022  if (StartTokenByteOffset) {
1023  StringOffset = *StartTokenByteOffset;
1024  ByteNo -= StringOffset;
1025  }
1026  while (1) {
1027  assert(TokNo < getNumConcatenated() && "Invalid byte number!");
1028  SourceLocation StrTokLoc = getStrTokenLoc(TokNo);
1029 
1030  // Get the spelling of the string so that we can get the data that makes up
1031  // the string literal, not the identifier for the macro it is potentially
1032  // expanded through.
1033  SourceLocation StrTokSpellingLoc = SM.getSpellingLoc(StrTokLoc);
1034 
1035  // Re-lex the token to get its length and original spelling.
1036  std::pair<FileID, unsigned> LocInfo =
1037  SM.getDecomposedLoc(StrTokSpellingLoc);
1038  bool Invalid = false;
1039  StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid);
1040  if (Invalid) {
1041  if (StartTokenByteOffset != nullptr)
1042  *StartTokenByteOffset = StringOffset;
1043  if (StartToken != nullptr)
1044  *StartToken = TokNo;
1045  return StrTokSpellingLoc;
1046  }
1047 
1048  const char *StrData = Buffer.data()+LocInfo.second;
1049 
1050  // Create a lexer starting at the beginning of this token.
1051  Lexer TheLexer(SM.getLocForStartOfFile(LocInfo.first), Features,
1052  Buffer.begin(), StrData, Buffer.end());
1053  Token TheTok;
1054  TheLexer.LexFromRawLexer(TheTok);
1055 
1056  // Use the StringLiteralParser to compute the length of the string in bytes.
1057  StringLiteralParser SLP(TheTok, SM, Features, Target);
1058  unsigned TokNumBytes = SLP.GetStringLength();
1059 
1060  // If the byte is in this token, return the location of the byte.
1061  if (ByteNo < TokNumBytes ||
1062  (ByteNo == TokNumBytes && TokNo == getNumConcatenated() - 1)) {
1063  unsigned Offset = SLP.getOffsetOfStringByte(TheTok, ByteNo);
1064 
1065  // Now that we know the offset of the token in the spelling, use the
1066  // preprocessor to get the offset in the original source.
1067  if (StartTokenByteOffset != nullptr)
1068  *StartTokenByteOffset = StringOffset;
1069  if (StartToken != nullptr)
1070  *StartToken = TokNo;
1071  return Lexer::AdvanceToTokenCharacter(StrTokLoc, Offset, SM, Features);
1072  }
1073 
1074  // Move to the next string token.
1075  StringOffset += TokNumBytes;
1076  ++TokNo;
1077  ByteNo -= TokNumBytes;
1078  }
1079 }
1080 
1081 
1082 
1083 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
1084 /// corresponds to, e.g. "sizeof" or "[pre]++".
1086  switch (Op) {
1087 #define UNARY_OPERATION(Name, Spelling) case UO_##Name: return Spelling;
1088 #include "clang/AST/OperationKinds.def"
1089  }
1090  llvm_unreachable("Unknown unary operator");
1091 }
1092 
1095  switch (OO) {
1096  default: llvm_unreachable("No unary operator for overloaded function");
1097  case OO_PlusPlus: return Postfix ? UO_PostInc : UO_PreInc;
1098  case OO_MinusMinus: return Postfix ? UO_PostDec : UO_PreDec;
1099  case OO_Amp: return UO_AddrOf;
1100  case OO_Star: return UO_Deref;
1101  case OO_Plus: return UO_Plus;
1102  case OO_Minus: return UO_Minus;
1103  case OO_Tilde: return UO_Not;
1104  case OO_Exclaim: return UO_LNot;
1105  case OO_Coawait: return UO_Coawait;
1106  }
1107 }
1108 
1110  switch (Opc) {
1111  case UO_PostInc: case UO_PreInc: return OO_PlusPlus;
1112  case UO_PostDec: case UO_PreDec: return OO_MinusMinus;
1113  case UO_AddrOf: return OO_Amp;
1114  case UO_Deref: return OO_Star;
1115  case UO_Plus: return OO_Plus;
1116  case UO_Minus: return OO_Minus;
1117  case UO_Not: return OO_Tilde;
1118  case UO_LNot: return OO_Exclaim;
1119  case UO_Coawait: return OO_Coawait;
1120  default: return OO_None;
1121  }
1122 }
1123 
1124 
1125 //===----------------------------------------------------------------------===//
1126 // Postfix Operators.
1127 //===----------------------------------------------------------------------===//
1128 
1129 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, Expr *fn,
1130  ArrayRef<Expr *> preargs, ArrayRef<Expr *> args, QualType t,
1131  ExprValueKind VK, SourceLocation rparenloc)
1132  : Expr(SC, t, VK, OK_Ordinary, fn->isTypeDependent(),
1133  fn->isValueDependent(), fn->isInstantiationDependent(),
1134  fn->containsUnexpandedParameterPack()),
1135  NumArgs(args.size()) {
1136 
1137  unsigned NumPreArgs = preargs.size();
1138  SubExprs = new (C) Stmt *[args.size()+PREARGS_START+NumPreArgs];
1139  SubExprs[FN] = fn;
1140  for (unsigned i = 0; i != NumPreArgs; ++i) {
1141  updateDependenciesFromArg(preargs[i]);
1142  SubExprs[i+PREARGS_START] = preargs[i];
1143  }
1144  for (unsigned i = 0; i != args.size(); ++i) {
1145  updateDependenciesFromArg(args[i]);
1146  SubExprs[i+PREARGS_START+NumPreArgs] = args[i];
1147  }
1148 
1149  CallExprBits.NumPreArgs = NumPreArgs;
1150  RParenLoc = rparenloc;
1151 }
1152 
1153 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, Expr *fn,
1155  SourceLocation rparenloc)
1156  : CallExpr(C, SC, fn, ArrayRef<Expr *>(), args, t, VK, rparenloc) {}
1157 
1159  QualType t, ExprValueKind VK, SourceLocation rparenloc)
1160  : CallExpr(C, CallExprClass, fn, ArrayRef<Expr *>(), args, t, VK, rparenloc) {
1161 }
1162 
1163 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, EmptyShell Empty)
1164  : CallExpr(C, SC, /*NumPreArgs=*/0, Empty) {}
1165 
1166 CallExpr::CallExpr(const ASTContext &C, StmtClass SC, unsigned NumPreArgs,
1167  EmptyShell Empty)
1168  : Expr(SC, Empty), SubExprs(nullptr), NumArgs(0) {
1169  // FIXME: Why do we allocate this?
1170  SubExprs = new (C) Stmt*[PREARGS_START+NumPreArgs]();
1171  CallExprBits.NumPreArgs = NumPreArgs;
1172 }
1173 
1174 void CallExpr::updateDependenciesFromArg(Expr *Arg) {
1175  if (Arg->isTypeDependent())
1176  ExprBits.TypeDependent = true;
1177  if (Arg->isValueDependent())
1178  ExprBits.ValueDependent = true;
1179  if (Arg->isInstantiationDependent())
1180  ExprBits.InstantiationDependent = true;
1182  ExprBits.ContainsUnexpandedParameterPack = true;
1183 }
1184 
1186  Expr *CEE = getCallee()->IgnoreParenImpCasts();
1187 
1188  while (SubstNonTypeTemplateParmExpr *NTTP
1189  = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE)) {
1190  CEE = NTTP->getReplacement()->IgnoreParenCasts();
1191  }
1192 
1193  // If we're calling a dereference, look at the pointer instead.
1194  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CEE)) {
1195  if (BO->isPtrMemOp())
1196  CEE = BO->getRHS()->IgnoreParenCasts();
1197  } else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(CEE)) {
1198  if (UO->getOpcode() == UO_Deref)
1199  CEE = UO->getSubExpr()->IgnoreParenCasts();
1200  }
1201  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
1202  return DRE->getDecl();
1203  if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
1204  return ME->getMemberDecl();
1205 
1206  return nullptr;
1207 }
1208 
1210  return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
1211 }
1212 
1213 /// setNumArgs - This changes the number of arguments present in this call.
1214 /// Any orphaned expressions are deleted by this, and any new operands are set
1215 /// to null.
1216 void CallExpr::setNumArgs(const ASTContext& C, unsigned NumArgs) {
1217  // No change, just return.
1218  if (NumArgs == getNumArgs()) return;
1219 
1220  // If shrinking # arguments, just delete the extras and forgot them.
1221  if (NumArgs < getNumArgs()) {
1222  this->NumArgs = NumArgs;
1223  return;
1224  }
1225 
1226  // Otherwise, we are growing the # arguments. New an bigger argument array.
1227  unsigned NumPreArgs = getNumPreArgs();
1228  Stmt **NewSubExprs = new (C) Stmt*[NumArgs+PREARGS_START+NumPreArgs];
1229  // Copy over args.
1230  for (unsigned i = 0; i != getNumArgs()+PREARGS_START+NumPreArgs; ++i)
1231  NewSubExprs[i] = SubExprs[i];
1232  // Null out new args.
1233  for (unsigned i = getNumArgs()+PREARGS_START+NumPreArgs;
1234  i != NumArgs+PREARGS_START+NumPreArgs; ++i)
1235  NewSubExprs[i] = nullptr;
1236 
1237  if (SubExprs) C.Deallocate(SubExprs);
1238  SubExprs = NewSubExprs;
1239  this->NumArgs = NumArgs;
1240 }
1241 
1242 /// getBuiltinCallee - If this is a call to a builtin, return the builtin ID. If
1243 /// not, return 0.
1244 unsigned CallExpr::getBuiltinCallee() const {
1245  // All simple function calls (e.g. func()) are implicitly cast to pointer to
1246  // function. As a result, we try and obtain the DeclRefExpr from the
1247  // ImplicitCastExpr.
1248  const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
1249  if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
1250  return 0;
1251 
1252  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
1253  if (!DRE)
1254  return 0;
1255 
1256  const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
1257  if (!FDecl)
1258  return 0;
1259 
1260  if (!FDecl->getIdentifier())
1261  return 0;
1262 
1263  return FDecl->getBuiltinID();
1264 }
1265 
1267  if (unsigned BI = getBuiltinCallee())
1268  return Ctx.BuiltinInfo.isUnevaluated(BI);
1269  return false;
1270 }
1271 
1273  const Expr *Callee = getCallee();
1274  QualType CalleeType = Callee->getType();
1275  if (const auto *FnTypePtr = CalleeType->getAs<PointerType>()) {
1276  CalleeType = FnTypePtr->getPointeeType();
1277  } else if (const auto *BPT = CalleeType->getAs<BlockPointerType>()) {
1278  CalleeType = BPT->getPointeeType();
1279  } else if (CalleeType->isSpecificPlaceholderType(BuiltinType::BoundMember)) {
1280  if (isa<CXXPseudoDestructorExpr>(Callee->IgnoreParens()))
1281  return Ctx.VoidTy;
1282 
1283  // This should never be overloaded and so should never return null.
1284  CalleeType = Expr::findBoundMemberType(Callee);
1285  }
1286 
1287  const FunctionType *FnType = CalleeType->castAs<FunctionType>();
1288  return FnType->getReturnType();
1289 }
1290 
1292  if (isa<CXXOperatorCallExpr>(this))
1293  return cast<CXXOperatorCallExpr>(this)->getLocStart();
1294 
1295  SourceLocation begin = getCallee()->getLocStart();
1296  if (begin.isInvalid() && getNumArgs() > 0 && getArg(0))
1297  begin = getArg(0)->getLocStart();
1298  return begin;
1299 }
1301  if (isa<CXXOperatorCallExpr>(this))
1302  return cast<CXXOperatorCallExpr>(this)->getLocEnd();
1303 
1305  if (end.isInvalid() && getNumArgs() > 0 && getArg(getNumArgs() - 1))
1306  end = getArg(getNumArgs() - 1)->getLocEnd();
1307  return end;
1308 }
1309 
1311  SourceLocation OperatorLoc,
1312  TypeSourceInfo *tsi,
1313  ArrayRef<OffsetOfNode> comps,
1314  ArrayRef<Expr*> exprs,
1315  SourceLocation RParenLoc) {
1316  void *Mem = C.Allocate(
1317  totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));
1318 
1319  return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, comps, exprs,
1320  RParenLoc);
1321 }
1322 
1324  unsigned numComps, unsigned numExprs) {
1325  void *Mem =
1326  C.Allocate(totalSizeToAlloc<OffsetOfNode, Expr *>(numComps, numExprs));
1327  return new (Mem) OffsetOfExpr(numComps, numExprs);
1328 }
1329 
1330 OffsetOfExpr::OffsetOfExpr(const ASTContext &C, QualType type,
1331  SourceLocation OperatorLoc, TypeSourceInfo *tsi,
1333  SourceLocation RParenLoc)
1334  : Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary,
1335  /*TypeDependent=*/false,
1336  /*ValueDependent=*/tsi->getType()->isDependentType(),
1337  tsi->getType()->isInstantiationDependentType(),
1338  tsi->getType()->containsUnexpandedParameterPack()),
1339  OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
1340  NumComps(comps.size()), NumExprs(exprs.size())
1341 {
1342  for (unsigned i = 0; i != comps.size(); ++i) {
1343  setComponent(i, comps[i]);
1344  }
1345 
1346  for (unsigned i = 0; i != exprs.size(); ++i) {
1347  if (exprs[i]->isTypeDependent() || exprs[i]->isValueDependent())
1348  ExprBits.ValueDependent = true;
1349  if (exprs[i]->containsUnexpandedParameterPack())
1350  ExprBits.ContainsUnexpandedParameterPack = true;
1351 
1352  setIndexExpr(i, exprs[i]);
1353  }
1354 }
1355 
1357  assert(getKind() == Field || getKind() == Identifier);
1358  if (getKind() == Field)
1359  return getField()->getIdentifier();
1360 
1361  return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask);
1362 }
1363 
1365  UnaryExprOrTypeTrait ExprKind, Expr *E, QualType resultType,
1367  : Expr(UnaryExprOrTypeTraitExprClass, resultType, VK_RValue, OK_Ordinary,
1368  false, // Never type-dependent (C++ [temp.dep.expr]p3).
1369  // Value-dependent if the argument is type-dependent.
1370  E->isTypeDependent(), E->isInstantiationDependent(),
1371  E->containsUnexpandedParameterPack()),
1372  OpLoc(op), RParenLoc(rp) {
1373  UnaryExprOrTypeTraitExprBits.Kind = ExprKind;
1374  UnaryExprOrTypeTraitExprBits.IsType = false;
1375  Argument.Ex = E;
1376 
1377  // Check to see if we are in the situation where alignof(decl) should be
1378  // dependent because decl's alignment is dependent.
1379  if (ExprKind == UETT_AlignOf) {
1381  E = E->IgnoreParens();
1382 
1383  const ValueDecl *D = nullptr;
1384  if (const auto *DRE = dyn_cast<DeclRefExpr>(E))
1385  D = DRE->getDecl();
1386  else if (const auto *ME = dyn_cast<MemberExpr>(E))
1387  D = ME->getMemberDecl();
1388 
1389  if (D) {
1390  for (const auto *I : D->specific_attrs<AlignedAttr>()) {
1391  if (I->isAlignmentDependent()) {
1392  setValueDependent(true);
1394  break;
1395  }
1396  }
1397  }
1398  }
1399  }
1400 }
1401 
1403  const ASTContext &C, Expr *base, bool isarrow, SourceLocation OperatorLoc,
1404  NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
1405  ValueDecl *memberdecl, DeclAccessPair founddecl,
1406  DeclarationNameInfo nameinfo, const TemplateArgumentListInfo *targs,
1407  QualType ty, ExprValueKind vk, ExprObjectKind ok) {
1408 
1409  bool hasQualOrFound = (QualifierLoc ||
1410  founddecl.getDecl() != memberdecl ||
1411  founddecl.getAccess() != memberdecl->getAccess());
1412 
1413  bool HasTemplateKWAndArgsInfo = targs || TemplateKWLoc.isValid();
1414  std::size_t Size =
1415  totalSizeToAlloc<MemberExprNameQualifier, ASTTemplateKWAndArgsInfo,
1416  TemplateArgumentLoc>(hasQualOrFound ? 1 : 0,
1417  HasTemplateKWAndArgsInfo ? 1 : 0,
1418  targs ? targs->size() : 0);
1419 
1420  void *Mem = C.Allocate(Size, llvm::alignOf<MemberExpr>());
1421  MemberExpr *E = new (Mem)
1422  MemberExpr(base, isarrow, OperatorLoc, memberdecl, nameinfo, ty, vk, ok);
1423 
1424  if (hasQualOrFound) {
1425  // FIXME: Wrong. We should be looking at the member declaration we found.
1426  if (QualifierLoc && QualifierLoc.getNestedNameSpecifier()->isDependent()) {
1427  E->setValueDependent(true);
1428  E->setTypeDependent(true);
1429  E->setInstantiationDependent(true);
1430  }
1431  else if (QualifierLoc &&
1433  E->setInstantiationDependent(true);
1434 
1435  E->HasQualifierOrFoundDecl = true;
1436 
1437  MemberExprNameQualifier *NQ =
1438  E->getTrailingObjects<MemberExprNameQualifier>();
1439  NQ->QualifierLoc = QualifierLoc;
1440  NQ->FoundDecl = founddecl;
1441  }
1442 
1443  E->HasTemplateKWAndArgsInfo = (targs || TemplateKWLoc.isValid());
1444 
1445  if (targs) {
1446  bool Dependent = false;
1447  bool InstantiationDependent = false;
1448  bool ContainsUnexpandedParameterPack = false;
1449  E->getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1450  TemplateKWLoc, *targs, E->getTrailingObjects<TemplateArgumentLoc>(),
1451  Dependent, InstantiationDependent, ContainsUnexpandedParameterPack);
1452  if (InstantiationDependent)
1453  E->setInstantiationDependent(true);
1454  } else if (TemplateKWLoc.isValid()) {
1455  E->getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1456  TemplateKWLoc);
1457  }
1458 
1459  return E;
1460 }
1461 
1463  if (isImplicitAccess()) {
1464  if (hasQualifier())
1465  return getQualifierLoc().getBeginLoc();
1466  return MemberLoc;
1467  }
1468 
1469  // FIXME: We don't want this to happen. Rather, we should be able to
1470  // detect all kinds of implicit accesses more cleanly.
1471  SourceLocation BaseStartLoc = getBase()->getLocStart();
1472  if (BaseStartLoc.isValid())
1473  return BaseStartLoc;
1474  return MemberLoc;
1475 }
1479  EndLoc = getRAngleLoc();
1480  else if (EndLoc.isInvalid())
1481  EndLoc = getBase()->getLocEnd();
1482  return EndLoc;
1483 }
1484 
1485 bool CastExpr::CastConsistency() const {
1486  switch (getCastKind()) {
1487  case CK_DerivedToBase:
1488  case CK_UncheckedDerivedToBase:
1489  case CK_DerivedToBaseMemberPointer:
1490  case CK_BaseToDerived:
1491  case CK_BaseToDerivedMemberPointer:
1492  assert(!path_empty() && "Cast kind should have a base path!");
1493  break;
1494 
1495  case CK_CPointerToObjCPointerCast:
1496  assert(getType()->isObjCObjectPointerType());
1497  assert(getSubExpr()->getType()->isPointerType());
1498  goto CheckNoBasePath;
1499 
1500  case CK_BlockPointerToObjCPointerCast:
1501  assert(getType()->isObjCObjectPointerType());
1502  assert(getSubExpr()->getType()->isBlockPointerType());
1503  goto CheckNoBasePath;
1504 
1505  case CK_ReinterpretMemberPointer:
1506  assert(getType()->isMemberPointerType());
1507  assert(getSubExpr()->getType()->isMemberPointerType());
1508  goto CheckNoBasePath;
1509 
1510  case CK_BitCast:
1511  // Arbitrary casts to C pointer types count as bitcasts.
1512  // Otherwise, we should only have block and ObjC pointer casts
1513  // here if they stay within the type kind.
1514  if (!getType()->isPointerType()) {
1515  assert(getType()->isObjCObjectPointerType() ==
1516  getSubExpr()->getType()->isObjCObjectPointerType());
1517  assert(getType()->isBlockPointerType() ==
1518  getSubExpr()->getType()->isBlockPointerType());
1519  }
1520  goto CheckNoBasePath;
1521 
1522  case CK_AnyPointerToBlockPointerCast:
1523  assert(getType()->isBlockPointerType());
1524  assert(getSubExpr()->getType()->isAnyPointerType() &&
1525  !getSubExpr()->getType()->isBlockPointerType());
1526  goto CheckNoBasePath;
1527 
1528  case CK_CopyAndAutoreleaseBlockObject:
1529  assert(getType()->isBlockPointerType());
1530  assert(getSubExpr()->getType()->isBlockPointerType());
1531  goto CheckNoBasePath;
1532 
1533  case CK_FunctionToPointerDecay:
1534  assert(getType()->isPointerType());
1535  assert(getSubExpr()->getType()->isFunctionType());
1536  goto CheckNoBasePath;
1537 
1538  case CK_AddressSpaceConversion:
1539  assert(getType()->isPointerType());
1540  assert(getSubExpr()->getType()->isPointerType());
1541  assert(getType()->getPointeeType().getAddressSpace() !=
1542  getSubExpr()->getType()->getPointeeType().getAddressSpace());
1543  // These should not have an inheritance path.
1544  case CK_Dynamic:
1545  case CK_ToUnion:
1546  case CK_ArrayToPointerDecay:
1547  case CK_NullToMemberPointer:
1548  case CK_NullToPointer:
1549  case CK_ConstructorConversion:
1550  case CK_IntegralToPointer:
1551  case CK_PointerToIntegral:
1552  case CK_ToVoid:
1553  case CK_VectorSplat:
1554  case CK_IntegralCast:
1555  case CK_BooleanToSignedIntegral:
1556  case CK_IntegralToFloating:
1557  case CK_FloatingToIntegral:
1558  case CK_FloatingCast:
1559  case CK_ObjCObjectLValueCast:
1560  case CK_FloatingRealToComplex:
1561  case CK_FloatingComplexToReal:
1562  case CK_FloatingComplexCast:
1563  case CK_FloatingComplexToIntegralComplex:
1564  case CK_IntegralRealToComplex:
1565  case CK_IntegralComplexToReal:
1566  case CK_IntegralComplexCast:
1567  case CK_IntegralComplexToFloatingComplex:
1568  case CK_ARCProduceObject:
1569  case CK_ARCConsumeObject:
1570  case CK_ARCReclaimReturnedObject:
1571  case CK_ARCExtendBlockObject:
1572  case CK_ZeroToOCLEvent:
1573  assert(!getType()->isBooleanType() && "unheralded conversion to bool");
1574  goto CheckNoBasePath;
1575 
1576  case CK_Dependent:
1577  case CK_LValueToRValue:
1578  case CK_NoOp:
1579  case CK_AtomicToNonAtomic:
1580  case CK_NonAtomicToAtomic:
1581  case CK_PointerToBoolean:
1582  case CK_IntegralToBoolean:
1583  case CK_FloatingToBoolean:
1584  case CK_MemberPointerToBoolean:
1585  case CK_FloatingComplexToBoolean:
1586  case CK_IntegralComplexToBoolean:
1587  case CK_LValueBitCast: // -> bool&
1588  case CK_UserDefinedConversion: // operator bool()
1589  case CK_BuiltinFnToFnPtr:
1590  CheckNoBasePath:
1591  assert(path_empty() && "Cast kind should not have a base path!");
1592  break;
1593  }
1594  return true;
1595 }
1596 
1597 const char *CastExpr::getCastKindName() const {
1598  switch (getCastKind()) {
1599 #define CAST_OPERATION(Name) case CK_##Name: return #Name;
1600 #include "clang/AST/OperationKinds.def"
1601  }
1602  llvm_unreachable("Unhandled cast kind!");
1603 }
1604 
1606  Expr *SubExpr = nullptr;
1607  CastExpr *E = this;
1608  do {
1609  SubExpr = E->getSubExpr();
1610 
1611  // Skip through reference binding to temporary.
1612  if (MaterializeTemporaryExpr *Materialize
1613  = dyn_cast<MaterializeTemporaryExpr>(SubExpr))
1614  SubExpr = Materialize->GetTemporaryExpr();
1615 
1616  // Skip any temporary bindings; they're implicit.
1617  if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
1618  SubExpr = Binder->getSubExpr();
1619 
1620  // Conversions by constructor and conversion functions have a
1621  // subexpression describing the call; strip it off.
1622  if (E->getCastKind() == CK_ConstructorConversion)
1623  SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0);
1624  else if (E->getCastKind() == CK_UserDefinedConversion) {
1625  assert((isa<CXXMemberCallExpr>(SubExpr) ||
1626  isa<BlockExpr>(SubExpr)) &&
1627  "Unexpected SubExpr for CK_UserDefinedConversion.");
1628  if (isa<CXXMemberCallExpr>(SubExpr))
1629  SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument();
1630  }
1631 
1632  // If the subexpression we're left with is an implicit cast, look
1633  // through that, too.
1634  } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr)));
1635 
1636  return SubExpr;
1637 }
1638 
1639 CXXBaseSpecifier **CastExpr::path_buffer() {
1640  switch (getStmtClass()) {
1641 #define ABSTRACT_STMT(x)
1642 #define CASTEXPR(Type, Base) \
1643  case Stmt::Type##Class: \
1644  return static_cast<Type *>(this)->getTrailingObjects<CXXBaseSpecifier *>();
1645 #define STMT(Type, Base)
1646 #include "clang/AST/StmtNodes.inc"
1647  default:
1648  llvm_unreachable("non-cast expressions not possible here");
1649  }
1650 }
1651 
1653  CastKind Kind, Expr *Operand,
1654  const CXXCastPath *BasePath,
1655  ExprValueKind VK) {
1656  unsigned PathSize = (BasePath ? BasePath->size() : 0);
1657  void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
1658  ImplicitCastExpr *E =
1659  new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK);
1660  if (PathSize)
1661  std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
1662  E->getTrailingObjects<CXXBaseSpecifier *>());
1663  return E;
1664 }
1665 
1667  unsigned PathSize) {
1668  void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
1669  return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize);
1670 }
1671 
1672 
1674  ExprValueKind VK, CastKind K, Expr *Op,
1675  const CXXCastPath *BasePath,
1676  TypeSourceInfo *WrittenTy,
1678  unsigned PathSize = (BasePath ? BasePath->size() : 0);
1679  void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
1680  CStyleCastExpr *E =
1681  new (Buffer) CStyleCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, R);
1682  if (PathSize)
1683  std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
1684  E->getTrailingObjects<CXXBaseSpecifier *>());
1685  return E;
1686 }
1687 
1689  unsigned PathSize) {
1690  void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
1691  return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize);
1692 }
1693 
1694 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
1695 /// corresponds to, e.g. "<<=".
1697  switch (Op) {
1698 #define BINARY_OPERATION(Name, Spelling) case BO_##Name: return Spelling;
1699 #include "clang/AST/OperationKinds.def"
1700  }
1701  llvm_unreachable("Invalid OpCode!");
1702 }
1703 
1706  switch (OO) {
1707  default: llvm_unreachable("Not an overloadable binary operator");
1708  case OO_Plus: return BO_Add;
1709  case OO_Minus: return BO_Sub;
1710  case OO_Star: return BO_Mul;
1711  case OO_Slash: return BO_Div;
1712  case OO_Percent: return BO_Rem;
1713  case OO_Caret: return BO_Xor;
1714  case OO_Amp: return BO_And;
1715  case OO_Pipe: return BO_Or;
1716  case OO_Equal: return BO_Assign;
1717  case OO_Less: return BO_LT;
1718  case OO_Greater: return BO_GT;
1719  case OO_PlusEqual: return BO_AddAssign;
1720  case OO_MinusEqual: return BO_SubAssign;
1721  case OO_StarEqual: return BO_MulAssign;
1722  case OO_SlashEqual: return BO_DivAssign;
1723  case OO_PercentEqual: return BO_RemAssign;
1724  case OO_CaretEqual: return BO_XorAssign;
1725  case OO_AmpEqual: return BO_AndAssign;
1726  case OO_PipeEqual: return BO_OrAssign;
1727  case OO_LessLess: return BO_Shl;
1728  case OO_GreaterGreater: return BO_Shr;
1729  case OO_LessLessEqual: return BO_ShlAssign;
1730  case OO_GreaterGreaterEqual: return BO_ShrAssign;
1731  case OO_EqualEqual: return BO_EQ;
1732  case OO_ExclaimEqual: return BO_NE;
1733  case OO_LessEqual: return BO_LE;
1734  case OO_GreaterEqual: return BO_GE;
1735  case OO_AmpAmp: return BO_LAnd;
1736  case OO_PipePipe: return BO_LOr;
1737  case OO_Comma: return BO_Comma;
1738  case OO_ArrowStar: return BO_PtrMemI;
1739  }
1740 }
1741 
1743  static const OverloadedOperatorKind OverOps[] = {
1744  /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
1745  OO_Star, OO_Slash, OO_Percent,
1746  OO_Plus, OO_Minus,
1747  OO_LessLess, OO_GreaterGreater,
1748  OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
1749  OO_EqualEqual, OO_ExclaimEqual,
1750  OO_Amp,
1751  OO_Caret,
1752  OO_Pipe,
1753  OO_AmpAmp,
1754  OO_PipePipe,
1755  OO_Equal, OO_StarEqual,
1756  OO_SlashEqual, OO_PercentEqual,
1757  OO_PlusEqual, OO_MinusEqual,
1758  OO_LessLessEqual, OO_GreaterGreaterEqual,
1759  OO_AmpEqual, OO_CaretEqual,
1760  OO_PipeEqual,
1761  OO_Comma
1762  };
1763  return OverOps[Opc];
1764 }
1765 
1767  ArrayRef<Expr*> initExprs, SourceLocation rbraceloc)
1768  : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false,
1769  false, false),
1770  InitExprs(C, initExprs.size()),
1771  LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), AltForm(nullptr, true)
1772 {
1773  sawArrayRangeDesignator(false);
1774  for (unsigned I = 0; I != initExprs.size(); ++I) {
1775  if (initExprs[I]->isTypeDependent())
1776  ExprBits.TypeDependent = true;
1777  if (initExprs[I]->isValueDependent())
1778  ExprBits.ValueDependent = true;
1779  if (initExprs[I]->isInstantiationDependent())
1780  ExprBits.InstantiationDependent = true;
1781  if (initExprs[I]->containsUnexpandedParameterPack())
1782  ExprBits.ContainsUnexpandedParameterPack = true;
1783  }
1784 
1785  InitExprs.insert(C, InitExprs.end(), initExprs.begin(), initExprs.end());
1786 }
1787 
1788 void InitListExpr::reserveInits(const ASTContext &C, unsigned NumInits) {
1789  if (NumInits > InitExprs.size())
1790  InitExprs.reserve(C, NumInits);
1791 }
1792 
1793 void InitListExpr::resizeInits(const ASTContext &C, unsigned NumInits) {
1794  InitExprs.resize(C, NumInits, nullptr);
1795 }
1796 
1797 Expr *InitListExpr::updateInit(const ASTContext &C, unsigned Init, Expr *expr) {
1798  if (Init >= InitExprs.size()) {
1799  InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, nullptr);
1800  setInit(Init, expr);
1801  return nullptr;
1802  }
1803 
1804  Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
1805  setInit(Init, expr);
1806  return Result;
1807 }
1808 
1810  assert(!hasArrayFiller() && "Filler already set!");
1811  ArrayFillerOrUnionFieldInit = filler;
1812  // Fill out any "holes" in the array due to designated initializers.
1813  Expr **inits = getInits();
1814  for (unsigned i = 0, e = getNumInits(); i != e; ++i)
1815  if (inits[i] == nullptr)
1816  inits[i] = filler;
1817 }
1818 
1820  if (getNumInits() != 1)
1821  return false;
1822  const ArrayType *AT = getType()->getAsArrayTypeUnsafe();
1823  if (!AT || !AT->getElementType()->isIntegerType())
1824  return false;
1825  // It is possible for getInit() to return null.
1826  const Expr *Init = getInit(0);
1827  if (!Init)
1828  return false;
1829  Init = Init->IgnoreParens();
1830  return isa<StringLiteral>(Init) || isa<ObjCEncodeExpr>(Init);
1831 }
1832 
1834  if (InitListExpr *SyntacticForm = getSyntacticForm())
1835  return SyntacticForm->getLocStart();
1836  SourceLocation Beg = LBraceLoc;
1837  if (Beg.isInvalid()) {
1838  // Find the first non-null initializer.
1839  for (InitExprsTy::const_iterator I = InitExprs.begin(),
1840  E = InitExprs.end();
1841  I != E; ++I) {
1842  if (Stmt *S = *I) {
1843  Beg = S->getLocStart();
1844  break;
1845  }
1846  }
1847  }
1848  return Beg;
1849 }
1850 
1852  if (InitListExpr *SyntacticForm = getSyntacticForm())
1853  return SyntacticForm->getLocEnd();
1854  SourceLocation End = RBraceLoc;
1855  if (End.isInvalid()) {
1856  // Find the first non-null initializer from the end.
1857  for (InitExprsTy::const_reverse_iterator I = InitExprs.rbegin(),
1858  E = InitExprs.rend();
1859  I != E; ++I) {
1860  if (Stmt *S = *I) {
1861  End = S->getLocEnd();
1862  break;
1863  }
1864  }
1865  }
1866  return End;
1867 }
1868 
1869 /// getFunctionType - Return the underlying function type for this block.
1870 ///
1872  // The block pointer is never sugared, but the function type might be.
1873  return cast<BlockPointerType>(getType())
1874  ->getPointeeType()->castAs<FunctionProtoType>();
1875 }
1876 
1878  return TheBlock->getCaretLocation();
1879 }
1880 const Stmt *BlockExpr::getBody() const {
1881  return TheBlock->getBody();
1882 }
1884  return TheBlock->getBody();
1885 }
1886 
1887 
1888 //===----------------------------------------------------------------------===//
1889 // Generic Expression Routines
1890 //===----------------------------------------------------------------------===//
1891 
1892 /// isUnusedResultAWarning - Return true if this immediate expression should
1893 /// be warned about if the result is unused. If so, fill in Loc and Ranges
1894 /// with location to warn on and the source range[s] to report with the
1895 /// warning.
1897  SourceRange &R1, SourceRange &R2,
1898  ASTContext &Ctx) const {
1899  // Don't warn if the expr is type dependent. The type could end up
1900  // instantiating to void.
1901  if (isTypeDependent())
1902  return false;
1903 
1904  switch (getStmtClass()) {
1905  default:
1906  if (getType()->isVoidType())
1907  return false;
1908  WarnE = this;
1909  Loc = getExprLoc();
1910  R1 = getSourceRange();
1911  return true;
1912  case ParenExprClass:
1913  return cast<ParenExpr>(this)->getSubExpr()->
1914  isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1915  case GenericSelectionExprClass:
1916  return cast<GenericSelectionExpr>(this)->getResultExpr()->
1917  isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1918  case ChooseExprClass:
1919  return cast<ChooseExpr>(this)->getChosenSubExpr()->
1920  isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1921  case UnaryOperatorClass: {
1922  const UnaryOperator *UO = cast<UnaryOperator>(this);
1923 
1924  switch (UO->getOpcode()) {
1925  case UO_Plus:
1926  case UO_Minus:
1927  case UO_AddrOf:
1928  case UO_Not:
1929  case UO_LNot:
1930  case UO_Deref:
1931  break;
1932  case UO_Coawait:
1933  // This is just the 'operator co_await' call inside the guts of a
1934  // dependent co_await call.
1935  case UO_PostInc:
1936  case UO_PostDec:
1937  case UO_PreInc:
1938  case UO_PreDec: // ++/--
1939  return false; // Not a warning.
1940  case UO_Real:
1941  case UO_Imag:
1942  // accessing a piece of a volatile complex is a side-effect.
1943  if (Ctx.getCanonicalType(UO->getSubExpr()->getType())
1944  .isVolatileQualified())
1945  return false;
1946  break;
1947  case UO_Extension:
1948  return UO->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1949  }
1950  WarnE = this;
1951  Loc = UO->getOperatorLoc();
1952  R1 = UO->getSubExpr()->getSourceRange();
1953  return true;
1954  }
1955  case BinaryOperatorClass: {
1956  const BinaryOperator *BO = cast<BinaryOperator>(this);
1957  switch (BO->getOpcode()) {
1958  default:
1959  break;
1960  // Consider the RHS of comma for side effects. LHS was checked by
1961  // Sema::CheckCommaOperands.
1962  case BO_Comma:
1963  // ((foo = <blah>), 0) is an idiom for hiding the result (and
1964  // lvalue-ness) of an assignment written in a macro.
1965  if (IntegerLiteral *IE =
1966  dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens()))
1967  if (IE->getValue() == 0)
1968  return false;
1969  return BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1970  // Consider '||', '&&' to have side effects if the LHS or RHS does.
1971  case BO_LAnd:
1972  case BO_LOr:
1973  if (!BO->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) ||
1974  !BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx))
1975  return false;
1976  break;
1977  }
1978  if (BO->isAssignmentOp())
1979  return false;
1980  WarnE = this;
1981  Loc = BO->getOperatorLoc();
1982  R1 = BO->getLHS()->getSourceRange();
1983  R2 = BO->getRHS()->getSourceRange();
1984  return true;
1985  }
1986  case CompoundAssignOperatorClass:
1987  case VAArgExprClass:
1988  case AtomicExprClass:
1989  return false;
1990 
1991  case ConditionalOperatorClass: {
1992  // If only one of the LHS or RHS is a warning, the operator might
1993  // be being used for control flow. Only warn if both the LHS and
1994  // RHS are warnings.
1995  const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
1996  if (!Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx))
1997  return false;
1998  if (!Exp->getLHS())
1999  return true;
2000  return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2001  }
2002 
2003  case MemberExprClass:
2004  WarnE = this;
2005  Loc = cast<MemberExpr>(this)->getMemberLoc();
2006  R1 = SourceRange(Loc, Loc);
2007  R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
2008  return true;
2009 
2010  case ArraySubscriptExprClass:
2011  WarnE = this;
2012  Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
2013  R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
2014  R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
2015  return true;
2016 
2017  case CXXOperatorCallExprClass: {
2018  // Warn about operator ==,!=,<,>,<=, and >= even when user-defined operator
2019  // overloads as there is no reasonable way to define these such that they
2020  // have non-trivial, desirable side-effects. See the -Wunused-comparison
2021  // warning: operators == and != are commonly typo'ed, and so warning on them
2022  // provides additional value as well. If this list is updated,
2023  // DiagnoseUnusedComparison should be as well.
2024  const CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(this);
2025  switch (Op->getOperator()) {
2026  default:
2027  break;
2028  case OO_EqualEqual:
2029  case OO_ExclaimEqual:
2030  case OO_Less:
2031  case OO_Greater:
2032  case OO_GreaterEqual:
2033  case OO_LessEqual:
2034  if (Op->getCallReturnType(Ctx)->isReferenceType() ||
2035  Op->getCallReturnType(Ctx)->isVoidType())
2036  break;
2037  WarnE = this;
2038  Loc = Op->getOperatorLoc();
2039  R1 = Op->getSourceRange();
2040  return true;
2041  }
2042 
2043  // Fallthrough for generic call handling.
2044  }
2045  case CallExprClass:
2046  case CXXMemberCallExprClass:
2047  case UserDefinedLiteralClass: {
2048  // If this is a direct call, get the callee.
2049  const CallExpr *CE = cast<CallExpr>(this);
2050  if (const Decl *FD = CE->getCalleeDecl()) {
2051  const FunctionDecl *Func = dyn_cast<FunctionDecl>(FD);
2052  bool HasWarnUnusedResultAttr = Func ? Func->hasUnusedResultAttr()
2053  : FD->hasAttr<WarnUnusedResultAttr>();
2054 
2055  // If the callee has attribute pure, const, or warn_unused_result, warn
2056  // about it. void foo() { strlen("bar"); } should warn.
2057  //
2058  // Note: If new cases are added here, DiagnoseUnusedExprResult should be
2059  // updated to match for QoI.
2060  if (HasWarnUnusedResultAttr ||
2061  FD->hasAttr<PureAttr>() || FD->hasAttr<ConstAttr>()) {
2062  WarnE = this;
2063  Loc = CE->getCallee()->getLocStart();
2064  R1 = CE->getCallee()->getSourceRange();
2065 
2066  if (unsigned NumArgs = CE->getNumArgs())
2067  R2 = SourceRange(CE->getArg(0)->getLocStart(),
2068  CE->getArg(NumArgs-1)->getLocEnd());
2069  return true;
2070  }
2071  }
2072  return false;
2073  }
2074 
2075  // If we don't know precisely what we're looking at, let's not warn.
2076  case UnresolvedLookupExprClass:
2077  case CXXUnresolvedConstructExprClass:
2078  return false;
2079 
2080  case CXXTemporaryObjectExprClass:
2081  case CXXConstructExprClass: {
2082  if (const CXXRecordDecl *Type = getType()->getAsCXXRecordDecl()) {
2083  if (Type->hasAttr<WarnUnusedAttr>()) {
2084  WarnE = this;
2085  Loc = getLocStart();
2086  R1 = getSourceRange();
2087  return true;
2088  }
2089  }
2090  return false;
2091  }
2092 
2093  case ObjCMessageExprClass: {
2094  const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
2095  if (Ctx.getLangOpts().ObjCAutoRefCount &&
2096  ME->isInstanceMessage() &&
2097  !ME->getType()->isVoidType() &&
2098  ME->getMethodFamily() == OMF_init) {
2099  WarnE = this;
2100  Loc = getExprLoc();
2101  R1 = ME->getSourceRange();
2102  return true;
2103  }
2104 
2105  if (const ObjCMethodDecl *MD = ME->getMethodDecl())
2106  if (MD->hasAttr<WarnUnusedResultAttr>()) {
2107  WarnE = this;
2108  Loc = getExprLoc();
2109  return true;
2110  }
2111 
2112  return false;
2113  }
2114 
2115  case ObjCPropertyRefExprClass:
2116  WarnE = this;
2117  Loc = getExprLoc();
2118  R1 = getSourceRange();
2119  return true;
2120 
2121  case PseudoObjectExprClass: {
2122  const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this);
2123 
2124  // Only complain about things that have the form of a getter.
2125  if (isa<UnaryOperator>(PO->getSyntacticForm()) ||
2126  isa<BinaryOperator>(PO->getSyntacticForm()))
2127  return false;
2128 
2129  WarnE = this;
2130  Loc = getExprLoc();
2131  R1 = getSourceRange();
2132  return true;
2133  }
2134 
2135  case StmtExprClass: {
2136  // Statement exprs don't logically have side effects themselves, but are
2137  // sometimes used in macros in ways that give them a type that is unused.
2138  // For example ({ blah; foo(); }) will end up with a type if foo has a type.
2139  // however, if the result of the stmt expr is dead, we don't want to emit a
2140  // warning.
2141  const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
2142  if (!CS->body_empty()) {
2143  if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
2144  return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2145  if (const LabelStmt *Label = dyn_cast<LabelStmt>(CS->body_back()))
2146  if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt()))
2147  return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2148  }
2149 
2150  if (getType()->isVoidType())
2151  return false;
2152  WarnE = this;
2153  Loc = cast<StmtExpr>(this)->getLParenLoc();
2154  R1 = getSourceRange();
2155  return true;
2156  }
2157  case CXXFunctionalCastExprClass:
2158  case CStyleCastExprClass: {
2159  // Ignore an explicit cast to void unless the operand is a non-trivial
2160  // volatile lvalue.
2161  const CastExpr *CE = cast<CastExpr>(this);
2162  if (CE->getCastKind() == CK_ToVoid) {
2163  if (CE->getSubExpr()->isGLValue() &&
2164  CE->getSubExpr()->getType().isVolatileQualified()) {
2165  const DeclRefExpr *DRE =
2166  dyn_cast<DeclRefExpr>(CE->getSubExpr()->IgnoreParens());
2167  if (!(DRE && isa<VarDecl>(DRE->getDecl()) &&
2168  cast<VarDecl>(DRE->getDecl())->hasLocalStorage())) {
2169  return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc,
2170  R1, R2, Ctx);
2171  }
2172  }
2173  return false;
2174  }
2175 
2176  // If this is a cast to a constructor conversion, check the operand.
2177  // Otherwise, the result of the cast is unused.
2178  if (CE->getCastKind() == CK_ConstructorConversion)
2179  return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2180 
2181  WarnE = this;
2182  if (const CXXFunctionalCastExpr *CXXCE =
2183  dyn_cast<CXXFunctionalCastExpr>(this)) {
2184  Loc = CXXCE->getLocStart();
2185  R1 = CXXCE->getSubExpr()->getSourceRange();
2186  } else {
2187  const CStyleCastExpr *CStyleCE = cast<CStyleCastExpr>(this);
2188  Loc = CStyleCE->getLParenLoc();
2189  R1 = CStyleCE->getSubExpr()->getSourceRange();
2190  }
2191  return true;
2192  }
2193  case ImplicitCastExprClass: {
2194  const CastExpr *ICE = cast<ImplicitCastExpr>(this);
2195 
2196  // lvalue-to-rvalue conversion on a volatile lvalue is a side-effect.
2197  if (ICE->getCastKind() == CK_LValueToRValue &&
2199  return false;
2200 
2201  return ICE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2202  }
2203  case CXXDefaultArgExprClass:
2204  return (cast<CXXDefaultArgExpr>(this)
2205  ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2206  case CXXDefaultInitExprClass:
2207  return (cast<CXXDefaultInitExpr>(this)
2208  ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2209 
2210  case CXXNewExprClass:
2211  // FIXME: In theory, there might be new expressions that don't have side
2212  // effects (e.g. a placement new with an uninitialized POD).
2213  case CXXDeleteExprClass:
2214  return false;
2215  case CXXBindTemporaryExprClass:
2216  return (cast<CXXBindTemporaryExpr>(this)
2217  ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2218  case ExprWithCleanupsClass:
2219  return (cast<ExprWithCleanups>(this)
2220  ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2221  }
2222 }
2223 
2224 /// isOBJCGCCandidate - Check if an expression is objc gc'able.
2225 /// returns true, if it is; false otherwise.
2227  const Expr *E = IgnoreParens();
2228  switch (E->getStmtClass()) {
2229  default:
2230  return false;
2231  case ObjCIvarRefExprClass:
2232  return true;
2233  case Expr::UnaryOperatorClass:
2234  return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2235  case ImplicitCastExprClass:
2236  return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2237  case MaterializeTemporaryExprClass:
2238  return cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr()
2239  ->isOBJCGCCandidate(Ctx);
2240  case CStyleCastExprClass:
2241  return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2242  case DeclRefExprClass: {
2243  const Decl *D = cast<DeclRefExpr>(E)->getDecl();
2244 
2245  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2246  if (VD->hasGlobalStorage())
2247  return true;
2248  QualType T = VD->getType();
2249  // dereferencing to a pointer is always a gc'able candidate,
2250  // unless it is __weak.
2251  return T->isPointerType() &&
2252  (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak);
2253  }
2254  return false;
2255  }
2256  case MemberExprClass: {
2257  const MemberExpr *M = cast<MemberExpr>(E);
2258  return M->getBase()->isOBJCGCCandidate(Ctx);
2259  }
2260  case ArraySubscriptExprClass:
2261  return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx);
2262  }
2263 }
2264 
2266  if (isTypeDependent())
2267  return false;
2268  return ClassifyLValue(Ctx) == Expr::LV_MemberFunction;
2269 }
2270 
2272  assert(expr->hasPlaceholderType(BuiltinType::BoundMember));
2273 
2274  // Bound member expressions are always one of these possibilities:
2275  // x->m x.m x->*y x.*y
2276  // (possibly parenthesized)
2277 
2278  expr = expr->IgnoreParens();
2279  if (const MemberExpr *mem = dyn_cast<MemberExpr>(expr)) {
2280  assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
2281  return mem->getMemberDecl()->getType();
2282  }
2283 
2284  if (const BinaryOperator *op = dyn_cast<BinaryOperator>(expr)) {
2285  QualType type = op->getRHS()->getType()->castAs<MemberPointerType>()
2286  ->getPointeeType();
2287  assert(type->isFunctionType());
2288  return type;
2289  }
2290 
2291  assert(isa<UnresolvedMemberExpr>(expr) || isa<CXXPseudoDestructorExpr>(expr));
2292  return QualType();
2293 }
2294 
2296  Expr* E = this;
2297  while (true) {
2298  if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
2299  E = P->getSubExpr();
2300  continue;
2301  }
2302  if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2303  if (P->getOpcode() == UO_Extension) {
2304  E = P->getSubExpr();
2305  continue;
2306  }
2307  }
2308  if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2309  if (!P->isResultDependent()) {
2310  E = P->getResultExpr();
2311  continue;
2312  }
2313  }
2314  if (ChooseExpr* P = dyn_cast<ChooseExpr>(E)) {
2315  if (!P->isConditionDependent()) {
2316  E = P->getChosenSubExpr();
2317  continue;
2318  }
2319  }
2320  return E;
2321  }
2322 }
2323 
2324 /// IgnoreParenCasts - Ignore parentheses and casts. Strip off any ParenExpr
2325 /// or CastExprs or ImplicitCastExprs, returning their operand.
2327  Expr *E = this;
2328  while (true) {
2329  E = E->IgnoreParens();
2330  if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2331  E = P->getSubExpr();
2332  continue;
2333  }
2334  if (MaterializeTemporaryExpr *Materialize
2335  = dyn_cast<MaterializeTemporaryExpr>(E)) {
2336  E = Materialize->GetTemporaryExpr();
2337  continue;
2338  }
2340  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2341  E = NTTP->getReplacement();
2342  continue;
2343  }
2344  return E;
2345  }
2346 }
2347 
2349  Expr *E = this;
2350  while (true) {
2351  if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2352  E = P->getSubExpr();
2353  continue;
2354  }
2355  if (MaterializeTemporaryExpr *Materialize
2356  = dyn_cast<MaterializeTemporaryExpr>(E)) {
2357  E = Materialize->GetTemporaryExpr();
2358  continue;
2359  }
2361  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2362  E = NTTP->getReplacement();
2363  continue;
2364  }
2365  return E;
2366  }
2367 }
2368 
2369 /// IgnoreParenLValueCasts - Ignore parentheses and lvalue-to-rvalue
2370 /// casts. This is intended purely as a temporary workaround for code
2371 /// that hasn't yet been rewritten to do the right thing about those
2372 /// casts, and may disappear along with the last internal use.
2374  Expr *E = this;
2375  while (true) {
2376  E = E->IgnoreParens();
2377  if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2378  if (P->getCastKind() == CK_LValueToRValue) {
2379  E = P->getSubExpr();
2380  continue;
2381  }
2382  } else if (MaterializeTemporaryExpr *Materialize
2383  = dyn_cast<MaterializeTemporaryExpr>(E)) {
2384  E = Materialize->GetTemporaryExpr();
2385  continue;
2386  } else if (SubstNonTypeTemplateParmExpr *NTTP
2387  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2388  E = NTTP->getReplacement();
2389  continue;
2390  }
2391  break;
2392  }
2393  return E;
2394 }
2395 
2397  Expr *E = this;
2398  while (true) {
2399  E = E->IgnoreParens();
2400  if (CastExpr *CE = dyn_cast<CastExpr>(E)) {
2401  if (CE->getCastKind() == CK_DerivedToBase ||
2402  CE->getCastKind() == CK_UncheckedDerivedToBase ||
2403  CE->getCastKind() == CK_NoOp) {
2404  E = CE->getSubExpr();
2405  continue;
2406  }
2407  }
2408 
2409  return E;
2410  }
2411 }
2412 
2414  Expr *E = this;
2415  while (true) {
2416  E = E->IgnoreParens();
2417  if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) {
2418  E = P->getSubExpr();
2419  continue;
2420  }
2421  if (MaterializeTemporaryExpr *Materialize
2422  = dyn_cast<MaterializeTemporaryExpr>(E)) {
2423  E = Materialize->GetTemporaryExpr();
2424  continue;
2425  }
2427  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2428  E = NTTP->getReplacement();
2429  continue;
2430  }
2431  return E;
2432  }
2433 }
2434 
2436  if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(this)) {
2437  if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl()))
2438  return MCE->getImplicitObjectArgument();
2439  }
2440  return this;
2441 }
2442 
2443 /// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
2444 /// value (including ptr->int casts of the same size). Strip off any
2445 /// ParenExpr or CastExprs, returning their operand.
2447  Expr *E = this;
2448  while (true) {
2449  E = E->IgnoreParens();
2450 
2451  if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2452  // We ignore integer <-> casts that are of the same width, ptr<->ptr and
2453  // ptr<->int casts of the same width. We also ignore all identity casts.
2454  Expr *SE = P->getSubExpr();
2455 
2456  if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
2457  E = SE;
2458  continue;
2459  }
2460 
2461  if ((E->getType()->isPointerType() ||
2462  E->getType()->isIntegralType(Ctx)) &&
2463  (SE->getType()->isPointerType() ||
2464  SE->getType()->isIntegralType(Ctx)) &&
2465  Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
2466  E = SE;
2467  continue;
2468  }
2469  }
2470 
2472  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2473  E = NTTP->getReplacement();
2474  continue;
2475  }
2476 
2477  return E;
2478  }
2479 }
2480 
2482  const Expr *E = this;
2483  if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
2484  E = M->GetTemporaryExpr();
2485 
2486  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
2487  E = ICE->getSubExprAsWritten();
2488 
2489  return isa<CXXDefaultArgExpr>(E);
2490 }
2491 
2492 /// \brief Skip over any no-op casts and any temporary-binding
2493 /// expressions.
2495  if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
2496  E = M->GetTemporaryExpr();
2497 
2498  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2499  if (ICE->getCastKind() == CK_NoOp)
2500  E = ICE->getSubExpr();
2501  else
2502  break;
2503  }
2504 
2505  while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
2506  E = BE->getSubExpr();
2507 
2508  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2509  if (ICE->getCastKind() == CK_NoOp)
2510  E = ICE->getSubExpr();
2511  else
2512  break;
2513  }
2514 
2515  return E->IgnoreParens();
2516 }
2517 
2518 /// isTemporaryObject - Determines if this expression produces a
2519 /// temporary of the given class type.
2520 bool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const {
2521  if (!C.hasSameUnqualifiedType(getType(), C.getTypeDeclType(TempTy)))
2522  return false;
2523 
2525 
2526  // Temporaries are by definition pr-values of class type.
2527  if (!E->Classify(C).isPRValue()) {
2528  // In this context, property reference is a message call and is pr-value.
2529  if (!isa<ObjCPropertyRefExpr>(E))
2530  return false;
2531  }
2532 
2533  // Black-list a few cases which yield pr-values of class type that don't
2534  // refer to temporaries of that type:
2535 
2536  // - implicit derived-to-base conversions
2537  if (isa<ImplicitCastExpr>(E)) {
2538  switch (cast<ImplicitCastExpr>(E)->getCastKind()) {
2539  case CK_DerivedToBase:
2540  case CK_UncheckedDerivedToBase:
2541  return false;
2542  default:
2543  break;
2544  }
2545  }
2546 
2547  // - member expressions (all)
2548  if (isa<MemberExpr>(E))
2549  return false;
2550 
2551  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E))
2552  if (BO->isPtrMemOp())
2553  return false;
2554 
2555  // - opaque values (all)
2556  if (isa<OpaqueValueExpr>(E))
2557  return false;
2558 
2559  return true;
2560 }
2561 
2563  const Expr *E = this;
2564 
2565  // Strip away parentheses and casts we don't care about.
2566  while (true) {
2567  if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) {
2568  E = Paren->getSubExpr();
2569  continue;
2570  }
2571 
2572  if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2573  if (ICE->getCastKind() == CK_NoOp ||
2574  ICE->getCastKind() == CK_LValueToRValue ||
2575  ICE->getCastKind() == CK_DerivedToBase ||
2576  ICE->getCastKind() == CK_UncheckedDerivedToBase) {
2577  E = ICE->getSubExpr();
2578  continue;
2579  }
2580  }
2581 
2582  if (const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
2583  if (UnOp->getOpcode() == UO_Extension) {
2584  E = UnOp->getSubExpr();
2585  continue;
2586  }
2587  }
2588 
2589  if (const MaterializeTemporaryExpr *M
2590  = dyn_cast<MaterializeTemporaryExpr>(E)) {
2591  E = M->GetTemporaryExpr();
2592  continue;
2593  }
2594 
2595  break;
2596  }
2597 
2598  if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
2599  return This->isImplicit();
2600 
2601  return false;
2602 }
2603 
2604 /// hasAnyTypeDependentArguments - Determines if any of the expressions
2605 /// in Exprs is type-dependent.
2607  for (unsigned I = 0; I < Exprs.size(); ++I)
2608  if (Exprs[I]->isTypeDependent())
2609  return true;
2610 
2611  return false;
2612 }
2613 
2614 bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef,
2615  const Expr **Culprit) const {
2616  // This function is attempting whether an expression is an initializer
2617  // which can be evaluated at compile-time. It very closely parallels
2618  // ConstExprEmitter in CGExprConstant.cpp; if they don't match, it
2619  // will lead to unexpected results. Like ConstExprEmitter, it falls back
2620  // to isEvaluatable most of the time.
2621  //
2622  // If we ever capture reference-binding directly in the AST, we can
2623  // kill the second parameter.
2624 
2625  if (IsForRef) {
2627  if (EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects)
2628  return true;
2629  if (Culprit)
2630  *Culprit = this;
2631  return false;
2632  }
2633 
2634  switch (getStmtClass()) {
2635  default: break;
2636  case StringLiteralClass:
2637  case ObjCEncodeExprClass:
2638  return true;
2639  case CXXTemporaryObjectExprClass:
2640  case CXXConstructExprClass: {
2641  const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
2642 
2643  if (CE->getConstructor()->isTrivial() &&
2645  // Trivial default constructor
2646  if (!CE->getNumArgs()) return true;
2647 
2648  // Trivial copy constructor
2649  assert(CE->getNumArgs() == 1 && "trivial ctor with > 1 argument");
2650  return CE->getArg(0)->isConstantInitializer(Ctx, false, Culprit);
2651  }
2652 
2653  break;
2654  }
2655  case CompoundLiteralExprClass: {
2656  // This handles gcc's extension that allows global initializers like
2657  // "struct x {int x;} x = (struct x) {};".
2658  // FIXME: This accepts other cases it shouldn't!
2659  const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
2660  return Exp->isConstantInitializer(Ctx, false, Culprit);
2661  }
2662  case DesignatedInitUpdateExprClass: {
2663  const DesignatedInitUpdateExpr *DIUE = cast<DesignatedInitUpdateExpr>(this);
2664  return DIUE->getBase()->isConstantInitializer(Ctx, false, Culprit) &&
2665  DIUE->getUpdater()->isConstantInitializer(Ctx, false, Culprit);
2666  }
2667  case InitListExprClass: {
2668  const InitListExpr *ILE = cast<InitListExpr>(this);
2669  if (ILE->getType()->isArrayType()) {
2670  unsigned numInits = ILE->getNumInits();
2671  for (unsigned i = 0; i < numInits; i++) {
2672  if (!ILE->getInit(i)->isConstantInitializer(Ctx, false, Culprit))
2673  return false;
2674  }
2675  return true;
2676  }
2677 
2678  if (ILE->getType()->isRecordType()) {
2679  unsigned ElementNo = 0;
2680  RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl();
2681  for (const auto *Field : RD->fields()) {
2682  // If this is a union, skip all the fields that aren't being initialized.
2683  if (RD->isUnion() && ILE->getInitializedFieldInUnion() != Field)
2684  continue;
2685 
2686  // Don't emit anonymous bitfields, they just affect layout.
2687  if (Field->isUnnamedBitfield())
2688  continue;
2689 
2690  if (ElementNo < ILE->getNumInits()) {
2691  const Expr *Elt = ILE->getInit(ElementNo++);
2692  if (Field->isBitField()) {
2693  // Bitfields have to evaluate to an integer.
2694  llvm::APSInt ResultTmp;
2695  if (!Elt->EvaluateAsInt(ResultTmp, Ctx)) {
2696  if (Culprit)
2697  *Culprit = Elt;
2698  return false;
2699  }
2700  } else {
2701  bool RefType = Field->getType()->isReferenceType();
2702  if (!Elt->isConstantInitializer(Ctx, RefType, Culprit))
2703  return false;
2704  }
2705  }
2706  }
2707  return true;
2708  }
2709 
2710  break;
2711  }
2712  case ImplicitValueInitExprClass:
2713  case NoInitExprClass:
2714  return true;
2715  case ParenExprClass:
2716  return cast<ParenExpr>(this)->getSubExpr()
2717  ->isConstantInitializer(Ctx, IsForRef, Culprit);
2718  case GenericSelectionExprClass:
2719  return cast<GenericSelectionExpr>(this)->getResultExpr()
2720  ->isConstantInitializer(Ctx, IsForRef, Culprit);
2721  case ChooseExprClass:
2722  if (cast<ChooseExpr>(this)->isConditionDependent()) {
2723  if (Culprit)
2724  *Culprit = this;
2725  return false;
2726  }
2727  return cast<ChooseExpr>(this)->getChosenSubExpr()
2728  ->isConstantInitializer(Ctx, IsForRef, Culprit);
2729  case UnaryOperatorClass: {
2730  const UnaryOperator* Exp = cast<UnaryOperator>(this);
2731  if (Exp->getOpcode() == UO_Extension)
2732  return Exp->getSubExpr()->isConstantInitializer(Ctx, false, Culprit);
2733  break;
2734  }
2735  case CXXFunctionalCastExprClass:
2736  case CXXStaticCastExprClass:
2737  case ImplicitCastExprClass:
2738  case CStyleCastExprClass:
2739  case ObjCBridgedCastExprClass:
2740  case CXXDynamicCastExprClass:
2741  case CXXReinterpretCastExprClass:
2742  case CXXConstCastExprClass: {
2743  const CastExpr *CE = cast<CastExpr>(this);
2744 
2745  // Handle misc casts we want to ignore.
2746  if (CE->getCastKind() == CK_NoOp ||
2747  CE->getCastKind() == CK_LValueToRValue ||
2748  CE->getCastKind() == CK_ToUnion ||
2749  CE->getCastKind() == CK_ConstructorConversion ||
2750  CE->getCastKind() == CK_NonAtomicToAtomic ||
2751  CE->getCastKind() == CK_AtomicToNonAtomic)
2752  return CE->getSubExpr()->isConstantInitializer(Ctx, false, Culprit);
2753 
2754  break;
2755  }
2756  case MaterializeTemporaryExprClass:
2757  return cast<MaterializeTemporaryExpr>(this)->GetTemporaryExpr()
2758  ->isConstantInitializer(Ctx, false, Culprit);
2759 
2760  case SubstNonTypeTemplateParmExprClass:
2761  return cast<SubstNonTypeTemplateParmExpr>(this)->getReplacement()
2762  ->isConstantInitializer(Ctx, false, Culprit);
2763  case CXXDefaultArgExprClass:
2764  return cast<CXXDefaultArgExpr>(this)->getExpr()
2765  ->isConstantInitializer(Ctx, false, Culprit);
2766  case CXXDefaultInitExprClass:
2767  return cast<CXXDefaultInitExpr>(this)->getExpr()
2768  ->isConstantInitializer(Ctx, false, Culprit);
2769  }
2770  // Allow certain forms of UB in constant initializers: signed integer
2771  // overflow and floating-point division by zero. We'll give a warning on
2772  // these, but they're common enough that we have to accept them.
2774  return true;
2775  if (Culprit)
2776  *Culprit = this;
2777  return false;
2778 }
2779 
2780 namespace {
2781  /// \brief Look for any side effects within a Stmt.
2782  class SideEffectFinder : public ConstEvaluatedExprVisitor<SideEffectFinder> {
2784  const bool IncludePossibleEffects;
2785  bool HasSideEffects;
2786 
2787  public:
2788  explicit SideEffectFinder(const ASTContext &Context, bool IncludePossible)
2789  : Inherited(Context),
2790  IncludePossibleEffects(IncludePossible), HasSideEffects(false) { }
2791 
2792  bool hasSideEffects() const { return HasSideEffects; }
2793 
2794  void VisitExpr(const Expr *E) {
2795  if (!HasSideEffects &&
2796  E->HasSideEffects(Context, IncludePossibleEffects))
2797  HasSideEffects = true;
2798  }
2799  };
2800 }
2801 
2803  bool IncludePossibleEffects) const {
2804  // In circumstances where we care about definite side effects instead of
2805  // potential side effects, we want to ignore expressions that are part of a
2806  // macro expansion as a potential side effect.
2807  if (!IncludePossibleEffects && getExprLoc().isMacroID())
2808  return false;
2809 
2811  return IncludePossibleEffects;
2812 
2813  switch (getStmtClass()) {
2814  case NoStmtClass:
2815  #define ABSTRACT_STMT(Type)
2816  #define STMT(Type, Base) case Type##Class:
2817  #define EXPR(Type, Base)
2818  #include "clang/AST/StmtNodes.inc"
2819  llvm_unreachable("unexpected Expr kind");
2820 
2821  case DependentScopeDeclRefExprClass:
2822  case CXXUnresolvedConstructExprClass:
2823  case CXXDependentScopeMemberExprClass:
2824  case UnresolvedLookupExprClass:
2825  case UnresolvedMemberExprClass:
2826  case PackExpansionExprClass:
2827  case SubstNonTypeTemplateParmPackExprClass:
2828  case FunctionParmPackExprClass:
2829  case TypoExprClass:
2830  case CXXFoldExprClass:
2831  llvm_unreachable("shouldn't see dependent / unresolved nodes here");
2832 
2833  case DeclRefExprClass:
2834  case ObjCIvarRefExprClass:
2835  case PredefinedExprClass:
2836  case IntegerLiteralClass:
2837  case FloatingLiteralClass:
2838  case ImaginaryLiteralClass:
2839  case StringLiteralClass:
2840  case CharacterLiteralClass:
2841  case OffsetOfExprClass:
2842  case ImplicitValueInitExprClass:
2843  case UnaryExprOrTypeTraitExprClass:
2844  case AddrLabelExprClass:
2845  case GNUNullExprClass:
2846  case NoInitExprClass:
2847  case CXXBoolLiteralExprClass:
2848  case CXXNullPtrLiteralExprClass:
2849  case CXXThisExprClass:
2850  case CXXScalarValueInitExprClass:
2851  case TypeTraitExprClass:
2852  case ArrayTypeTraitExprClass:
2853  case ExpressionTraitExprClass:
2854  case CXXNoexceptExprClass:
2855  case SizeOfPackExprClass:
2856  case ObjCStringLiteralClass:
2857  case ObjCEncodeExprClass:
2858  case ObjCBoolLiteralExprClass:
2859  case ObjCAvailabilityCheckExprClass:
2860  case CXXUuidofExprClass:
2861  case OpaqueValueExprClass:
2862  // These never have a side-effect.
2863  return false;
2864 
2865  case CallExprClass:
2866  case CXXOperatorCallExprClass:
2867  case CXXMemberCallExprClass:
2868  case CUDAKernelCallExprClass:
2869  case UserDefinedLiteralClass: {
2870  // We don't know a call definitely has side effects, except for calls
2871  // to pure/const functions that definitely don't.
2872  // If the call itself is considered side-effect free, check the operands.
2873  const Decl *FD = cast<CallExpr>(this)->getCalleeDecl();
2874  bool IsPure = FD && (FD->hasAttr<ConstAttr>() || FD->hasAttr<PureAttr>());
2875  if (IsPure || !IncludePossibleEffects)
2876  break;
2877  return true;
2878  }
2879 
2880  case BlockExprClass:
2881  case CXXBindTemporaryExprClass:
2882  if (!IncludePossibleEffects)
2883  break;
2884  return true;
2885 
2886  case MSPropertyRefExprClass:
2887  case MSPropertySubscriptExprClass:
2888  case CompoundAssignOperatorClass:
2889  case VAArgExprClass:
2890  case AtomicExprClass:
2891  case CXXThrowExprClass:
2892  case CXXNewExprClass:
2893  case CXXDeleteExprClass:
2894  case CoawaitExprClass:
2895  case CoyieldExprClass:
2896  // These always have a side-effect.
2897  return true;
2898 
2899  case StmtExprClass: {
2900  // StmtExprs have a side-effect if any substatement does.
2901  SideEffectFinder Finder(Ctx, IncludePossibleEffects);
2902  Finder.Visit(cast<StmtExpr>(this)->getSubStmt());
2903  return Finder.hasSideEffects();
2904  }
2905 
2906  case ExprWithCleanupsClass:
2907  if (IncludePossibleEffects)
2908  if (cast<ExprWithCleanups>(this)->cleanupsHaveSideEffects())
2909  return true;
2910  break;
2911 
2912  case ParenExprClass:
2913  case ArraySubscriptExprClass:
2914  case OMPArraySectionExprClass:
2915  case MemberExprClass:
2916  case ConditionalOperatorClass:
2917  case BinaryConditionalOperatorClass:
2918  case CompoundLiteralExprClass:
2919  case ExtVectorElementExprClass:
2920  case DesignatedInitExprClass:
2921  case DesignatedInitUpdateExprClass:
2922  case ParenListExprClass:
2923  case CXXPseudoDestructorExprClass:
2924  case CXXStdInitializerListExprClass:
2925  case SubstNonTypeTemplateParmExprClass:
2926  case MaterializeTemporaryExprClass:
2927  case ShuffleVectorExprClass:
2928  case ConvertVectorExprClass:
2929  case AsTypeExprClass:
2930  // These have a side-effect if any subexpression does.
2931  break;
2932 
2933  case UnaryOperatorClass:
2934  if (cast<UnaryOperator>(this)->isIncrementDecrementOp())
2935  return true;
2936  break;
2937 
2938  case BinaryOperatorClass:
2939  if (cast<BinaryOperator>(this)->isAssignmentOp())
2940  return true;
2941  break;
2942 
2943  case InitListExprClass:
2944  // FIXME: The children for an InitListExpr doesn't include the array filler.
2945  if (const Expr *E = cast<InitListExpr>(this)->getArrayFiller())
2946  if (E->HasSideEffects(Ctx, IncludePossibleEffects))
2947  return true;
2948  break;
2949 
2950  case GenericSelectionExprClass:
2951  return cast<GenericSelectionExpr>(this)->getResultExpr()->
2952  HasSideEffects(Ctx, IncludePossibleEffects);
2953 
2954  case ChooseExprClass:
2955  return cast<ChooseExpr>(this)->getChosenSubExpr()->HasSideEffects(
2956  Ctx, IncludePossibleEffects);
2957 
2958  case CXXDefaultArgExprClass:
2959  return cast<CXXDefaultArgExpr>(this)->getExpr()->HasSideEffects(
2960  Ctx, IncludePossibleEffects);
2961 
2962  case CXXDefaultInitExprClass: {
2963  const FieldDecl *FD = cast<CXXDefaultInitExpr>(this)->getField();
2964  if (const Expr *E = FD->getInClassInitializer())
2965  return E->HasSideEffects(Ctx, IncludePossibleEffects);
2966  // If we've not yet parsed the initializer, assume it has side-effects.
2967  return true;
2968  }
2969 
2970  case CXXDynamicCastExprClass: {
2971  // A dynamic_cast expression has side-effects if it can throw.
2972  const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(this);
2973  if (DCE->getTypeAsWritten()->isReferenceType() &&
2974  DCE->getCastKind() == CK_Dynamic)
2975  return true;
2976  } // Fall through.
2977  case ImplicitCastExprClass:
2978  case CStyleCastExprClass:
2979  case CXXStaticCastExprClass:
2980  case CXXReinterpretCastExprClass:
2981  case CXXConstCastExprClass:
2982  case CXXFunctionalCastExprClass: {
2983  // While volatile reads are side-effecting in both C and C++, we treat them
2984  // as having possible (not definite) side-effects. This allows idiomatic
2985  // code to behave without warning, such as sizeof(*v) for a volatile-
2986  // qualified pointer.
2987  if (!IncludePossibleEffects)
2988  break;
2989 
2990  const CastExpr *CE = cast<CastExpr>(this);
2991  if (CE->getCastKind() == CK_LValueToRValue &&
2993  return true;
2994  break;
2995  }
2996 
2997  case CXXTypeidExprClass:
2998  // typeid might throw if its subexpression is potentially-evaluated, so has
2999  // side-effects in that case whether or not its subexpression does.
3000  return cast<CXXTypeidExpr>(this)->isPotentiallyEvaluated();
3001 
3002  case CXXConstructExprClass:
3003  case CXXTemporaryObjectExprClass: {
3004  const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
3005  if (!CE->getConstructor()->isTrivial() && IncludePossibleEffects)
3006  return true;
3007  // A trivial constructor does not add any side-effects of its own. Just look
3008  // at its arguments.
3009  break;
3010  }
3011 
3012  case CXXInheritedCtorInitExprClass: {
3013  const auto *ICIE = cast<CXXInheritedCtorInitExpr>(this);
3014  if (!ICIE->getConstructor()->isTrivial() && IncludePossibleEffects)
3015  return true;
3016  break;
3017  }
3018 
3019  case LambdaExprClass: {
3020  const LambdaExpr *LE = cast<LambdaExpr>(this);
3022  E = LE->capture_end(); I != E; ++I)
3023  if (I->getCaptureKind() == LCK_ByCopy)
3024  // FIXME: Only has a side-effect if the variable is volatile or if
3025  // the copy would invoke a non-trivial copy constructor.
3026  return true;
3027  return false;
3028  }
3029 
3030  case PseudoObjectExprClass: {
3031  // Only look for side-effects in the semantic form, and look past
3032  // OpaqueValueExpr bindings in that form.
3033  const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this);
3035  E = PO->semantics_end();
3036  I != E; ++I) {
3037  const Expr *Subexpr = *I;
3038  if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Subexpr))
3039  Subexpr = OVE->getSourceExpr();
3040  if (Subexpr->HasSideEffects(Ctx, IncludePossibleEffects))
3041  return true;
3042  }
3043  return false;
3044  }
3045 
3046  case ObjCBoxedExprClass:
3047  case ObjCArrayLiteralClass:
3048  case ObjCDictionaryLiteralClass:
3049  case ObjCSelectorExprClass:
3050  case ObjCProtocolExprClass:
3051  case ObjCIsaExprClass:
3052  case ObjCIndirectCopyRestoreExprClass:
3053  case ObjCSubscriptRefExprClass:
3054  case ObjCBridgedCastExprClass:
3055  case ObjCMessageExprClass:
3056  case ObjCPropertyRefExprClass:
3057  // FIXME: Classify these cases better.
3058  if (IncludePossibleEffects)
3059  return true;
3060  break;
3061  }
3062 
3063  // Recurse to children.
3064  for (const Stmt *SubStmt : children())
3065  if (SubStmt &&
3066  cast<Expr>(SubStmt)->HasSideEffects(Ctx, IncludePossibleEffects))
3067  return true;
3068 
3069  return false;
3070 }
3071 
3072 namespace {
3073  /// \brief Look for a call to a non-trivial function within an expression.
3074  class NonTrivialCallFinder : public ConstEvaluatedExprVisitor<NonTrivialCallFinder>
3075  {
3077 
3078  bool NonTrivial;
3079 
3080  public:
3081  explicit NonTrivialCallFinder(const ASTContext &Context)
3082  : Inherited(Context), NonTrivial(false) { }
3083 
3084  bool hasNonTrivialCall() const { return NonTrivial; }
3085 
3086  void VisitCallExpr(const CallExpr *E) {
3087  if (const CXXMethodDecl *Method
3088  = dyn_cast_or_null<const CXXMethodDecl>(E->getCalleeDecl())) {
3089  if (Method->isTrivial()) {
3090  // Recurse to children of the call.
3091  Inherited::VisitStmt(E);
3092  return;
3093  }
3094  }
3095 
3096  NonTrivial = true;
3097  }
3098 
3099  void VisitCXXConstructExpr(const CXXConstructExpr *E) {
3100  if (E->getConstructor()->isTrivial()) {
3101  // Recurse to children of the call.
3102  Inherited::VisitStmt(E);
3103  return;
3104  }
3105 
3106  NonTrivial = true;
3107  }
3108 
3109  void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E) {
3110  if (E->getTemporary()->getDestructor()->isTrivial()) {
3111  Inherited::VisitStmt(E);
3112  return;
3113  }
3114 
3115  NonTrivial = true;
3116  }
3117  };
3118 }
3119 
3120 bool Expr::hasNonTrivialCall(const ASTContext &Ctx) const {
3121  NonTrivialCallFinder Finder(Ctx);
3122  Finder.Visit(this);
3123  return Finder.hasNonTrivialCall();
3124 }
3125 
3126 /// isNullPointerConstant - C99 6.3.2.3p3 - Return whether this is a null
3127 /// pointer constant or not, as well as the specific kind of constant detected.
3128 /// Null pointer constants can be integer constant expressions with the
3129 /// value zero, casts of zero to void*, nullptr (C++0X), or __null
3130 /// (a GNU extension).
3134  if (isValueDependent() &&
3135  (!Ctx.getLangOpts().CPlusPlus11 || Ctx.getLangOpts().MSVCCompat)) {
3136  switch (NPC) {
3138  llvm_unreachable("Unexpected value dependent expression!");
3140  if (isTypeDependent() || getType()->isIntegralType(Ctx))
3141  return NPCK_ZeroExpression;
3142  else
3143  return NPCK_NotNull;
3144 
3146  return NPCK_NotNull;
3147  }
3148  }
3149 
3150  // Strip off a cast to void*, if it exists. Except in C++.
3151  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
3152  if (!Ctx.getLangOpts().CPlusPlus) {
3153  // Check that it is a cast to void*.
3154  if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
3155  QualType Pointee = PT->getPointeeType();
3156  Qualifiers Q = Pointee.getQualifiers();
3157  // In OpenCL v2.0 generic address space acts as a placeholder
3158  // and should be ignored.
3159  bool IsASValid = true;
3160  if (Ctx.getLangOpts().OpenCLVersion >= 200) {
3161  if (Pointee.getAddressSpace() == LangAS::opencl_generic)
3162  Q.removeAddressSpace();
3163  else
3164  IsASValid = false;
3165  }
3166 
3167  if (IsASValid && !Q.hasQualifiers() &&
3168  Pointee->isVoidType() && // to void*
3169  CE->getSubExpr()->getType()->isIntegerType()) // from int.
3170  return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3171  }
3172  }
3173  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
3174  // Ignore the ImplicitCastExpr type entirely.
3175  return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3176  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
3177  // Accept ((void*)0) as a null pointer constant, as many other
3178  // implementations do.
3179  return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3180  } else if (const GenericSelectionExpr *GE =
3181  dyn_cast<GenericSelectionExpr>(this)) {
3182  if (GE->isResultDependent())
3183  return NPCK_NotNull;
3184  return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);
3185  } else if (const ChooseExpr *CE = dyn_cast<ChooseExpr>(this)) {
3186  if (CE->isConditionDependent())
3187  return NPCK_NotNull;
3188  return CE->getChosenSubExpr()->isNullPointerConstant(Ctx, NPC);
3189  } else if (const CXXDefaultArgExpr *DefaultArg
3190  = dyn_cast<CXXDefaultArgExpr>(this)) {
3191  // See through default argument expressions.
3192  return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
3193  } else if (const CXXDefaultInitExpr *DefaultInit
3194  = dyn_cast<CXXDefaultInitExpr>(this)) {
3195  // See through default initializer expressions.
3196  return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC);
3197  } else if (isa<GNUNullExpr>(this)) {
3198  // The GNU __null extension is always a null pointer constant.
3199  return NPCK_GNUNull;
3200  } else if (const MaterializeTemporaryExpr *M
3201  = dyn_cast<MaterializeTemporaryExpr>(this)) {
3202  return M->GetTemporaryExpr()->isNullPointerConstant(Ctx, NPC);
3203  } else if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(this)) {
3204  if (const Expr *Source = OVE->getSourceExpr())
3205  return Source->isNullPointerConstant(Ctx, NPC);
3206  }
3207 
3208  // C++11 nullptr_t is always a null pointer constant.
3209  if (getType()->isNullPtrType())
3210  return NPCK_CXX11_nullptr;
3211 
3212  if (const RecordType *UT = getType()->getAsUnionType())
3213  if (!Ctx.getLangOpts().CPlusPlus11 &&
3214  UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
3215  if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){
3216  const Expr *InitExpr = CLE->getInitializer();
3217  if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
3218  return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC);
3219  }
3220  // This expression must be an integer type.
3221  if (!getType()->isIntegerType() ||
3222  (Ctx.getLangOpts().CPlusPlus && getType()->isEnumeralType()))
3223  return NPCK_NotNull;
3224 
3225  if (Ctx.getLangOpts().CPlusPlus11) {
3226  // C++11 [conv.ptr]p1: A null pointer constant is an integer literal with
3227  // value zero or a prvalue of type std::nullptr_t.
3228  // Microsoft mode permits C++98 rules reflecting MSVC behavior.
3229  const IntegerLiteral *Lit = dyn_cast<IntegerLiteral>(this);
3230  if (Lit && !Lit->getValue())
3231  return NPCK_ZeroLiteral;
3232  else if (!Ctx.getLangOpts().MSVCCompat || !isCXX98IntegralConstantExpr(Ctx))
3233  return NPCK_NotNull;
3234  } else {
3235  // If we have an integer constant expression, we need to *evaluate* it and
3236  // test for the value 0.
3237  if (!isIntegerConstantExpr(Ctx))
3238  return NPCK_NotNull;
3239  }
3240 
3241  if (EvaluateKnownConstInt(Ctx) != 0)
3242  return NPCK_NotNull;
3243 
3244  if (isa<IntegerLiteral>(this))
3245  return NPCK_ZeroLiteral;
3246  return NPCK_ZeroExpression;
3247 }
3248 
3249 /// \brief If this expression is an l-value for an Objective C
3250 /// property, find the underlying property reference expression.
3252  const Expr *E = this;
3253  while (true) {
3254  assert((E->getValueKind() == VK_LValue &&
3255  E->getObjectKind() == OK_ObjCProperty) &&
3256  "expression is not a property reference");
3257  E = E->IgnoreParenCasts();
3258  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
3259  if (BO->getOpcode() == BO_Comma) {
3260  E = BO->getRHS();
3261  continue;
3262  }
3263  }
3264 
3265  break;
3266  }
3267 
3268  return cast<ObjCPropertyRefExpr>(E);
3269 }
3270 
3271 bool Expr::isObjCSelfExpr() const {
3272  const Expr *E = IgnoreParenImpCasts();
3273 
3274  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
3275  if (!DRE)
3276  return false;
3277 
3278  const ImplicitParamDecl *Param = dyn_cast<ImplicitParamDecl>(DRE->getDecl());
3279  if (!Param)
3280  return false;
3281 
3282  const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(Param->getDeclContext());
3283  if (!M)
3284  return false;
3285 
3286  return M->getSelfDecl() == Param;
3287 }
3288 
3290  Expr *E = this->IgnoreParens();
3291 
3292  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
3293  if (ICE->getCastKind() == CK_LValueToRValue ||
3294  (ICE->getValueKind() != VK_RValue && ICE->getCastKind() == CK_NoOp))
3295  E = ICE->getSubExpr()->IgnoreParens();
3296  else
3297  break;
3298  }
3299 
3300  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
3301  if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
3302  if (Field->isBitField())
3303  return Field;
3304 
3305  if (ObjCIvarRefExpr *IvarRef = dyn_cast<ObjCIvarRefExpr>(E))
3306  if (FieldDecl *Ivar = dyn_cast<FieldDecl>(IvarRef->getDecl()))
3307  if (Ivar->isBitField())
3308  return Ivar;
3309 
3310  if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E))
3311  if (FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
3312  if (Field->isBitField())
3313  return Field;
3314 
3315  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) {
3316  if (BinOp->isAssignmentOp() && BinOp->getLHS())
3317  return BinOp->getLHS()->getSourceBitField();
3318 
3319  if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS())
3320  return BinOp->getRHS()->getSourceBitField();
3321  }
3322 
3323  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E))
3324  if (UnOp->isPrefix() && UnOp->isIncrementDecrementOp())
3325  return UnOp->getSubExpr()->getSourceBitField();
3326 
3327  return nullptr;
3328 }
3329 
3331  const Expr *E = this->IgnoreParens();
3332 
3333  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
3334  if (ICE->getValueKind() != VK_RValue &&
3335  ICE->getCastKind() == CK_NoOp)
3336  E = ICE->getSubExpr()->IgnoreParens();
3337  else
3338  break;
3339  }
3340 
3341  if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
3342  return ASE->getBase()->getType()->isVectorType();
3343 
3344  if (isa<ExtVectorElementExpr>(E))
3345  return true;
3346 
3347  return false;
3348 }
3349 
3351  const Expr *E = this->IgnoreParenImpCasts();
3352 
3353  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
3354  if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
3355  if (VD->getStorageClass() == SC_Register &&
3356  VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
3357  return true;
3358 
3359  return false;
3360 }
3361 
3362 /// isArrow - Return true if the base expression is a pointer to vector,
3363 /// return false if the base expression is a vector.
3365  return getBase()->getType()->isPointerType();
3366 }
3367 
3369  if (const VectorType *VT = getType()->getAs<VectorType>())
3370  return VT->getNumElements();
3371  return 1;
3372 }
3373 
3374 /// containsDuplicateElements - Return true if any element access is repeated.
3376  // FIXME: Refactor this code to an accessor on the AST node which returns the
3377  // "type" of component access, and share with code below and in Sema.
3378  StringRef Comp = Accessor->getName();
3379 
3380  // Halving swizzles do not contain duplicate elements.
3381  if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")
3382  return false;
3383 
3384  // Advance past s-char prefix on hex swizzles.
3385  if (Comp[0] == 's' || Comp[0] == 'S')
3386  Comp = Comp.substr(1);
3387 
3388  for (unsigned i = 0, e = Comp.size(); i != e; ++i)
3389  if (Comp.substr(i + 1).find(Comp[i]) != StringRef::npos)
3390  return true;
3391 
3392  return false;
3393 }
3394 
3395 /// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
3397  SmallVectorImpl<uint32_t> &Elts) const {
3398  StringRef Comp = Accessor->getName();
3399  if (Comp[0] == 's' || Comp[0] == 'S')
3400  Comp = Comp.substr(1);
3401 
3402  bool isHi = Comp == "hi";
3403  bool isLo = Comp == "lo";
3404  bool isEven = Comp == "even";
3405  bool isOdd = Comp == "odd";
3406 
3407  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
3408  uint64_t Index;
3409 
3410  if (isHi)
3411  Index = e + i;
3412  else if (isLo)
3413  Index = i;
3414  else if (isEven)
3415  Index = 2 * i;
3416  else if (isOdd)
3417  Index = 2 * i + 1;
3418  else
3419  Index = ExtVectorType::getAccessorIdx(Comp[i]);
3420 
3421  Elts.push_back(Index);
3422  }
3423 }
3424 
3426  QualType Type, SourceLocation BLoc,
3427  SourceLocation RP)
3428  : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary,
3429  Type->isDependentType(), Type->isDependentType(),
3430  Type->isInstantiationDependentType(),
3431  Type->containsUnexpandedParameterPack()),
3432  BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size())
3433 {
3434  SubExprs = new (C) Stmt*[args.size()];
3435  for (unsigned i = 0; i != args.size(); i++) {
3436  if (args[i]->isTypeDependent())
3437  ExprBits.TypeDependent = true;
3438  if (args[i]->isValueDependent())
3439  ExprBits.ValueDependent = true;
3440  if (args[i]->isInstantiationDependent())
3441  ExprBits.InstantiationDependent = true;
3442  if (args[i]->containsUnexpandedParameterPack())
3443  ExprBits.ContainsUnexpandedParameterPack = true;
3444 
3445  SubExprs[i] = args[i];
3446  }
3447 }
3448 
3450  if (SubExprs) C.Deallocate(SubExprs);
3451 
3452  this->NumExprs = Exprs.size();
3453  SubExprs = new (C) Stmt*[NumExprs];
3454  memcpy(SubExprs, Exprs.data(), sizeof(Expr *) * Exprs.size());
3455 }
3456 
3458  SourceLocation GenericLoc, Expr *ControllingExpr,
3459  ArrayRef<TypeSourceInfo*> AssocTypes,
3460  ArrayRef<Expr*> AssocExprs,
3461  SourceLocation DefaultLoc,
3462  SourceLocation RParenLoc,
3463  bool ContainsUnexpandedParameterPack,
3464  unsigned ResultIndex)
3465  : Expr(GenericSelectionExprClass,
3466  AssocExprs[ResultIndex]->getType(),
3467  AssocExprs[ResultIndex]->getValueKind(),
3468  AssocExprs[ResultIndex]->getObjectKind(),
3469  AssocExprs[ResultIndex]->isTypeDependent(),
3470  AssocExprs[ResultIndex]->isValueDependent(),
3471  AssocExprs[ResultIndex]->isInstantiationDependent(),
3472  ContainsUnexpandedParameterPack),
3473  AssocTypes(new (Context) TypeSourceInfo*[AssocTypes.size()]),
3474  SubExprs(new (Context) Stmt*[END_EXPR+AssocExprs.size()]),
3475  NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
3476  GenericLoc(GenericLoc), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
3477  SubExprs[CONTROLLING] = ControllingExpr;
3478  assert(AssocTypes.size() == AssocExprs.size());
3479  std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes);
3480  std::copy(AssocExprs.begin(), AssocExprs.end(), SubExprs+END_EXPR);
3481 }
3482 
3484  SourceLocation GenericLoc, Expr *ControllingExpr,
3485  ArrayRef<TypeSourceInfo*> AssocTypes,
3486  ArrayRef<Expr*> AssocExprs,
3487  SourceLocation DefaultLoc,
3488  SourceLocation RParenLoc,
3489  bool ContainsUnexpandedParameterPack)
3490  : Expr(GenericSelectionExprClass,
3491  Context.DependentTy,
3492  VK_RValue,
3493  OK_Ordinary,
3494  /*isTypeDependent=*/true,
3495  /*isValueDependent=*/true,
3496  /*isInstantiationDependent=*/true,
3497  ContainsUnexpandedParameterPack),
3498  AssocTypes(new (Context) TypeSourceInfo*[AssocTypes.size()]),
3499  SubExprs(new (Context) Stmt*[END_EXPR+AssocExprs.size()]),
3500  NumAssocs(AssocExprs.size()), ResultIndex(-1U), GenericLoc(GenericLoc),
3501  DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
3502  SubExprs[CONTROLLING] = ControllingExpr;
3503  assert(AssocTypes.size() == AssocExprs.size());
3504  std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes);
3505  std::copy(AssocExprs.begin(), AssocExprs.end(), SubExprs+END_EXPR);
3506 }
3507 
3508 //===----------------------------------------------------------------------===//
3509 // DesignatedInitExpr
3510 //===----------------------------------------------------------------------===//
3511 
3513  assert(Kind == FieldDesignator && "Only valid on a field designator");
3514  if (Field.NameOrField & 0x01)
3515  return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
3516  else
3517  return getField()->getIdentifier();
3518 }
3519 
3520 DesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty,
3521  llvm::ArrayRef<Designator> Designators,
3522  SourceLocation EqualOrColonLoc,
3523  bool GNUSyntax,
3524  ArrayRef<Expr*> IndexExprs,
3525  Expr *Init)
3526  : Expr(DesignatedInitExprClass, Ty,
3527  Init->getValueKind(), Init->getObjectKind(),
3528  Init->isTypeDependent(), Init->isValueDependent(),
3529  Init->isInstantiationDependent(),
3531  EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
3532  NumDesignators(Designators.size()), NumSubExprs(IndexExprs.size() + 1) {
3533  this->Designators = new (C) Designator[NumDesignators];
3534 
3535  // Record the initializer itself.
3536  child_iterator Child = child_begin();
3537  *Child++ = Init;
3538 
3539  // Copy the designators and their subexpressions, computing
3540  // value-dependence along the way.
3541  unsigned IndexIdx = 0;
3542  for (unsigned I = 0; I != NumDesignators; ++I) {
3543  this->Designators[I] = Designators[I];
3544 
3545  if (this->Designators[I].isArrayDesignator()) {
3546  // Compute type- and value-dependence.
3547  Expr *Index = IndexExprs[IndexIdx];
3548  if (Index->isTypeDependent() || Index->isValueDependent())
3549  ExprBits.TypeDependent = ExprBits.ValueDependent = true;
3550  if (Index->isInstantiationDependent())
3551  ExprBits.InstantiationDependent = true;
3552  // Propagate unexpanded parameter packs.
3554  ExprBits.ContainsUnexpandedParameterPack = true;
3555 
3556  // Copy the index expressions into permanent storage.
3557  *Child++ = IndexExprs[IndexIdx++];
3558  } else if (this->Designators[I].isArrayRangeDesignator()) {
3559  // Compute type- and value-dependence.
3560  Expr *Start = IndexExprs[IndexIdx];
3561  Expr *End = IndexExprs[IndexIdx + 1];
3562  if (Start->isTypeDependent() || Start->isValueDependent() ||
3563  End->isTypeDependent() || End->isValueDependent()) {
3564  ExprBits.TypeDependent = ExprBits.ValueDependent = true;
3565  ExprBits.InstantiationDependent = true;
3566  } else if (Start->isInstantiationDependent() ||
3567  End->isInstantiationDependent()) {
3568  ExprBits.InstantiationDependent = true;
3569  }
3570 
3571  // Propagate unexpanded parameter packs.
3572  if (Start->containsUnexpandedParameterPack() ||
3574  ExprBits.ContainsUnexpandedParameterPack = true;
3575 
3576  // Copy the start/end expressions into permanent storage.
3577  *Child++ = IndexExprs[IndexIdx++];
3578  *Child++ = IndexExprs[IndexIdx++];
3579  }
3580  }
3581 
3582  assert(IndexIdx == IndexExprs.size() && "Wrong number of index expressions");
3583 }
3584 
3587  llvm::ArrayRef<Designator> Designators,
3588  ArrayRef<Expr*> IndexExprs,
3589  SourceLocation ColonOrEqualLoc,
3590  bool UsesColonSyntax, Expr *Init) {
3591  void *Mem = C.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),
3592  llvm::alignOf<DesignatedInitExpr>());
3593  return new (Mem) DesignatedInitExpr(C, C.VoidTy, Designators,
3594  ColonOrEqualLoc, UsesColonSyntax,
3595  IndexExprs, Init);
3596 }
3597 
3599  unsigned NumIndexExprs) {
3600  void *Mem = C.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),
3601  llvm::alignOf<DesignatedInitExpr>());
3602  return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
3603 }
3604 
3606  const Designator *Desigs,
3607  unsigned NumDesigs) {
3608  Designators = new (C) Designator[NumDesigs];
3609  NumDesignators = NumDesigs;
3610  for (unsigned I = 0; I != NumDesigs; ++I)
3611  Designators[I] = Desigs[I];
3612 }
3613 
3615  DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this);
3616  if (size() == 1)
3617  return DIE->getDesignator(0)->getSourceRange();
3618  return SourceRange(DIE->getDesignator(0)->getLocStart(),
3619  DIE->getDesignator(size()-1)->getLocEnd());
3620 }
3621 
3623  SourceLocation StartLoc;
3624  auto *DIE = const_cast<DesignatedInitExpr *>(this);
3625  Designator &First = *DIE->getDesignator(0);
3626  if (First.isFieldDesignator()) {
3627  if (GNUSyntax)
3629  else
3631  } else
3632  StartLoc =
3634  return StartLoc;
3635 }
3636 
3638  return getInit()->getLocEnd();
3639 }
3640 
3642  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
3643  return getSubExpr(D.ArrayOrRange.Index + 1);
3644 }
3645 
3647  assert(D.Kind == Designator::ArrayRangeDesignator &&
3648  "Requires array range designator");
3649  return getSubExpr(D.ArrayOrRange.Index + 1);
3650 }
3651 
3653  assert(D.Kind == Designator::ArrayRangeDesignator &&
3654  "Requires array range designator");
3655  return getSubExpr(D.ArrayOrRange.Index + 2);
3656 }
3657 
3658 /// \brief Replaces the designator at index @p Idx with the series
3659 /// of designators in [First, Last).
3661  const Designator *First,
3662  const Designator *Last) {
3663  unsigned NumNewDesignators = Last - First;
3664  if (NumNewDesignators == 0) {
3665  std::copy_backward(Designators + Idx + 1,
3666  Designators + NumDesignators,
3667  Designators + Idx);
3668  --NumNewDesignators;
3669  return;
3670  } else if (NumNewDesignators == 1) {
3671  Designators[Idx] = *First;
3672  return;
3673  }
3674 
3675  Designator *NewDesignators
3676  = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
3677  std::copy(Designators, Designators + Idx, NewDesignators);
3678  std::copy(First, Last, NewDesignators + Idx);
3679  std::copy(Designators + Idx + 1, Designators + NumDesignators,
3680  NewDesignators + Idx + NumNewDesignators);
3681  Designators = NewDesignators;
3682  NumDesignators = NumDesignators - 1 + NumNewDesignators;
3683 }
3684 
3686  SourceLocation lBraceLoc, Expr *baseExpr, SourceLocation rBraceLoc)
3687  : Expr(DesignatedInitUpdateExprClass, baseExpr->getType(), VK_RValue,
3689  BaseAndUpdaterExprs[0] = baseExpr;
3690 
3691  InitListExpr *ILE = new (C) InitListExpr(C, lBraceLoc, None, rBraceLoc);
3692  ILE->setType(baseExpr->getType());
3693  BaseAndUpdaterExprs[1] = ILE;
3694 }
3695 
3697  return getBase()->getLocStart();
3698 }
3699 
3701  return getBase()->getLocEnd();
3702 }
3703 
3705  ArrayRef<Expr*> exprs,
3706  SourceLocation rparenloc)
3707  : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary,
3708  false, false, false, false),
3709  NumExprs(exprs.size()), LParenLoc(lparenloc), RParenLoc(rparenloc) {
3710  Exprs = new (C) Stmt*[exprs.size()];
3711  for (unsigned i = 0; i != exprs.size(); ++i) {
3712  if (exprs[i]->isTypeDependent())
3713  ExprBits.TypeDependent = true;
3714  if (exprs[i]->isValueDependent())
3715  ExprBits.ValueDependent = true;
3716  if (exprs[i]->isInstantiationDependent())
3717  ExprBits.InstantiationDependent = true;
3718  if (exprs[i]->containsUnexpandedParameterPack())
3719  ExprBits.ContainsUnexpandedParameterPack = true;
3720 
3721  Exprs[i] = exprs[i];
3722  }
3723 }
3724 
3726  if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e))
3727  e = ewc->getSubExpr();
3728  if (const MaterializeTemporaryExpr *m = dyn_cast<MaterializeTemporaryExpr>(e))
3729  e = m->GetTemporaryExpr();
3730  e = cast<CXXConstructExpr>(e)->getArg(0);
3731  while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
3732  e = ice->getSubExpr();
3733  return cast<OpaqueValueExpr>(e);
3734 }
3735 
3737  EmptyShell sh,
3738  unsigned numSemanticExprs) {
3739  void *buffer =
3740  Context.Allocate(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),
3741  llvm::alignOf<PseudoObjectExpr>());
3742  return new(buffer) PseudoObjectExpr(sh, numSemanticExprs);
3743 }
3744 
3745 PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs)
3746  : Expr(PseudoObjectExprClass, shell) {
3747  PseudoObjectExprBits.NumSubExprs = numSemanticExprs + 1;
3748 }
3749 
3751  ArrayRef<Expr*> semantics,
3752  unsigned resultIndex) {
3753  assert(syntax && "no syntactic expression!");
3754  assert(semantics.size() && "no semantic expressions!");
3755 
3756  QualType type;
3757  ExprValueKind VK;
3758  if (resultIndex == NoResult) {
3759  type = C.VoidTy;
3760  VK = VK_RValue;
3761  } else {
3762  assert(resultIndex < semantics.size());
3763  type = semantics[resultIndex]->getType();
3764  VK = semantics[resultIndex]->getValueKind();
3765  assert(semantics[resultIndex]->getObjectKind() == OK_Ordinary);
3766  }
3767 
3768  void *buffer = C.Allocate(totalSizeToAlloc<Expr *>(semantics.size() + 1),
3769  llvm::alignOf<PseudoObjectExpr>());
3770  return new(buffer) PseudoObjectExpr(type, VK, syntax, semantics,
3771  resultIndex);
3772 }
3773 
3774 PseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK,
3775  Expr *syntax, ArrayRef<Expr*> semantics,
3776  unsigned resultIndex)
3777  : Expr(PseudoObjectExprClass, type, VK, OK_Ordinary,
3778  /*filled in at end of ctor*/ false, false, false, false) {
3779  PseudoObjectExprBits.NumSubExprs = semantics.size() + 1;
3780  PseudoObjectExprBits.ResultIndex = resultIndex + 1;
3781 
3782  for (unsigned i = 0, e = semantics.size() + 1; i != e; ++i) {
3783  Expr *E = (i == 0 ? syntax : semantics[i-1]);
3784  getSubExprsBuffer()[i] = E;
3785 
3786  if (E->isTypeDependent())
3787  ExprBits.TypeDependent = true;
3788  if (E->isValueDependent())
3789  ExprBits.ValueDependent = true;
3791  ExprBits.InstantiationDependent = true;
3793  ExprBits.ContainsUnexpandedParameterPack = true;
3794 
3795  if (isa<OpaqueValueExpr>(E))
3796  assert(cast<OpaqueValueExpr>(E)->getSourceExpr() != nullptr &&
3797  "opaque-value semantic expressions for pseudo-object "
3798  "operations must have sources");
3799  }
3800 }
3801 
3802 //===----------------------------------------------------------------------===//
3803 // Child Iterators for iterating over subexpressions/substatements
3804 //===----------------------------------------------------------------------===//
3805 
3806 // UnaryExprOrTypeTraitExpr
3808  // If this is of a type and the type is a VLA type (and not a typedef), the
3809  // size expression of the VLA needs to be treated as an executable expression.
3810  // Why isn't this weirdness documented better in StmtIterator?
3811  if (isArgumentType()) {
3812  if (const VariableArrayType* T = dyn_cast<VariableArrayType>(
3813  getArgumentType().getTypePtr()))
3814  return child_range(child_iterator(T), child_iterator());
3815  return child_range(child_iterator(), child_iterator());
3816  }
3817  return child_range(&Argument.Ex, &Argument.Ex + 1);
3818 }
3819 
3821  QualType t, AtomicOp op, SourceLocation RP)
3822  : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary,
3823  false, false, false, false),
3824  NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op)
3825 {
3826  assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions");
3827  for (unsigned i = 0; i != args.size(); i++) {
3828  if (args[i]->isTypeDependent())
3829  ExprBits.TypeDependent = true;
3830  if (args[i]->isValueDependent())
3831  ExprBits.ValueDependent = true;
3832  if (args[i]->isInstantiationDependent())
3833  ExprBits.InstantiationDependent = true;
3834  if (args[i]->containsUnexpandedParameterPack())
3835  ExprBits.ContainsUnexpandedParameterPack = true;
3836 
3837  SubExprs[i] = args[i];
3838  }
3839 }
3840 
3842  switch (Op) {
3843  case AO__c11_atomic_init:
3844  case AO__c11_atomic_load:
3845  case AO__atomic_load_n:
3846  return 2;
3847 
3848  case AO__c11_atomic_store:
3849  case AO__c11_atomic_exchange:
3850  case AO__atomic_load:
3851  case AO__atomic_store:
3852  case AO__atomic_store_n:
3853  case AO__atomic_exchange_n:
3854  case AO__c11_atomic_fetch_add:
3855  case AO__c11_atomic_fetch_sub:
3856  case AO__c11_atomic_fetch_and:
3857  case AO__c11_atomic_fetch_or:
3858  case AO__c11_atomic_fetch_xor:
3859  case AO__atomic_fetch_add:
3860  case AO__atomic_fetch_sub:
3861  case AO__atomic_fetch_and:
3862  case AO__atomic_fetch_or:
3863  case AO__atomic_fetch_xor:
3864  case AO__atomic_fetch_nand:
3865  case AO__atomic_add_fetch:
3866  case AO__atomic_sub_fetch:
3867  case AO__atomic_and_fetch:
3868  case AO__atomic_or_fetch:
3869  case AO__atomic_xor_fetch:
3870  case AO__atomic_nand_fetch:
3871  return 3;
3872 
3873  case AO__atomic_exchange:
3874  return 4;
3875 
3876  case AO__c11_atomic_compare_exchange_strong:
3877  case AO__c11_atomic_compare_exchange_weak:
3878  return 5;
3879 
3880  case AO__atomic_compare_exchange:
3881  case AO__atomic_compare_exchange_n:
3882  return 6;
3883  }
3884  llvm_unreachable("unknown atomic op");
3885 }
3886 
3888  unsigned ArraySectionCount = 0;
3889  while (auto *OASE = dyn_cast<OMPArraySectionExpr>(Base->IgnoreParens())) {
3890  Base = OASE->getBase();
3891  ++ArraySectionCount;
3892  }
3893  while (auto *ASE =
3894  dyn_cast<ArraySubscriptExpr>(Base->IgnoreParenImpCasts())) {
3895  Base = ASE->getBase();
3896  ++ArraySectionCount;
3897  }
3898  Base = Base->IgnoreParenImpCasts();
3899  auto OriginalTy = Base->getType();
3900  if (auto *DRE = dyn_cast<DeclRefExpr>(Base))
3901  if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
3902  OriginalTy = PVD->getOriginalType().getNonReferenceType();
3903 
3904  for (unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {
3905  if (OriginalTy->isAnyPointerType())
3906  OriginalTy = OriginalTy->getPointeeType();
3907  else {
3908  assert (OriginalTy->isArrayType());
3909  OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
3910  }
3911  }
3912  return OriginalTy;
3913 }
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:539
GenericSelectionExpr(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo * > AssocTypes, ArrayRef< Expr * > AssocExprs, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
Definition: Expr.cpp:3457
LValueClassification ClassifyLValue(ASTContext &Ctx) const
Reasons why an expression might not be an l-value.
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:52
unsigned getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5375
Represents a single C99 designator.
Definition: Expr.h:4028
void setValueDependent(bool VD)
Set whether this expression is value-dependent or not.
Definition: Expr.h:150
Defines the clang::ASTContext interface.
unsigned getNumInits() const
Definition: Expr.h:3776
bool containsDuplicateElements() const
containsDuplicateElements - Return true if any element access is repeated.
Definition: Expr.cpp:3375
static std::string ComputeName(IdentType IT, const Decl *CurrentDecl)
Definition: Expr.cpp:472
CastKind getCastKind() const
Definition: Expr.h:2680
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:408
IdentifierInfo * getFieldName() const
For a field or identifier offsetof node, returns the name of the field.
Definition: Expr.cpp:1356
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1561
Stmt * body_back()
Definition: Stmt.h:585
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
Definition: ASTMatchers.h:1367
static void computeDeclRefDependence(const ASTContext &Ctx, NamedDecl *D, QualType T, bool &TypeDependent, bool &ValueDependent, bool &InstantiationDependent)
Compute the type-, value-, and instantiation-dependence of a declaration reference based on the decla...
Definition: Expr.cpp:213
BlockDecl * TheBlock
Definition: Expr.h:4569
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:237
Expr * getSyntacticForm()
Return the syntactic form of this expression, i.e.
Definition: Expr.h:4723
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens...
Definition: Lexer.h:46
void setArrayFiller(Expr *filler)
Definition: Expr.cpp:1809
Complete object ctor.
Definition: ABI.h:26
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2179
A (possibly-)qualified type.
Definition: Type.h:598
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:212
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2217
static StringLiteral * CreateEmpty(const ASTContext &C, unsigned NumStrs)
Construct an empty string literal.
Definition: Expr.cpp:851
ObjCMethodFamily getMethodFamily() const
Definition: ExprObjC.h:1270
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1269
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c.h:53
DeclarationNameInfo getMemberNameInfo() const
Retrieve the member declaration name info.
Definition: Expr.h:2503
unsigned FieldLoc
The location of the field name in the designated initializer.
Definition: Expr.h:4005
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:232
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.h:4135
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:1780
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
DesignatedInitUpdateExpr(const ASTContext &C, SourceLocation lBraceLoc, Expr *baseExprs, SourceLocation rBraceLoc)
Definition: Expr.cpp:3685
SourceLocation getEndLoc() const
getEndLoc - Retrieve the location of the last token.
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2879
bool isArgumentType() const
Definition: Expr.h:2010
unsigned getChar16Width() const
getChar16Width/Align - Return the size of 'char16_t' for this target, in bits.
Expr * getInit() const
Retrieve the initializer value.
Definition: Expr.h:4184
unsigned getIntWidth(QualType T) const
bool isArrow() const
isArrow - Return true if the base expression is a pointer to vector, return false if the base express...
Definition: Expr.cpp:3364
Defines the SourceManager interface.
reverse_iterator rbegin()
Definition: ASTVector.h:98
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
Definition: Expr.h:463
bool isRecordType() const
Definition: Type.h:5539
void setSemantics(const llvm::fltSemantics &Sem)
Set the APFloat semantics this literal uses.
Definition: Expr.cpp:774
unsigned size() const
Returns the number of designators in this initializer.
Definition: Expr.h:4153
AccessSpecifier getAccess() const
void setType(QualType t)
Definition: Expr.h:127
Defines the C++ template declaration subclasses.
StringRef P
iterator insert(const ASTContext &C, iterator I, const T &Elt)
Definition: ASTVector.h:216
bool isEnumeralType() const
Definition: Type.h:5542
bool hasUnusedResultAttr() const
Returns true if this function or its return type has the warn_unused_result attribute.
Definition: Decl.h:2059
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1619
const char * getCastKindName() const
Definition: Expr.cpp:1597
The base class of the type hierarchy.
Definition: Type.h:1281
std::unique_ptr< llvm::MemoryBuffer > Buffer
InitListExpr * getSyntacticForm() const
Definition: Expr.h:3882
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2456
void getEncodedElementAccess(SmallVectorImpl< uint32_t > &Elts) const
getEncodedElementAccess - Encode the elements accessed into an llvm aggregate Constant of ConstantInt...
Definition: Expr.cpp:3396
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1162
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:101
bool isBooleanType() const
Definition: Type.h:5743
A container of type source information.
Definition: Decl.h:62
SourceLocation getOperatorLoc() const
Definition: Expr.h:2937
static StringLiteral * Create(const ASTContext &C, StringRef Str, StringKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumStrs)
This is the "fully general" constructor that allows representation of strings formed from multiple co...
Definition: Expr.cpp:826
StreamedQualTypeHelper stream(const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
Definition: Type.h:979
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
Definition: DeclTemplate.h:216
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:26
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2187
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Definition: Expr.cpp:2802
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:3962
Expr * getInClassInitializer() const
getInClassInitializer - Get the C++11 in-class initializer for this member, or null if one has not be...
Definition: Decl.h:2416
capture_iterator capture_begin() const
Retrieve an iterator pointing to the first lambda capture.
Definition: ExprCXX.cpp:944
Expr * ignoreParenBaseCasts() LLVM_READONLY
Ignore parentheses and derived-to-base casts.
Definition: Expr.cpp:2396
bool hasExplicitTemplateArgs() const
Determines whether the member name was followed by an explicit template argument list.
Definition: Expr.h:2470
static OffsetOfExpr * CreateEmpty(const ASTContext &C, unsigned NumComps, unsigned NumExprs)
Definition: Expr.cpp:1323
static const OpaqueValueExpr * findInCopyConstruct(const Expr *expr)
Given an expression which invokes a copy constructor — i.e.
Definition: Expr.cpp:3725
unsigned getChar32Width() const
getChar32Width/Align - Return the size of 'char32_t' for this target, in bits.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:768
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2562
const Expr * getCallee() const
Definition: Expr.h:2188
MangleContext * createMangleContext()
const FunctionProtoType * getFunctionType() const
getFunctionType - Return the underlying function type for this block.
Definition: Expr.cpp:1871
void resizeInits(const ASTContext &Context, unsigned NumInits)
Specify the number of initializers.
Definition: Expr.cpp:1793
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1813
void setInit(unsigned Init, Expr *expr)
Definition: Expr.h:3795
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
PredefinedExpr(SourceLocation L, QualType FNTy, IdentType IT, StringLiteral *SL)
Definition: Expr.cpp:438
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:49
static DeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Construct an empty declaration reference expression.
Definition: Expr.cpp:412
SourceLocation getOperatorLoc() const
Returns the location of the operator symbol in the expression.
Definition: ExprCXX.h:84
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Definition: Type.h:949
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:2936
static bool isAssignmentOp(Opcode Opc)
Definition: Expr.h:3022
bool body_empty() const
Definition: Stmt.h:575
iterator begin() const
Definition: Type.h:4235
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Definition: Expr.cpp:3132
Defines the clang::Expr interface and subclasses for C++ expressions.
Expr * getArrayIndex(const Designator &D) const
Definition: Expr.cpp:3641
bool isVoidType() const
Definition: Type.h:5680
The collection of all-type qualifiers we support.
Definition: Type.h:117
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
Definition: Expr.cpp:3289
static int getAccessorIdx(char c)
Definition: Type.h:2858
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:789
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3253
Represents a C99 designated initializer expression.
Definition: Expr.h:3953
bool refersToGlobalRegisterVar() const
Returns whether this expression refers to a global register variable.
Definition: Expr.cpp:3350
One of these records is kept for each identifier that is lexed.
Represents a class template specialization, which refers to a class template with a given set of temp...
Expr * getSubExpr(unsigned Idx) const
Definition: Expr.h:4198
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
StringRef getBufferData(FileID FID, bool *Invalid=nullptr) const
Return a StringRef to the source buffer data for the specified FileID.
ShuffleVectorExpr(const ASTContext &C, ArrayRef< Expr * > args, QualType Type, SourceLocation BLoc, SourceLocation RP)
Definition: Expr.cpp:3425
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:92
A C++ nested-name-specifier augmented with source location information.
static SourceLocation getFromRawEncoding(unsigned Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
bool isReferenceType() const
Definition: Type.h:5491
bool isImplicitCXXThis() const
Whether this expression is an implicit reference to 'this' in C++.
Definition: Expr.cpp:2562
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2293
void setNumArgs(const ASTContext &C, unsigned NumArgs)
setNumArgs - This changes the number of arguments present in this call.
Definition: Expr.cpp:1216
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
Definition: TypeTraits.h:93
bool isUnevaluated(unsigned ID) const
Returns true if this builtin does not perform the side-effects of its arguments.
Definition: Builtins.h:125
void Deallocate(void *Ptr) const
Definition: ASTContext.h:574
const Stmt * getBody() const
Definition: Expr.cpp:1880
bool isPRValue() const
Definition: Expr.h:351
unsigned getOffsetOfStringByte(const Token &TheTok, unsigned ByteNo) const
getOffsetOfStringByte - This function returns the offset of the specified byte of the string data rep...
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:231
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr)
Definition: Expr.cpp:368
unsigned size() const
Definition: DeclTemplate.h:92
Stmt * getBody() const override
Definition: Decl.h:3536
bool refersToVectorElement() const
Returns whether this expression refers to a vector element.
Definition: Expr.cpp:3330
Expr * getSubExpr()
Definition: Expr.h:2684
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
void setComponent(unsigned Idx, OffsetOfNode ON)
Definition: Expr.h:1928
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1199
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
Definition: Expr.h:2460
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2007
const ObjCPropertyRefExpr * getObjCProperty() const
If this expression is an l-value for an Objective C property, find the underlying property reference ...
Definition: Expr.cpp:3251
SourceLocation getRParenLoc() const
Definition: Expr.h:2284
NestedNameSpecifierLoc QualifierLoc
The nested-name-specifier that qualifies the name, including source-location information.
Definition: Expr.h:2306
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr * > exprs, SourceLocation RParenLoc)
Definition: Expr.cpp:1310
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:105
struct FieldDesignator Field
A field designator, e.g., ".x".
Definition: Expr.h:4038
Expr * getLHS() const
Definition: Expr.h:2943
const Expr *const * const_semantics_iterator
Definition: Expr.h:4746
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:399
Describes an C or C++ initializer list.
Definition: Expr.h:3746
const TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
Definition: DeclTemplate.h:432
uint32_t getCodeUnit(size_t i) const
Definition: Expr.h:1536
void setValue(const ASTContext &C, const llvm::APInt &Val)
Definition: Expr.h:1249
BinaryOperatorKind
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:588
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1240
Base object ctor.
Definition: ABI.h:27
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
Definition: Type.h:5667
const LangOptions & getLangOpts() const
Definition: ASTContext.h:604
CallExpr(const ASTContext &C, StmtClass SC, Expr *fn, ArrayRef< Expr * > preargs, ArrayRef< Expr * > args, QualType t, ExprValueKind VK, SourceLocation rparenloc)
Definition: Expr.cpp:1129
< Capturing the *this object by copy
Definition: Lambda.h:37
unsigned getLength() const
Definition: Expr.h:1547
A convenient class for passing around template argument information.
Definition: TemplateBase.h:523
uint32_t Offset
Definition: CacheTokens.cpp:44
DeclarationNameInfo getNameInfo() const
Definition: Expr.h:1021
QualType getReturnType() const
Definition: Type.h:3009
const TemplateArgument & getArg(unsigned Idx) const
Retrieve a specific template argument as a type.
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:1838
field_range fields() const
Definition: Decl.h:3382
NullPointerConstantValueDependence
Enumeration used to describe how isNullPointerConstant() should cope with value-dependent expressions...
Definition: Expr.h:686
capture_iterator capture_end() const
Retrieve an iterator pointing past the end of the sequence of lambda captures.
Definition: ExprCXX.cpp:948
semantics_iterator semantics_end()
Definition: Expr.h:4753
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2897
const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const
Walk outwards from an expression we want to bind a reference to and find the expression whose lifetim...
Definition: Expr.cpp:54
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:147
RecordDecl * getDecl() const
Definition: Type.h:3716
FunctionDecl * getTemplateInstantiationPattern() const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3128
bool isInstantiationDependent() const
Whether this nested name specifier involves a template parameter.
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2326
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Definition: Expr.h:2823
Expr * getLHS() const
Definition: Expr.h:3215
static bool isBooleanType(QualType Ty)
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
An adjustment to be made to the temporary created when emitting a reference binding, which accesses a particular subobject of that temporary.
Definition: Expr.h:59
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2632
std::reverse_iterator< const_iterator > const_reverse_iterator
Definition: ASTVector.h:83
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1119
CXXTemporary * getTemporary()
Definition: ExprCXX.h:1139
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1503
iterator end() const
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
Definition: Expr.cpp:1244
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:720
An ordinary object is located at an address in memory.
Definition: Specifiers.h:121
This represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:3625
Represents an ObjC class declaration.
Definition: DeclObjC.h:1091
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Character, const SourceManager &SM, const LangOptions &LangOpts)
AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token...
Definition: Lexer.cpp:700
Expression is a GNU-style __null constant.
Definition: Expr.h:681
detail::InMemoryDirectory::const_iterator I
unsigned getWCharWidth() const
getWCharWidth/Align - Return the size of 'wchar_t' for this target, in bits.
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:967
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix)
Retrieve the unary opcode that corresponds to the given overloaded operator.
Definition: Expr.cpp:1094
QualType getType() const
Definition: Decl.h:599
bool isInvalid() const
void setIntValue(const ASTContext &C, const llvm::APInt &Val)
Definition: Expr.cpp:691
uint64_t * pVal
Used to store the >64 bits integer value.
Definition: Expr.h:1224
Represents the this expression in C++.
Definition: ExprCXX.h:873
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type...
Definition: Type.h:5835
Expr * getRHS() const
Definition: Expr.h:3216
bool isUnion() const
Definition: Decl.h:2939
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3170
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type...
Definition: Type.h:5858
llvm::APInt getValue() const
Definition: Expr.h:1248
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:551
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3073
IdentifierInfo * getFieldName() const
Definition: Expr.cpp:3512
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
Definition: Expr.h:1084
bool isInstanceMessage() const
Determine whether this is an instance message to either a computed object or to super.
Definition: ExprObjC.h:1143
Expr * IgnoreParenNoopCasts(ASTContext &Ctx) LLVM_READONLY
IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the value (including ptr->int ...
Definition: Expr.cpp:2446
bool isOBJCGCCandidate(ASTContext &Ctx) const
isOBJCGCCandidate - Return true if this expression may be used in a read/ write barrier.
Definition: Expr.cpp:2226
CastKind
CastKind - The kind of operation required for a conversion.
SourceRange getDesignatorsSourceRange() const
Definition: Expr.cpp:3614
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1652
Specifies that the expression should never be value-dependent.
Definition: Expr.h:688
NamedDecl * getDecl() const
iterator end()
Definition: ASTVector.h:94
ASTContext * Context
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:189
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
Exposes information about the current target.
InitListExpr(const ASTContext &C, SourceLocation lbraceloc, ArrayRef< Expr * > initExprs, SourceLocation rbraceloc)
Definition: Expr.cpp:1766
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:131
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1251
bool isObjCSelfExpr() const
Check if this expression is the ObjC 'self' implicit parameter.
Definition: Expr.cpp:3271
void setString(const ASTContext &C, StringRef Str, StringKind Kind, bool IsPascal)
Sets the string data to the given string data.
Definition: Expr.cpp:956
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.h:4129
bool isKnownToHaveBooleanValue() const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
Definition: Expr.cpp:112
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:590
Expr - This represents one expression.
Definition: Expr.h:105
void setDesignators(const ASTContext &C, const Designator *Desigs, unsigned NumDesigs)
Definition: Expr.cpp:3605
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:3622
StringRef getName() const
Return the actual identifier string.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:102
void outputString(raw_ostream &OS) const
Definition: Expr.cpp:863
double getValueAsApproximateDouble() const
getValueAsApproximateDouble - This returns the value as an inaccurate double.
Definition: Expr.cpp:794
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:432
void setTypeDependent(bool TD)
Set whether this expression is type-dependent or not.
Definition: Expr.h:168
bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc, SourceRange &R1, SourceRange &R2, ASTContext &Ctx) const
isUnusedResultAWarning - Return true if this immediate expression should be warned about if the resul...
Definition: Expr.cpp:1896
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2414
SourceRange getSourceRange() const
Definition: ExprCXX.h:95
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:1851
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2011
Expr * getArrayRangeStart(const Designator &D) const
Definition: Expr.cpp:3646
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode. ...
Definition: Expr.cpp:1109
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:406
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
Definition: Expr.h:373
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
Definition: Expr.cpp:746
Represents the type decltype(expr) (C++11).
Definition: Type.h:3590
ArrayRef< Expr * > inits()
Definition: Expr.h:3781
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:692
Extra data stored in some MemberExpr objects.
Definition: Expr.h:2303
Base object dtor.
Definition: ABI.h:37
SourceLocation getLocEnd() const LLVM_READONLY
unsigned getNumSubExprs() const
Definition: Expr.h:4862
Expr * getSubExpr() const
Definition: Expr.h:1695
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1774
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1214
bool EvaluateAsInt(llvm::APSInt &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer...
QualType getCXXNameType() const
getCXXNameType - If this name is one of the C++ names (of a constructor, destructor, or conversion function), return the type associated with that name.
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:860
Expr * getSubExprAsWritten()
Retrieve the cast subexpression as it was written in the source code, looking through any implicit ca...
Definition: Expr.cpp:1605
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1668
unsigned Index
Location of the first index expression within the designated initializer expression's list of subexpr...
Definition: Expr.h:4012
Represents a GCC generic vector type.
Definition: Type.h:2756
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3767
Allow UB that we can give a value, but not arbitrary unmodeled side effects.
Definition: Expr.h:587
class LLVM_ALIGNAS(8) TemplateSpecializationType unsigned NumArgs
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4154
ValueDecl * getDecl()
Definition: Expr.h:1017
bool isGLValue() const
Definition: Expr.h:250
The result type of a method or function.
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr.
Definition: Expr.h:2834
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Definition: DeclTemplate.h:442
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name, with source-location information.
Definition: Expr.h:1036
reverse_iterator rend()
Definition: ASTVector.h:100
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:1476
do v
Definition: arm_acle.h:78
const SourceManager & SM
Definition: Format.cpp:1184
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c.h:75
InitListExpr * getUpdater() const
Definition: Expr.h:4295
bool isArrayRangeDesignator() const
Definition: Expr.h:4078
SourceLocation getCaretLocation() const
Definition: Expr.cpp:1877
Expr * IgnoreCasts() LLVM_READONLY
Ignore casts. Strip off any CastExprs, returning their operand.
Definition: Expr.cpp:2348
bool isBoundMemberFunction(ASTContext &Ctx) const
Returns true if this expression is a bound member function.
Definition: Expr.cpp:2265
const llvm::fltSemantics & getSemantics() const
Return the APFloat semantics this literal uses.
Definition: Expr.cpp:756
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
Definition: Expr.cpp:1705
Expr * IgnoreConversionOperator() LLVM_READONLY
IgnoreConversionOperator - Ignore conversion operator.
Definition: Expr.cpp:2435
unsigned DotLoc
The location of the '.' in the designated initializer.
Definition: Expr.h:4002
UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo, QualType resultType, SourceLocation op, SourceLocation rp)
Definition: Expr.h:1982
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:290
ASTMatchFinder *const Finder
void ExpandDesignator(const ASTContext &C, unsigned Idx, const Designator *First, const Designator *Last)
Replaces the designator at index Idx with the series of designators in [First, Last).
Definition: Expr.cpp:3660
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:848
#define false
Definition: stdbool.h:33
Kind
A field in a dependent type, known only by its name.
Definition: Expr.h:1779
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:5730
Expr * getArrayRangeEnd(const Designator &D) const
Definition: Expr.cpp:3652
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4679
Encodes a location in the source.
unsigned getNumParams() const
getNumParams - Return the number of parameters this function must have based on its FunctionType...
Definition: Decl.cpp:2742
Expression is not a Null pointer constant.
Definition: Expr.h:665
bool isImplicitAccess() const
Determine whether the base of this explicit is implicit.
Definition: Expr.h:2524
bool isValid() const
Return true if this is a valid SourceLocation object.
FieldDecl * getField() const
Definition: Expr.h:4082
const std::string ID
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:121
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > PL, ArrayRef< Expr * > IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
static QualType getUnderlyingType(const SubRegion *R)
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
size_type size() const
Definition: ASTVector.h:104
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:119
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1736
void print(const PrintingPolicy &Policy, raw_ostream &Out) const
Print this template argument to the given output stream.
const CXXRecordDecl * getBestDynamicClassType() const
For an expression of class type or pointer to class type, return the most derived class decl the expr...
Definition: Expr.cpp:39
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1625
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2114
SourceLocation getStrTokenLoc(unsigned TokNum) const
Definition: Expr.h:1576
uint64_t VAL
Used to store the <= 64 bits integer value.
Definition: Expr.h:1223
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
Specifies that a value-dependent expression should be considered to never be a null pointer constant...
Definition: Expr.h:696
CanQualType VoidTy
Definition: ASTContext.h:893
Expr * updateInit(const ASTContext &C, unsigned Init, Expr *expr)
Updates the initializer at index Init with the new expression expr, and returns the old expression at...
Definition: Expr.cpp:1797
bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const
Returns true if this is a call to a builtin which does not evaluate side-effects within its arguments...
Definition: Expr.cpp:1266
StringLiteral * getFunctionName()
Definition: Expr.cpp:446
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
Definition: Type.h:1236
ParenListExpr(const ASTContext &C, SourceLocation lparenloc, ArrayRef< Expr * > exprs, SourceLocation rparenloc)
Definition: Expr.cpp:3704
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2734
static QualType findBoundMemberType(const Expr *expr)
Given an expression of bound-member type, find the type of the member.
Definition: Expr.cpp:2271
Expr ** getInits()
Retrieve the set of initializers.
Definition: Expr.h:3779
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:165
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5849
static DesignatedInitExpr * CreateEmpty(const ASTContext &C, unsigned NumIndexExprs)
Definition: Expr.cpp:3598
static DesignatedInitExpr * Create(const ASTContext &C, llvm::ArrayRef< Designator > Designators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
Definition: Expr.cpp:3586
Complete object dtor.
Definition: ABI.h:36
bool isVectorType() const
Definition: Type.h:5548
unsigned getBuiltinID() const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:2687
uintptr_t NameOrField
Refers to the field that is being initialized.
Definition: Expr.h:3999
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1242
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1833
const Expr * getBase() const
Definition: Expr.h:4527
unsigned LBracketLoc
The location of the '[' starting the array range designator.
Definition: Expr.h:4014
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5329
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:427
void sawArrayRangeDesignator(bool ARD=true)
Definition: Expr.h:3896
bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const
isCXX98IntegralConstantExpr - Return true if this expression is an integral constant expression in C+...
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:70
Opcode getOpcode() const
Definition: Expr.h:1692
static MemberExpr * Create(const ASTContext &C, Expr *base, bool isarrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *memberdecl, DeclAccessPair founddecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *targs, QualType ty, ExprValueKind VK, ExprObjectKind OK)
Definition: Expr.cpp:1402
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:193
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Definition: Expr.h:1699
A POD class for pairing a NamedDecl* with an access specifier.
Represents a C11 generic selection.
Definition: Expr.h:4413
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
Definition: Expr.cpp:1272
QualType getType() const
Definition: Expr.h:126
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
SourceLocation getLParenLoc() const
Definition: Expr.h:2860
StringRef getOpcodeStr() const
Definition: Expr.h:2959
child_range children()
void setExprs(const ASTContext &C, ArrayRef< Expr * > Exprs)
Definition: Expr.cpp:3449
SourceLocation getLocStart() const LLVM_READONLY
UnaryOperatorKind
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1135
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:562
bool hasSideEffects(Expr *E, ASTContext &Ctx)
Definition: Transforms.cpp:173
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return 0.
Definition: Expr.cpp:1209
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1983
static LLVM_READONLY bool isPrintable(unsigned char c)
Return true if this character is an ASCII printable character; that is, a character that should take ...
Definition: CharInfo.h:140
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type...
Definition: Expr.cpp:2520
AtomicExpr(SourceLocation BLoc, ArrayRef< Expr * > args, QualType t, AtomicOp op, SourceLocation RP)
Definition: Expr.cpp:3820
SourceRange getSourceRange(const SourceRange &Range)
Returns the SourceRange of a SourceRange.
Definition: FixIt.h:34
A field designator, e.g., ".x".
Definition: Expr.h:3992
NestedNameSpecifierLoc getQualifierLoc() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: Expr.h:2430
The same as PrettyFunction, except that the 'virtual' keyword is omitted for virtual member functions...
Definition: Expr.h:1171
bool isDefaultArgument() const
Determine whether this expression is a default function argument.
Definition: Expr.cpp:2481
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:3696
Expression is a Null pointer constant built from a zero integer expression that is not a simple...
Definition: Expr.h:672
void resize(const ASTContext &C, unsigned N, const T &NV)
Definition: ASTVector.h:338
void setInstantiationDependent(bool ID)
Set whether this expression is instantiation-dependent or not.
Definition: Expr.h:194
StringKind getKind() const
Definition: Expr.h:1554
bool path_empty() const
Definition: Expr.h:2698
Expression is a C++11 nullptr.
Definition: Expr.h:678
detail::InMemoryDirectory::const_iterator E
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2401
semantics_iterator semantics_begin()
Definition: Expr.h:4747
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2205
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:1966
ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
ExplicitCastExpr - An explicit cast written in the source code.
Definition: Expr.h:2800
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
unsigned getNumArgs() const
Definition: ExprCXX.h:1285
unsigned getNumConcatenated() const
getNumConcatenated - Get the number of string literal tokens that were concatenated in translation ph...
Definition: Expr.h:1574
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
Definition: Expr.cpp:3750
llvm::APFloat getValue() const
Definition: Expr.h:1368
Expr * IgnoreParenImpCasts() LLVM_READONLY
IgnoreParenImpCasts - Ignore parentheses and implicit casts.
Definition: Expr.cpp:2413
Decl * getCalleeDecl()
Definition: Expr.cpp:1185
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant...
Definition: Expr.cpp:2614
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier, e.g., N::foo.
Definition: Expr.h:1032
Pointer to a block type.
Definition: Type.h:2286
struct ArrayOrRangeDesignator ArrayOrRange
An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
Definition: Expr.h:4040
bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...
Not an overloaded operator.
Definition: OperatorKinds.h:23
bool HasSideEffects
Whether the evaluated expression has side effects.
Definition: Expr.h:535
MemberExpr(Expr *base, bool isarrow, SourceLocation operatorloc, ValueDecl *memberdecl, const DeclarationNameInfo &NameInfo, QualType ty, ExprValueKind VK, ExprObjectKind OK)
Definition: Expr.h:2367
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3707
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:427
static const TypeInfo & getInfo(unsigned id)
Definition: Types.cpp:34
SourceLocation getCaretLocation() const
Definition: Decl.h:3530
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5818
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2063
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:3637
static StringRef getIdentTypeName(IdentType IT)
Definition: Expr.cpp:450
void setIndexExpr(unsigned Idx, Expr *E)
Definition: Expr.h:1947
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
Definition: Expr.cpp:1673
static ImplicitCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize)
Definition: Expr.cpp:1666
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1291
bool isFunctionType() const
Definition: Type.h:5479
Expr * IgnoreParenLValueCasts() LLVM_READONLY
Ignore parentheses and lvalue casts.
Definition: Expr.cpp:2373
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1288
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1225
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1528
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:1848
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:1300
Represents a base class of a C++ class.
Definition: DeclCXX.h:159
iterator begin()
Definition: ASTVector.h:92
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:479
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1037
Expr * getBase() const
Definition: Expr.h:2405
A template argument list.
Definition: DeclTemplate.h:173
static CStyleCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize)
Definition: Expr.cpp:1688
static const Expr * skipTemporaryBindingsNoOpCastsAndParens(const Expr *E)
Skip over any no-op casts and any temporary-binding expressions.
Definition: Expr.cpp:2494
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Expr.cpp:3700
void reserve(const ASTContext &C, unsigned N)
Definition: ASTVector.h:168
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
Expression is a Null pointer constant built from a literal zero.
Definition: Expr.h:675
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2315
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Definition: ExprCXX.h:77
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
Definition: Expr.h:3841
Represents a C++ struct/union/class.
Definition: DeclCXX.h:263
bool hasQualifiers() const
Return true if the set contains any qualifiers.
Definition: Type.h:376
bool hasNonTrivialCall(const ASTContext &Ctx) const
Determine whether this expression involves a call to any function that is not trivial.
Definition: Expr.cpp:3120
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
Definition: Expr.cpp:3887
Opcode getOpcode() const
Definition: Expr.h:2940
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:3547
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv]).
Definition: ExprCXX.h:1395
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
Definition: Expr.h:2425
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:568
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:461
FieldDecl * getField() const
For a field offsetof node, returns the field.
Definition: Expr.h:1834
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:353
bool isArrayType() const
Definition: Type.h:5521
bool hasExplicitTemplateArgs() const
Determines whether this declaration reference was followed by an explicit template argument list...
Definition: Expr.h:1095
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1466
Defines the clang::TargetInfo interface.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2148
unsigned GetStringLength() const
Expr * getRHS() const
Definition: Expr.h:2945
Designator * getDesignator(unsigned Idx)
Definition: Expr.h:4164
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
Definition: Expr.cpp:2606
void reserveInits(const ASTContext &C, unsigned NumInits)
Reserve space for some number of initializers.
Definition: Expr.cpp:1788
bool isIncompleteArrayType() const
Definition: Type.h:5527
bool isStringLiteralInit() const
Definition: Expr.cpp:1819
Expr * getBase() const
Definition: Expr.h:4292
DeclAccessPair FoundDecl
The DeclAccessPair through which the MemberDecl was found due to name qualifiers. ...
Definition: Expr.h:2310
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:932
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:401
QualType getElementType() const
Definition: Type.h:2490
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file. ...
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
Definition: Expr.cpp:1742
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3785
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:3849
Qualifiers::GC getObjCGCAttrKind(QualType Ty) const
Return one of the GCNone, Weak or Strong Objective-C garbage collection attributes.
#define true
Definition: stdbool.h:32
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:109
A trivial tuple used to represent a source range.
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to...
Definition: Expr.cpp:1085
unsigned getNumElements() const
getNumElements - Get the number of components being selected.
Definition: Expr.cpp:3368
bool isVolatile() const
Definition: Type.h:3020
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
Definition: Expr.h:1874
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2607
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
SourceLocation getLocationOfByte(unsigned ByteNo, const SourceManager &SM, const LangOptions &Features, const TargetInfo &Target, unsigned *StartToken=nullptr, unsigned *StartTokenByteOffset=nullptr) const
getLocationOfByte - Return a source location that points to the specified byte of this string literal...
Definition: Expr.cpp:1009
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx) const
EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...
unsigned getNumPreArgs() const
Definition: Expr.h:2179
void removeAddressSpace()
Definition: Type.h:340
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2380
This class handles loading and caching of source files into memory.
const CXXDestructorDecl * getDestructor() const
Definition: ExprCXX.h:1099
Defines enum values for all the target-independent builtin functions.
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant()...
Definition: Expr.h:663
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:5702
Kind getKind() const
Determine what kind of offsetof node this is.
Definition: Expr.h:1824
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2295
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5286
bool isPointerType() const
Definition: Type.h:5482
bool isConst() const
Definition: Type.h:3019
SourceRange getSourceRange() const LLVM_READONLY
Definition: Expr.h:4138
QualType getArgumentType() const
Definition: Expr.h:2011
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.cpp:1462