clang  8.0.0svn
ScopeInfo.h
Go to the documentation of this file.
1 //===- ScopeInfo.h - Information about a semantic context -------*- C++ -*-===//
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 defines FunctionScopeInfo and its subclasses, which contain
11 // information about a single function, block, lambda, or method body.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_SEMA_SCOPEINFO_H
16 #define LLVM_CLANG_SEMA_SCOPEINFO_H
17 
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/Type.h"
21 #include "clang/Basic/LLVM.h"
24 #include "clang/Sema/CleanupInfo.h"
25 #include "llvm/ADT/DenseMap.h"
26 #include "llvm/ADT/DenseMapInfo.h"
27 #include "llvm/ADT/MapVector.h"
28 #include "llvm/ADT/PointerIntPair.h"
29 #include "llvm/ADT/SmallPtrSet.h"
30 #include "llvm/ADT/SmallSet.h"
31 #include "llvm/ADT/SmallVector.h"
32 #include "llvm/ADT/StringRef.h"
33 #include "llvm/ADT/StringSwitch.h"
34 #include "llvm/Support/Casting.h"
35 #include "llvm/Support/ErrorHandling.h"
36 #include <algorithm>
37 #include <cassert>
38 #include <utility>
39 
40 namespace clang {
41 
42 class BlockDecl;
43 class CapturedDecl;
44 class CXXMethodDecl;
45 class CXXRecordDecl;
46 class ImplicitParamDecl;
47 class NamedDecl;
48 class ObjCIvarRefExpr;
49 class ObjCMessageExpr;
50 class ObjCPropertyDecl;
51 class ObjCPropertyRefExpr;
52 class ParmVarDecl;
53 class RecordDecl;
54 class ReturnStmt;
55 class Scope;
56 class Stmt;
57 class SwitchStmt;
58 class TemplateParameterList;
59 class TemplateTypeParmDecl;
60 class VarDecl;
61 
62 namespace sema {
63 
64 /// Contains information about the compound statement currently being
65 /// parsed.
67 public:
68  /// Whether this compound stamement contains `for' or `while' loops
69  /// with empty bodies.
70  bool HasEmptyLoopBodies = false;
71 
72  /// Whether this compound statement corresponds to a GNU statement
73  /// expression.
74  bool IsStmtExpr;
75 
76  CompoundScopeInfo(bool IsStmtExpr) : IsStmtExpr(IsStmtExpr) {}
77 
79  HasEmptyLoopBodies = true;
80  }
81 };
82 
84 public:
87  const Stmt *stmt;
88 
90  const Stmt *stmt)
91  : PD(PD), Loc(Loc), stmt(stmt) {}
92 };
93 
94 /// Retains information about a function, method, or block that is
95 /// currently being parsed.
97 protected:
98  enum ScopeKind {
102  SK_CapturedRegion
103  };
104 
105 public:
106  /// What kind of scope we are describing.
108 
109  /// Whether this function contains a VLA, \@try, try, C++
110  /// initializer, or anything else that can't be jumped past.
112 
113  /// Whether this function contains any switches or direct gotos.
115 
116  /// Whether this function contains any indirect gotos.
117  bool HasIndirectGoto : 1;
118 
119  /// Whether a statement was dropped because it was invalid.
120  bool HasDroppedStmt : 1;
121 
122  /// True if current scope is for OpenMP declare reduction combiner.
124 
125  /// Whether there is a fallthrough statement in this function.
127 
128  /// Whether we make reference to a declaration that could be
129  /// unavailable.
131 
132  /// A flag that is set when parsing a method that must call super's
133  /// implementation, such as \c -dealloc, \c -finalize, or any method marked
134  /// with \c __attribute__((objc_requires_super)).
136 
137  /// True when this is a method marked as a designated initializer.
139 
140  /// This starts true for a method marked as designated initializer and will
141  /// be set to false if there is an invocation to a designated initializer of
142  /// the super class.
144 
145  /// True when this is an initializer method not marked as a designated
146  /// initializer within a class that has at least one initializer marked as a
147  /// designated initializer.
149 
150  /// This starts true for a secondary initializer method and will be set to
151  /// false if there is an invocation of an initializer on 'self'.
153 
154  /// True only when this function has not already built, or attempted
155  /// to build, the initial and final coroutine suspend points
157 
158  /// An enumeration represeting the kind of the first coroutine statement
159  /// in the function. One of co_return, co_await, or co_yield.
160  unsigned char FirstCoroutineStmtKind : 2;
161 
162  /// First coroutine statement in the current function.
163  /// (ex co_return, co_await, co_yield)
165 
166  /// First 'return' statement in the current function.
168 
169  /// First C++ 'try' statement in the current function.
171 
172  /// First SEH '__try' statement in the current function.
174 
175  /// Used to determine if errors occurred in this function or block.
177 
178  /// A SwitchStmt, along with a flag indicating if its list of case statements
179  /// is incomplete (because we dropped an invalid one while parsing).
180  using SwitchInfo = llvm::PointerIntPair<SwitchStmt*, 1, bool>;
181 
182  /// SwitchStack - This is the current set of active switch statements in the
183  /// block.
185 
186  /// The list of return statements that occur within the function or
187  /// block, if there is any chance of applying the named return value
188  /// optimization, or if we need to infer a return type.
190 
191  /// The promise object for this coroutine, if any.
192  VarDecl *CoroutinePromise = nullptr;
193 
194  /// A mapping between the coroutine function parameters that were moved
195  /// to the coroutine frame, and their move statements.
196  llvm::SmallMapVector<ParmVarDecl *, Stmt *, 4> CoroutineParameterMoves;
197 
198  /// The initial and final coroutine suspend points.
199  std::pair<Stmt *, Stmt *> CoroutineSuspends;
200 
201  /// The stack of currently active compound stamement scopes in the
202  /// function.
204 
205  /// A list of PartialDiagnostics created but delayed within the
206  /// current function scope. These diagnostics are vetted for reachability
207  /// prior to being emitted.
209 
210  /// A list of parameters which have the nonnull attribute and are
211  /// modified in the function.
212  llvm::SmallPtrSet<const ParmVarDecl *, 8> ModifiedNonNullParams;
213 
214 public:
215  /// Represents a simple identification of a weak object.
216  ///
217  /// Part of the implementation of -Wrepeated-use-of-weak.
218  ///
219  /// This is used to determine if two weak accesses refer to the same object.
220  /// Here are some examples of how various accesses are "profiled":
221  ///
222  /// Access Expression | "Base" Decl | "Property" Decl
223  /// :---------------: | :-----------------: | :------------------------------:
224  /// self.property | self (VarDecl) | property (ObjCPropertyDecl)
225  /// self.implicitProp | self (VarDecl) | -implicitProp (ObjCMethodDecl)
226  /// self->ivar.prop | ivar (ObjCIvarDecl) | prop (ObjCPropertyDecl)
227  /// cxxObj.obj.prop | obj (FieldDecl) | prop (ObjCPropertyDecl)
228  /// [self foo].prop | 0 (unknown) | prop (ObjCPropertyDecl)
229  /// self.prop1.prop2 | prop1 (ObjCPropertyDecl) | prop2 (ObjCPropertyDecl)
230  /// MyClass.prop | MyClass (ObjCInterfaceDecl) | -prop (ObjCMethodDecl)
231  /// MyClass.foo.prop | +foo (ObjCMethodDecl) | -prop (ObjCPropertyDecl)
232  /// weakVar | 0 (known) | weakVar (VarDecl)
233  /// self->weakIvar | self (VarDecl) | weakIvar (ObjCIvarDecl)
234  ///
235  /// Objects are identified with only two Decls to make it reasonably fast to
236  /// compare them.
238  /// The base object decl, as described in the class documentation.
239  ///
240  /// The extra flag is "true" if the Base and Property are enough to uniquely
241  /// identify the object in memory.
242  ///
243  /// \sa isExactProfile()
244  using BaseInfoTy = llvm::PointerIntPair<const NamedDecl *, 1, bool>;
245  BaseInfoTy Base;
246 
247  /// The "property" decl, as described in the class documentation.
248  ///
249  /// Note that this may not actually be an ObjCPropertyDecl, e.g. in the
250  /// case of "implicit" properties (regular methods accessed via dot syntax).
251  const NamedDecl *Property = nullptr;
252 
253  /// Used to find the proper base profile for a given base expression.
254  static BaseInfoTy getBaseInfo(const Expr *BaseE);
255 
256  inline WeakObjectProfileTy();
257  static inline WeakObjectProfileTy getSentinel();
258 
259  public:
261  WeakObjectProfileTy(const Expr *Base, const ObjCPropertyDecl *Property);
262  WeakObjectProfileTy(const DeclRefExpr *RE);
264 
265  const NamedDecl *getBase() const { return Base.getPointer(); }
266  const NamedDecl *getProperty() const { return Property; }
267 
268  /// Returns true if the object base specifies a known object in memory,
269  /// rather than, say, an instance variable or property of another object.
270  ///
271  /// Note that this ignores the effects of aliasing; that is, \c foo.bar is
272  /// considered an exact profile if \c foo is a local variable, even if
273  /// another variable \c foo2 refers to the same object as \c foo.
274  ///
275  /// For increased precision, accesses with base variables that are
276  /// properties or ivars of 'self' (e.g. self.prop1.prop2) are considered to
277  /// be exact, though this is not true for arbitrary variables
278  /// (foo.prop1.prop2).
279  bool isExactProfile() const {
280  return Base.getInt();
281  }
282 
283  bool operator==(const WeakObjectProfileTy &Other) const {
284  return Base == Other.Base && Property == Other.Property;
285  }
286 
287  // For use in DenseMap.
288  // We can't specialize the usual llvm::DenseMapInfo at the end of the file
289  // because by that point the DenseMap in FunctionScopeInfo has already been
290  // instantiated.
291  class DenseMapInfo {
292  public:
294  return WeakObjectProfileTy();
295  }
296 
298  return WeakObjectProfileTy::getSentinel();
299  }
300 
301  static unsigned getHashValue(const WeakObjectProfileTy &Val) {
302  using Pair = std::pair<BaseInfoTy, const NamedDecl *>;
303 
304  return llvm::DenseMapInfo<Pair>::getHashValue(Pair(Val.Base,
305  Val.Property));
306  }
307 
308  static bool isEqual(const WeakObjectProfileTy &LHS,
309  const WeakObjectProfileTy &RHS) {
310  return LHS == RHS;
311  }
312  };
313  };
314 
315  /// Represents a single use of a weak object.
316  ///
317  /// Stores both the expression and whether the access is potentially unsafe
318  /// (i.e. it could potentially be warned about).
319  ///
320  /// Part of the implementation of -Wrepeated-use-of-weak.
321  class WeakUseTy {
322  llvm::PointerIntPair<const Expr *, 1, bool> Rep;
323 
324  public:
325  WeakUseTy(const Expr *Use, bool IsRead) : Rep(Use, IsRead) {}
326 
327  const Expr *getUseExpr() const { return Rep.getPointer(); }
328  bool isUnsafe() const { return Rep.getInt(); }
329  void markSafe() { Rep.setInt(false); }
330 
331  bool operator==(const WeakUseTy &Other) const {
332  return Rep == Other.Rep;
333  }
334  };
335 
336  /// Used to collect uses of a particular weak object in a function body.
337  ///
338  /// Part of the implementation of -Wrepeated-use-of-weak.
340 
341  /// Used to collect all uses of weak objects in a function body.
342  ///
343  /// Part of the implementation of -Wrepeated-use-of-weak.
344  using WeakObjectUseMap =
345  llvm::SmallDenseMap<WeakObjectProfileTy, WeakUseVector, 8,
347 
348 private:
349  /// Used to collect all uses of weak objects in this function body.
350  ///
351  /// Part of the implementation of -Wrepeated-use-of-weak.
352  WeakObjectUseMap WeakObjectUses;
353 
354 protected:
355  FunctionScopeInfo(const FunctionScopeInfo&) = default;
356 
357 public:
359  : Kind(SK_Function), HasBranchProtectedScope(false),
360  HasBranchIntoScope(false), HasIndirectGoto(false),
361  HasDroppedStmt(false), HasOMPDeclareReductionCombiner(false),
362  HasFallthroughStmt(false), HasPotentialAvailabilityViolations(false),
363  ObjCShouldCallSuper(false), ObjCIsDesignatedInit(false),
364  ObjCWarnForNoDesignatedInitChain(false), ObjCIsSecondaryInit(false),
365  ObjCWarnForNoInitDelegation(false), NeedsCoroutineSuspends(true),
366  ErrorTrap(Diag) {}
367 
368  virtual ~FunctionScopeInfo();
369 
370  /// Record that a weak object was accessed.
371  ///
372  /// Part of the implementation of -Wrepeated-use-of-weak.
373  template <typename ExprT>
374  inline void recordUseOfWeak(const ExprT *E, bool IsRead = true);
375 
376  void recordUseOfWeak(const ObjCMessageExpr *Msg,
377  const ObjCPropertyDecl *Prop);
378 
379  /// Record that a given expression is a "safe" access of a weak object (e.g.
380  /// assigning it to a strong variable.)
381  ///
382  /// Part of the implementation of -Wrepeated-use-of-weak.
383  void markSafeWeakUse(const Expr *E);
384 
386  return WeakObjectUses;
387  }
388 
390  HasBranchIntoScope = true;
391  }
392 
394  HasBranchProtectedScope = true;
395  }
396 
398  HasIndirectGoto = true;
399  }
400 
402  HasDroppedStmt = true;
403  }
404 
406  HasOMPDeclareReductionCombiner = true;
407  }
408 
410  HasFallthroughStmt = true;
411  }
412 
414  setHasBranchProtectedScope();
415  FirstCXXTryLoc = TryLoc;
416  }
417 
419  setHasBranchProtectedScope();
420  FirstSEHTryLoc = TryLoc;
421  }
422 
423  bool NeedsScopeChecking() const {
424  return !HasDroppedStmt &&
425  (HasIndirectGoto ||
426  (HasBranchProtectedScope && HasBranchIntoScope));
427  }
428 
429  bool isCoroutine() const { return !FirstCoroutineStmtLoc.isInvalid(); }
430 
431  void setFirstCoroutineStmt(SourceLocation Loc, StringRef Keyword) {
432  assert(FirstCoroutineStmtLoc.isInvalid() &&
433  "first coroutine statement location already set");
434  FirstCoroutineStmtLoc = Loc;
435  FirstCoroutineStmtKind = llvm::StringSwitch<unsigned char>(Keyword)
436  .Case("co_return", 0)
437  .Case("co_await", 1)
438  .Case("co_yield", 2);
439  }
440 
441  StringRef getFirstCoroutineStmtKeyword() const {
442  assert(FirstCoroutineStmtLoc.isValid()
443  && "no coroutine statement available");
444  switch (FirstCoroutineStmtKind) {
445  case 0: return "co_return";
446  case 1: return "co_await";
447  case 2: return "co_yield";
448  default:
449  llvm_unreachable("FirstCoroutineStmtKind has an invalid value");
450  };
451  }
452 
453  void setNeedsCoroutineSuspends(bool value = true) {
454  assert((!value || CoroutineSuspends.first == nullptr) &&
455  "we already have valid suspend points");
456  NeedsCoroutineSuspends = value;
457  }
458 
460  return !NeedsCoroutineSuspends && CoroutineSuspends.first == nullptr;
461  }
462 
463  void setCoroutineSuspends(Stmt *Initial, Stmt *Final) {
464  assert(Initial && Final && "suspend points cannot be null");
465  assert(CoroutineSuspends.first == nullptr && "suspend points already set");
466  NeedsCoroutineSuspends = false;
467  CoroutineSuspends.first = Initial;
468  CoroutineSuspends.second = Final;
469  }
470 
471  /// Clear out the information in this function scope, making it
472  /// suitable for reuse.
473  void Clear();
474 };
475 
476 class Capture {
477  // There are three categories of capture: capturing 'this', capturing
478  // local variables, and C++1y initialized captures (which can have an
479  // arbitrary initializer, and don't really capture in the traditional
480  // sense at all).
481  //
482  // There are three ways to capture a local variable:
483  // - capture by copy in the C++11 sense,
484  // - capture by reference in the C++11 sense, and
485  // - __block capture.
486  // Lambdas explicitly specify capture by copy or capture by reference.
487  // For blocks, __block capture applies to variables with that annotation,
488  // variables of reference type are captured by reference, and other
489  // variables are captured by copy.
490  enum CaptureKind {
491  Cap_ByCopy, Cap_ByRef, Cap_Block, Cap_VLA
492  };
493  enum {
494  IsNestedCapture = 0x1,
495  IsThisCaptured = 0x2
496  };
497 
498  /// The variable being captured (if we are not capturing 'this') and whether
499  /// this is a nested capture, and whether we are capturing 'this'
500  llvm::PointerIntPair<VarDecl*, 2> VarAndNestedAndThis;
501 
502  /// Expression to initialize a field of the given type, and the kind of
503  /// capture (if this is a capture and not an init-capture). The expression
504  /// is only required if we are capturing ByVal and the variable's type has
505  /// a non-trivial copy constructor.
506  llvm::PointerIntPair<void *, 2, CaptureKind> InitExprAndCaptureKind;
507 
508  /// The source location at which the first capture occurred.
509  SourceLocation Loc;
510 
511  /// The location of the ellipsis that expands a parameter pack.
512  SourceLocation EllipsisLoc;
513 
514  /// The type as it was captured, which is in effect the type of the
515  /// non-static data member that would hold the capture.
516  QualType CaptureType;
517 
518  /// Whether an explicit capture has been odr-used in the body of the
519  /// lambda.
520  bool ODRUsed = false;
521 
522  /// Whether an explicit capture has been non-odr-used in the body of
523  /// the lambda.
524  bool NonODRUsed = false;
525 
526 public:
527  Capture(VarDecl *Var, bool Block, bool ByRef, bool IsNested,
528  SourceLocation Loc, SourceLocation EllipsisLoc,
529  QualType CaptureType, Expr *Cpy)
530  : VarAndNestedAndThis(Var, IsNested ? IsNestedCapture : 0),
531  InitExprAndCaptureKind(
532  Cpy, !Var ? Cap_VLA : Block ? Cap_Block : ByRef ? Cap_ByRef
533  : Cap_ByCopy),
534  Loc(Loc), EllipsisLoc(EllipsisLoc), CaptureType(CaptureType) {}
535 
536  enum IsThisCapture { ThisCapture };
537  Capture(IsThisCapture, bool IsNested, SourceLocation Loc,
538  QualType CaptureType, Expr *Cpy, const bool ByCopy)
539  : VarAndNestedAndThis(
540  nullptr, (IsThisCaptured | (IsNested ? IsNestedCapture : 0))),
541  InitExprAndCaptureKind(Cpy, ByCopy ? Cap_ByCopy : Cap_ByRef),
542  Loc(Loc), CaptureType(CaptureType) {}
543 
544  bool isThisCapture() const {
545  return VarAndNestedAndThis.getInt() & IsThisCaptured;
546  }
547 
548  bool isVariableCapture() const {
549  return !isThisCapture() && !isVLATypeCapture();
550  }
551 
552  bool isCopyCapture() const {
553  return InitExprAndCaptureKind.getInt() == Cap_ByCopy;
554  }
555 
556  bool isReferenceCapture() const {
557  return InitExprAndCaptureKind.getInt() == Cap_ByRef;
558  }
559 
560  bool isBlockCapture() const {
561  return InitExprAndCaptureKind.getInt() == Cap_Block;
562  }
563 
564  bool isVLATypeCapture() const {
565  return InitExprAndCaptureKind.getInt() == Cap_VLA;
566  }
567 
568  bool isNested() const {
569  return VarAndNestedAndThis.getInt() & IsNestedCapture;
570  }
571 
572  bool isODRUsed() const { return ODRUsed; }
573  bool isNonODRUsed() const { return NonODRUsed; }
574  void markUsed(bool IsODRUse) { (IsODRUse ? ODRUsed : NonODRUsed) = true; }
575 
576  VarDecl *getVariable() const {
577  assert(isVariableCapture());
578  return VarAndNestedAndThis.getPointer();
579  }
580 
581  /// Retrieve the location at which this variable was captured.
582  SourceLocation getLocation() const { return Loc; }
583 
584  /// Retrieve the source location of the ellipsis, whose presence
585  /// indicates that the capture is a pack expansion.
586  SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
587 
588  /// Retrieve the capture type for this capture, which is effectively
589  /// the type of the non-static data member in the lambda/block structure
590  /// that would store this capture.
592  assert(!isThisCapture());
593  return CaptureType;
594  }
595 
596  Expr *getInitExpr() const {
597  assert(!isVLATypeCapture() && "no init expression for type capture");
598  return static_cast<Expr *>(InitExprAndCaptureKind.getPointer());
599  }
600 };
601 
603 protected:
604  CapturingScopeInfo(const CapturingScopeInfo&) = default;
605 
606 public:
608  ImpCap_None, ImpCap_LambdaByval, ImpCap_LambdaByref, ImpCap_Block,
609  ImpCap_CapturedRegion
610  };
611 
613 
615  : FunctionScopeInfo(Diag), ImpCaptureStyle(Style) {}
616 
617  /// CaptureMap - A map of captured variables to (index+1) into Captures.
618  llvm::DenseMap<VarDecl*, unsigned> CaptureMap;
619 
620  /// CXXThisCaptureIndex - The (index+1) of the capture of 'this';
621  /// zero if 'this' is not captured.
622  unsigned CXXThisCaptureIndex = 0;
623 
624  /// Captures - The captures.
626 
627  /// - Whether the target type of return statements in this context
628  /// is deduced (e.g. a lambda or block with omitted return type).
629  bool HasImplicitReturnType = false;
630 
631  /// ReturnType - The target type of return statements in this context,
632  /// or null if unknown.
634 
635  void addCapture(VarDecl *Var, bool isBlock, bool isByref, bool isNested,
636  SourceLocation Loc, SourceLocation EllipsisLoc,
637  QualType CaptureType, Expr *Cpy) {
638  Captures.push_back(Capture(Var, isBlock, isByref, isNested, Loc,
639  EllipsisLoc, CaptureType, Cpy));
640  CaptureMap[Var] = Captures.size();
641  }
642 
643  void addVLATypeCapture(SourceLocation Loc, QualType CaptureType) {
644  Captures.push_back(Capture(/*Var*/ nullptr, /*isBlock*/ false,
645  /*isByref*/ false, /*isNested*/ false, Loc,
646  /*EllipsisLoc*/ SourceLocation(), CaptureType,
647  /*Cpy*/ nullptr));
648  }
649 
650  // Note, we do not need to add the type of 'this' since that is always
651  // retrievable from Sema::getCurrentThisType - and is also encoded within the
652  // type of the corresponding FieldDecl.
653  void addThisCapture(bool isNested, SourceLocation Loc,
654  Expr *Cpy, bool ByCopy);
655 
656  /// Determine whether the C++ 'this' is captured.
657  bool isCXXThisCaptured() const { return CXXThisCaptureIndex != 0; }
658 
659  /// Retrieve the capture of C++ 'this', if it has been captured.
661  assert(isCXXThisCaptured() && "this has not been captured");
662  return Captures[CXXThisCaptureIndex - 1];
663  }
664 
665  /// Determine whether the given variable has been captured.
666  bool isCaptured(VarDecl *Var) const {
667  return CaptureMap.count(Var);
668  }
669 
670  /// Determine whether the given variable-array type has been captured.
671  bool isVLATypeCaptured(const VariableArrayType *VAT) const;
672 
673  /// Retrieve the capture of the given variable, if it has been
674  /// captured already.
676  assert(isCaptured(Var) && "Variable has not been captured");
677  return Captures[CaptureMap[Var] - 1];
678  }
679 
680  const Capture &getCapture(VarDecl *Var) const {
681  llvm::DenseMap<VarDecl*, unsigned>::const_iterator Known
682  = CaptureMap.find(Var);
683  assert(Known != CaptureMap.end() && "Variable has not been captured");
684  return Captures[Known->second - 1];
685  }
686 
687  static bool classof(const FunctionScopeInfo *FSI) {
688  return FSI->Kind == SK_Block || FSI->Kind == SK_Lambda
689  || FSI->Kind == SK_CapturedRegion;
690  }
691 };
692 
693 /// Retains information about a block that is currently being parsed.
694 class BlockScopeInfo final : public CapturingScopeInfo {
695 public:
697 
698  /// TheScope - This is the scope for the block itself, which contains
699  /// arguments etc.
701 
702  /// BlockType - The function type of the block, if one was given.
703  /// Its return type may be BuiltinType::Dependent.
705 
707  : CapturingScopeInfo(Diag, ImpCap_Block), TheDecl(Block),
708  TheScope(BlockScope) {
709  Kind = SK_Block;
710  }
711 
712  ~BlockScopeInfo() override;
713 
714  static bool classof(const FunctionScopeInfo *FSI) {
715  return FSI->Kind == SK_Block;
716  }
717 };
718 
719 /// Retains information about a captured region.
721 public:
722  /// The CapturedDecl for this statement.
724 
725  /// The captured record type.
727 
728  /// This is the enclosing scope of the captured region.
730 
731  /// The implicit parameter for the captured variables.
733 
734  /// The kind of captured region.
735  unsigned short CapRegionKind;
736 
737  unsigned short OpenMPLevel;
738 
740  RecordDecl *RD, ImplicitParamDecl *Context,
741  CapturedRegionKind K, unsigned OpenMPLevel)
742  : CapturingScopeInfo(Diag, ImpCap_CapturedRegion),
743  TheCapturedDecl(CD), TheRecordDecl(RD), TheScope(S),
744  ContextParam(Context), CapRegionKind(K), OpenMPLevel(OpenMPLevel) {
745  Kind = SK_CapturedRegion;
746  }
747 
748  ~CapturedRegionScopeInfo() override;
749 
750  /// A descriptive name for the kind of captured region this is.
751  StringRef getRegionName() const {
752  switch (CapRegionKind) {
753  case CR_Default:
754  return "default captured statement";
755  case CR_ObjCAtFinally:
756  return "Objective-C @finally statement";
757  case CR_OpenMP:
758  return "OpenMP region";
759  }
760  llvm_unreachable("Invalid captured region kind!");
761  }
762 
763  static bool classof(const FunctionScopeInfo *FSI) {
764  return FSI->Kind == SK_CapturedRegion;
765  }
766 };
767 
768 class LambdaScopeInfo final : public CapturingScopeInfo {
769 public:
770  /// The class that describes the lambda.
771  CXXRecordDecl *Lambda = nullptr;
772 
773  /// The lambda's compiler-generated \c operator().
774  CXXMethodDecl *CallOperator = nullptr;
775 
776  /// Source range covering the lambda introducer [...].
778 
779  /// Source location of the '&' or '=' specifying the default capture
780  /// type, if any.
782 
783  /// The number of captures in the \c Captures list that are
784  /// explicit captures.
785  unsigned NumExplicitCaptures = 0;
786 
787  /// Whether this is a mutable lambda.
788  bool Mutable = false;
789 
790  /// Whether the (empty) parameter list is explicit.
791  bool ExplicitParams = false;
792 
793  /// Whether any of the capture expressions requires cleanups.
795 
796  /// Whether the lambda contains an unexpanded parameter pack.
797  bool ContainsUnexpandedParameterPack = false;
798 
799  /// If this is a generic lambda, use this as the depth of
800  /// each 'auto' parameter, during initial AST construction.
801  unsigned AutoTemplateParameterDepth = 0;
802 
803  /// Store the list of the auto parameters for a generic lambda.
804  /// If this is a generic lambda, store the list of the auto
805  /// parameters converted into TemplateTypeParmDecls into a vector
806  /// that can be used to construct the generic lambda's template
807  /// parameter list, during initial AST construction.
809 
810  /// If this is a generic lambda, and the template parameter
811  /// list has been created (from the AutoTemplateParams) then
812  /// store a reference to it (cache it to avoid reconstructing it).
813  TemplateParameterList *GLTemplateParameterList = nullptr;
814 
815  /// Contains all variable-referring-expressions (i.e. DeclRefExprs
816  /// or MemberExprs) that refer to local variables in a generic lambda
817  /// or a lambda in a potentially-evaluated-if-used context.
818  ///
819  /// Potentially capturable variables of a nested lambda that might need
820  /// to be captured by the lambda are housed here.
821  /// This is specifically useful for generic lambdas or
822  /// lambdas within a potentially evaluated-if-used context.
823  /// If an enclosing variable is named in an expression of a lambda nested
824  /// within a generic lambda, we don't always know know whether the variable
825  /// will truly be odr-used (i.e. need to be captured) by that nested lambda,
826  /// until its instantiation. But we still need to capture it in the
827  /// enclosing lambda if all intervening lambdas can capture the variable.
829 
830  /// Contains all variable-referring-expressions that refer
831  /// to local variables that are usable as constant expressions and
832  /// do not involve an odr-use (they may still need to be captured
833  /// if the enclosing full-expression is instantiation dependent).
834  llvm::SmallSet<Expr *, 8> NonODRUsedCapturingExprs;
835 
836  /// A map of explicit capture indices to their introducer source ranges.
837  llvm::DenseMap<unsigned, SourceRange> ExplicitCaptureRanges;
838 
839  /// Contains all of the variables defined in this lambda that shadow variables
840  /// that were defined in parent contexts. Used to avoid warnings when the
841  /// shadowed variables are uncaptured by this lambda.
843  const VarDecl *VD;
845  };
847 
849 
851  : CapturingScopeInfo(Diag, ImpCap_None) {
852  Kind = SK_Lambda;
853  }
854 
855  /// Note when all explicit captures have been added.
857  NumExplicitCaptures = Captures.size();
858  }
859 
860  static bool classof(const FunctionScopeInfo *FSI) {
861  return FSI->Kind == SK_Lambda;
862  }
863 
864  /// Is this scope known to be for a generic lambda? (This will be false until
865  /// we parse the first 'auto'-typed parameter.
866  bool isGenericLambda() const {
867  return !AutoTemplateParams.empty() || GLTemplateParameterList;
868  }
869 
870  /// Add a variable that might potentially be captured by the
871  /// lambda and therefore the enclosing lambdas.
872  ///
873  /// This is also used by enclosing lambda's to speculatively capture
874  /// variables that nested lambda's - depending on their enclosing
875  /// specialization - might need to capture.
876  /// Consider:
877  /// void f(int, int); <-- don't capture
878  /// void f(const int&, double); <-- capture
879  /// void foo() {
880  /// const int x = 10;
881  /// auto L = [=](auto a) { // capture 'x'
882  /// return [=](auto b) {
883  /// f(x, a); // we may or may not need to capture 'x'
884  /// };
885  /// };
886  /// }
887  void addPotentialCapture(Expr *VarExpr) {
888  assert(isa<DeclRefExpr>(VarExpr) || isa<MemberExpr>(VarExpr));
889  PotentiallyCapturingExprs.push_back(VarExpr);
890  }
891 
893  PotentialThisCaptureLocation = Loc;
894  }
895 
896  bool hasPotentialThisCapture() const {
897  return PotentialThisCaptureLocation.isValid();
898  }
899 
900  /// Mark a variable's reference in a lambda as non-odr using.
901  ///
902  /// For generic lambdas, if a variable is named in a potentially evaluated
903  /// expression, where the enclosing full expression is dependent then we
904  /// must capture the variable (given a default capture).
905  /// This is accomplished by recording all references to variables
906  /// (DeclRefExprs or MemberExprs) within said nested lambda in its array of
907  /// PotentialCaptures. All such variables have to be captured by that lambda,
908  /// except for as described below.
909  /// If that variable is usable as a constant expression and is named in a
910  /// manner that does not involve its odr-use (e.g. undergoes
911  /// lvalue-to-rvalue conversion, or discarded) record that it is so. Upon the
912  /// act of analyzing the enclosing full expression (ActOnFinishFullExpr)
913  /// if we can determine that the full expression is not instantiation-
914  /// dependent, then we can entirely avoid its capture.
915  ///
916  /// const int n = 0;
917  /// [&] (auto x) {
918  /// (void)+n + x;
919  /// };
920  /// Interestingly, this strategy would involve a capture of n, even though
921  /// it's obviously not odr-used here, because the full-expression is
922  /// instantiation-dependent. It could be useful to avoid capturing such
923  /// variables, even when they are referred to in an instantiation-dependent
924  /// expression, if we can unambiguously determine that they shall never be
925  /// odr-used. This would involve removal of the variable-referring-expression
926  /// from the array of PotentialCaptures during the lvalue-to-rvalue
927  /// conversions. But per the working draft N3797, (post-chicago 2013) we must
928  /// capture such variables.
929  /// Before anyone is tempted to implement a strategy for not-capturing 'n',
930  /// consider the insightful warning in:
931  /// /cfe-commits/Week-of-Mon-20131104/092596.html
932  /// "The problem is that the set of captures for a lambda is part of the ABI
933  /// (since lambda layout can be made visible through inline functions and the
934  /// like), and there are no guarantees as to which cases we'll manage to build
935  /// an lvalue-to-rvalue conversion in, when parsing a template -- some
936  /// seemingly harmless change elsewhere in Sema could cause us to start or stop
937  /// building such a node. So we need a rule that anyone can implement and get
938  /// exactly the same result".
939  void markVariableExprAsNonODRUsed(Expr *CapturingVarExpr) {
940  assert(isa<DeclRefExpr>(CapturingVarExpr)
941  || isa<MemberExpr>(CapturingVarExpr));
942  NonODRUsedCapturingExprs.insert(CapturingVarExpr);
943  }
944  bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const {
945  assert(isa<DeclRefExpr>(CapturingVarExpr)
946  || isa<MemberExpr>(CapturingVarExpr));
947  return NonODRUsedCapturingExprs.count(CapturingVarExpr);
948  }
950  PotentiallyCapturingExprs.erase(
951  std::remove(PotentiallyCapturingExprs.begin(),
952  PotentiallyCapturingExprs.end(), E),
953  PotentiallyCapturingExprs.end());
954  }
956  PotentiallyCapturingExprs.clear();
957  PotentialThisCaptureLocation = SourceLocation();
958  }
960  return PotentiallyCapturingExprs.size();
961  }
962 
963  bool hasPotentialCaptures() const {
964  return getNumPotentialVariableCaptures() ||
965  PotentialThisCaptureLocation.isValid();
966  }
967 
968  // When passed the index, returns the VarDecl and Expr associated
969  // with the index.
970  void getPotentialVariableCapture(unsigned Idx, VarDecl *&VD, Expr *&E) const;
971 };
972 
973 FunctionScopeInfo::WeakObjectProfileTy::WeakObjectProfileTy()
974  : Base(nullptr, false) {}
975 
977 FunctionScopeInfo::WeakObjectProfileTy::getSentinel() {
979  Result.Base.setInt(true);
980  return Result;
981 }
982 
983 template <typename ExprT>
984 void FunctionScopeInfo::recordUseOfWeak(const ExprT *E, bool IsRead) {
985  assert(E);
986  WeakUseVector &Uses = WeakObjectUses[WeakObjectProfileTy(E)];
987  Uses.push_back(WeakUseTy(E, IsRead));
988 }
989 
990 inline void
992  Expr *Cpy,
993  const bool ByCopy) {
994  Captures.push_back(Capture(Capture::ThisCapture, isNested, Loc, QualType(),
995  Cpy, ByCopy));
996  CXXThisCaptureIndex = Captures.size();
997 }
998 
999 } // namespace sema
1000 
1001 } // namespace clang
1002 
1003 #endif // LLVM_CLANG_SEMA_SCOPEINFO_H
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:577
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
Definition: ScopeInfo.h:777
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
A (possibly-)qualified type.
Definition: Type.h:642
void addThisCapture(bool isNested, SourceLocation Loc, Expr *Cpy, bool ByCopy)
Definition: ScopeInfo.h:991
bool HasFallthroughStmt
Whether there is a fallthrough statement in this function.
Definition: ScopeInfo.h:126
bool HasEmptyLoopBodies
Whether this compound stamement contains `for&#39; or `while&#39; loops with empty bodies.
Definition: ScopeInfo.h:70
void setNeedsCoroutineSuspends(bool value=true)
Definition: ScopeInfo.h:453
Stmt - This represents one statement.
Definition: Stmt.h:66
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:633
C Language Family Type Representation.
QualType getCaptureType() const
Retrieve the capture type for this capture, which is effectively the type of the non-static data memb...
Definition: ScopeInfo.h:591
bool hasPotentialCaptures() const
Definition: ScopeInfo.h:963
bool operator==(const WeakUseTy &Other) const
Definition: ScopeInfo.h:331
bool isCopyCapture() const
Definition: ScopeInfo.h:552
const WeakObjectUseMap & getWeakObjectUses() const
Definition: ScopeInfo.h:385
StringRef getFirstCoroutineStmtKeyword() const
Definition: ScopeInfo.h:441
static unsigned getHashValue(const WeakObjectProfileTy &Val)
Definition: ScopeInfo.h:301
bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const
Definition: ScopeInfo.h:944
std::pair< Stmt *, Stmt * > CoroutineSuspends
The initial and final coroutine suspend points.
Definition: ScopeInfo.h:199
static bool classof(const FunctionScopeInfo *FSI)
Definition: ScopeInfo.h:860
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:96
bool isODRUsed() const
Definition: ScopeInfo.h:572
Represents a variable declaration or definition.
Definition: Decl.h:812
static bool classof(const FunctionScopeInfo *FSI)
Definition: ScopeInfo.h:763
bool hasPotentialThisCapture() const
Definition: ScopeInfo.h:896
static bool classof(const FunctionScopeInfo *FSI)
Definition: ScopeInfo.h:687
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:998
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
llvm::SmallVector< ShadowedOuterDecl, 4 > ShadowingDecls
Definition: ScopeInfo.h:846
llvm::PointerIntPair< SwitchStmt *, 1, bool > SwitchInfo
A SwitchStmt, along with a flag indicating if its list of case statements is incomplete (because we d...
Definition: ScopeInfo.h:180
bool NeedsCoroutineSuspends
True only when this function has not already built, or attempted to build, the initial and final coro...
Definition: ScopeInfo.h:156
CapturedDecl * TheCapturedDecl
The CapturedDecl for this statement.
Definition: ScopeInfo.h:723
bool HasDroppedStmt
Whether a statement was dropped because it was invalid.
Definition: ScopeInfo.h:120
llvm::SmallMapVector< ParmVarDecl *, Stmt *, 4 > CoroutineParameterMoves
A mapping between the coroutine function parameters that were moved to the coroutine frame...
Definition: ScopeInfo.h:196
Represents a struct/union/class.
Definition: Decl.h:3570
unsigned char FirstCoroutineStmtKind
An enumeration represeting the kind of the first coroutine statement in the function.
Definition: ScopeInfo.h:160
ScopeKind Kind
What kind of scope we are describing.
Definition: ScopeInfo.h:107
Scope * TheScope
This is the enclosing scope of the captured region.
Definition: ScopeInfo.h:729
llvm::SmallSet< Expr *, 8 > NonODRUsedCapturingExprs
Contains all variable-referring-expressions that refer to local variables that are usable as constant...
Definition: ScopeInfo.h:834
SourceLocation FirstSEHTryLoc
First SEH &#39;__try&#39; statement in the current function.
Definition: ScopeInfo.h:173
bool operator==(const WeakObjectProfileTy &Other) const
Definition: ScopeInfo.h:283
DiagnosticErrorTrap ErrorTrap
Used to determine if errors occurred in this function or block.
Definition: ScopeInfo.h:176
bool isThisCapture() const
Definition: ScopeInfo.h:544
Expr * getInitExpr() const
Definition: ScopeInfo.h:596
CompoundScopeInfo(bool IsStmtExpr)
Definition: ScopeInfo.h:76
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
WeakUseTy(const Expr *Use, bool IsRead)
Definition: ScopeInfo.h:325
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
QualType FunctionType
BlockType - The function type of the block, if one was given.
Definition: ScopeInfo.h:704
void finishedExplicitCaptures()
Note when all explicit captures have been added.
Definition: ScopeInfo.h:856
bool IsStmtExpr
Whether this compound statement corresponds to a GNU statement expression.
Definition: ScopeInfo.h:74
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
FunctionScopeInfo(DiagnosticsEngine &Diag)
Definition: ScopeInfo.h:358
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4013
PossiblyUnreachableDiag(const PartialDiagnostic &PD, SourceLocation Loc, const Stmt *stmt)
Definition: ScopeInfo.h:89
SmallVector< TemplateTypeParmDecl *, 4 > AutoTemplateParams
Store the list of the auto parameters for a generic lambda.
Definition: ScopeInfo.h:808
Contains information about the compound statement currently being parsed.
Definition: ScopeInfo.h:66
SourceLocation FirstCXXTryLoc
First C++ &#39;try&#39; statement in the current function.
Definition: ScopeInfo.h:170
CleanupInfo Cleanup
Whether any of the capture expressions requires cleanups.
Definition: ScopeInfo.h:794
ImplicitCaptureStyle ImpCaptureStyle
Definition: ScopeInfo.h:612
void addPotentialCapture(Expr *VarExpr)
Add a variable that might potentially be captured by the lambda and therefore the enclosing lambdas...
Definition: ScopeInfo.h:887
void markVariableExprAsNonODRUsed(Expr *CapturingVarExpr)
Mark a variable&#39;s reference in a lambda as non-odr using.
Definition: ScopeInfo.h:939
SmallVector< ReturnStmt *, 4 > Returns
The list of return statements that occur within the function or block, if there is any chance of appl...
Definition: ScopeInfo.h:189
Retains information about a captured region.
Definition: ScopeInfo.h:720
void recordUseOfWeak(const ExprT *E, bool IsRead=true)
Record that a weak object was accessed.
Definition: ScopeInfo.h:984
SourceLocation getEllipsisLoc() const
Retrieve the source location of the ellipsis, whose presence indicates that the capture is a pack exp...
Definition: ScopeInfo.h:586
SourceLocation PotentialThisCaptureLocation
Definition: ScopeInfo.h:848
CapturedRegionScopeInfo(DiagnosticsEngine &Diag, Scope *S, CapturedDecl *CD, RecordDecl *RD, ImplicitParamDecl *Context, CapturedRegionKind K, unsigned OpenMPLevel)
Definition: ScopeInfo.h:739
bool isVariableCapture() const
Definition: ScopeInfo.h:548
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:694
Pepresents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3835
This represents one expression.
Definition: Expr.h:105
void removePotentialCapture(Expr *E)
Definition: ScopeInfo.h:949
SmallVector< SwitchInfo, 8 > SwitchStack
SwitchStack - This is the current set of active switch statements in the block.
Definition: ScopeInfo.h:184
bool HasBranchProtectedScope
Whether this function contains a VLA, @try, try, C++ initializer, or anything else that can&#39;t be jump...
Definition: ScopeInfo.h:111
llvm::DenseMap< unsigned, SourceRange > ExplicitCaptureRanges
A map of explicit capture indices to their introducer source ranges.
Definition: ScopeInfo.h:837
bool isCaptured(VarDecl *Var) const
Determine whether the given variable has been captured.
Definition: ScopeInfo.h:666
Capture & getCapture(VarDecl *Var)
Retrieve the capture of the given variable, if it has been captured already.
Definition: ScopeInfo.h:675
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:904
void setHasCXXTry(SourceLocation TryLoc)
Definition: ScopeInfo.h:413
unsigned short CapRegionKind
The kind of captured region.
Definition: ScopeInfo.h:735
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
Definition: ScopeInfo.h:582
CapturingScopeInfo(DiagnosticsEngine &Diag, ImplicitCaptureStyle Style)
Definition: ScopeInfo.h:614
#define false
Definition: stdbool.h:33
Kind
VarDecl * getVariable() const
Definition: ScopeInfo.h:576
void setHasSEHTry(SourceLocation TryLoc)
Definition: ScopeInfo.h:418
bool HasPotentialAvailabilityViolations
Whether we make reference to a declaration that could be unavailable.
Definition: ScopeInfo.h:130
Encodes a location in the source.
bool ObjCWarnForNoDesignatedInitChain
This starts true for a method marked as designated initializer and will be set to false if there is a...
Definition: ScopeInfo.h:143
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2043
bool isVLATypeCapture() const
Definition: ScopeInfo.h:564
SmallVector< Capture, 4 > Captures
Captures - The captures.
Definition: ScopeInfo.h:625
SourceLocation FirstCoroutineStmtLoc
First coroutine statement in the current function.
Definition: ScopeInfo.h:164
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:721
void addPotentialThisCapture(SourceLocation Loc)
Definition: ScopeInfo.h:892
bool ObjCIsDesignatedInit
True when this is a method marked as a designated initializer.
Definition: ScopeInfo.h:138
bool ObjCShouldCallSuper
A flag that is set when parsing a method that must call super&#39;s implementation, such as -dealloc...
Definition: ScopeInfo.h:135
SourceLocation CaptureDefaultLoc
Source location of the &#39;&&#39; or &#39;=&#39; specifying the default capture type, if any.
Definition: ScopeInfo.h:781
bool HasOMPDeclareReductionCombiner
True if current scope is for OpenMP declare reduction combiner.
Definition: ScopeInfo.h:123
llvm::SmallVector< Expr *, 4 > PotentiallyCapturingExprs
Contains all variable-referring-expressions (i.e.
Definition: ScopeInfo.h:828
bool isGenericLambda() const
Is this scope known to be for a generic lambda? (This will be false until we parse the first &#39;auto&#39;-t...
Definition: ScopeInfo.h:866
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
bool ObjCIsSecondaryInit
True when this is an initializer method not marked as a designated initializer within a class that ha...
Definition: ScopeInfo.h:148
bool HasIndirectGoto
Whether this function contains any indirect gotos.
Definition: ScopeInfo.h:117
const Capture & getCapture(VarDecl *Var) const
Definition: ScopeInfo.h:680
StringRef getRegionName() const
A descriptive name for the kind of captured region this is.
Definition: ScopeInfo.h:751
Represents a simple identification of a weak object.
Definition: ScopeInfo.h:237
bool ObjCWarnForNoInitDelegation
This starts true for a secondary initializer method and will be set to false if there is an invocatio...
Definition: ScopeInfo.h:152
BlockScopeInfo(DiagnosticsEngine &Diag, Scope *BlockScope, BlockDecl *Block)
Definition: ScopeInfo.h:706
LambdaScopeInfo(DiagnosticsEngine &Diag)
Definition: ScopeInfo.h:850
SourceLocation FirstReturnLoc
First &#39;return&#39; statement in the current function.
Definition: ScopeInfo.h:167
Contains all of the variables defined in this lambda that shadow variables that were defined in paren...
Definition: ScopeInfo.h:842
RecordDecl * TheRecordDecl
The captured record type.
Definition: ScopeInfo.h:726
bool isReferenceCapture() const
Definition: ScopeInfo.h:556
void setFirstCoroutineStmt(SourceLocation Loc, StringRef Keyword)
Definition: ScopeInfo.h:431
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
llvm::DenseMap< VarDecl *, unsigned > CaptureMap
CaptureMap - A map of captured variables to (index+1) into Captures.
Definition: ScopeInfo.h:618
unsigned getNumPotentialVariableCaptures() const
Definition: ScopeInfo.h:959
Capture & getCXXThisCapture()
Retrieve the capture of C++ &#39;this&#39;, if it has been captured.
Definition: ScopeInfo.h:660
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:513
static bool isEqual(const WeakObjectProfileTy &LHS, const WeakObjectProfileTy &RHS)
Definition: ScopeInfo.h:308
Defines the clang::SourceLocation class and associated facilities.
SmallVector< PossiblyUnreachableDiag, 4 > PossiblyUnreachableDiags
A list of PartialDiagnostics created but delayed within the current function scope.
Definition: ScopeInfo.h:208
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
void markUsed(bool IsODRUse)
Definition: ScopeInfo.h:574
bool isNested() const
Definition: ScopeInfo.h:568
Capture(IsThisCapture, bool IsNested, SourceLocation Loc, QualType CaptureType, Expr *Cpy, const bool ByCopy)
Definition: ScopeInfo.h:537
static bool classof(const FunctionScopeInfo *FSI)
Definition: ScopeInfo.h:714
llvm::SmallPtrSet< const ParmVarDecl *, 8 > ModifiedNonNullParams
A list of parameters which have the nonnull attribute and are modified in the function.
Definition: ScopeInfo.h:212
bool isCXXThisCaptured() const
Determine whether the C++ &#39;this&#39; is captured.
Definition: ScopeInfo.h:657
void addVLATypeCapture(SourceLocation Loc, QualType CaptureType)
Definition: ScopeInfo.h:643
Represents a single use of a weak object.
Definition: ScopeInfo.h:321
Scope * TheScope
TheScope - This is the scope for the block itself, which contains arguments etc.
Definition: ScopeInfo.h:700
llvm::SmallDenseMap< WeakObjectProfileTy, WeakUseVector, 8, WeakObjectProfileTy::DenseMapInfo > WeakObjectUseMap
Used to collect all uses of weak objects in a function body.
Definition: ScopeInfo.h:346
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:971
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:17
bool isNonODRUsed() const
Definition: ScopeInfo.h:573
void addCapture(VarDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, Expr *Cpy)
Definition: ScopeInfo.h:635
bool hasInvalidCoroutineSuspends() const
Definition: ScopeInfo.h:459
ImplicitParamDecl * ContextParam
The implicit parameter for the captured variables.
Definition: ScopeInfo.h:732
SmallVector< CompoundScopeInfo, 4 > CompoundScopes
The stack of currently active compound stamement scopes in the function.
Definition: ScopeInfo.h:203
bool isExactProfile() const
Returns true if the object base specifies a known object in memory, rather than, say, an instance variable or property of another object.
Definition: ScopeInfo.h:279
#define true
Definition: stdbool.h:32
A trivial tuple used to represent a source range.
This represents a decl that may have a name.
Definition: Decl.h:248
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2945
Capture(VarDecl *Var, bool Block, bool ByRef, bool IsNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, Expr *Cpy)
Definition: ScopeInfo.h:527
bool HasBranchIntoScope
Whether this function contains any switches or direct gotos.
Definition: ScopeInfo.h:114
bool isBlockCapture() const
Definition: ScopeInfo.h:560
const FormatStyle & Style
void setCoroutineSuspends(Stmt *Initial, Stmt *Final)
Definition: ScopeInfo.h:463