clang 19.0.0git
CallEvent.h
Go to the documentation of this file.
1//===- CallEvent.h - Wrapper for all function and method calls --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file This file defines CallEvent and its subclasses, which represent path-
10/// sensitive instances of different kinds of function and method calls
11/// (C, C++, and Objective-C).
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CALLEVENT_H
16#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CALLEVENT_H
17
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclBase.h"
20#include "clang/AST/DeclCXX.h"
21#include "clang/AST/DeclObjC.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/ExprCXX.h"
24#include "clang/AST/ExprObjC.h"
25#include "clang/AST/Stmt.h"
26#include "clang/AST/Type.h"
28#include "clang/Basic/LLVM.h"
35#include "llvm/ADT/ArrayRef.h"
36#include "llvm/ADT/IntrusiveRefCntPtr.h"
37#include "llvm/ADT/PointerIntPair.h"
38#include "llvm/ADT/PointerUnion.h"
39#include "llvm/ADT/STLExtras.h"
40#include "llvm/ADT/SmallVector.h"
41#include "llvm/ADT/StringRef.h"
42#include "llvm/ADT/iterator_range.h"
43#include "llvm/Support/Allocator.h"
44#include "llvm/Support/Casting.h"
45#include "llvm/Support/ErrorHandling.h"
46#include <cassert>
47#include <limits>
48#include <optional>
49#include <utility>
50
51namespace clang {
52
53class LocationContext;
54class ProgramPoint;
55class ProgramPointTag;
56class StackFrameContext;
57
58namespace ento {
59
78};
79
80class CallEvent;
81
82template <typename T = CallEvent>
83class CallEventRef : public IntrusiveRefCntPtr<const T> {
84public:
86 CallEventRef(const CallEventRef &Orig) : IntrusiveRefCntPtr<const T>(Orig) {}
87
88 // The copy assignment operator is defined as deleted pending further
89 // motivation.
91
93 return this->get()->template cloneWithState<T>(State);
94 }
95
96 // Allow implicit conversions to a superclass type, since CallEventRef
97 // behaves like a pointer-to-const.
98 template <typename SuperT> operator CallEventRef<SuperT>() const {
99 return this->get();
100 }
101};
102
103/// \class RuntimeDefinition
104/// Defines the runtime definition of the called function.
105///
106/// Encapsulates the information we have about which Decl will be used
107/// when the call is executed on the given path. When dealing with dynamic
108/// dispatch, the information is based on DynamicTypeInfo and might not be
109/// precise.
111 /// The Declaration of the function which could be called at runtime.
112 /// NULL if not available.
113 const Decl *D = nullptr;
114
115 /// The region representing an object (ObjC/C++) on which the method is
116 /// called. With dynamic dispatch, the method definition depends on the
117 /// runtime type of this object. NULL when the DynamicTypeInfo is
118 /// precise.
119 const MemRegion *R = nullptr;
120
121 /// A definition is foreign if it has been imported and newly created by the
122 /// ASTImporter. This can be true only if CTU is enabled.
123 const bool Foreign = false;
124
125public:
126 RuntimeDefinition() = default;
127 RuntimeDefinition(const Decl *InD) : D(InD) {}
128 RuntimeDefinition(const Decl *InD, bool Foreign) : D(InD), Foreign(Foreign) {}
129 RuntimeDefinition(const Decl *InD, const MemRegion *InR) : D(InD), R(InR) {}
130
131 const Decl *getDecl() { return D; }
132 bool isForeign() const { return Foreign; }
133
134 /// Check if the definition we have is precise.
135 /// If not, it is possible that the call dispatches to another definition at
136 /// execution time.
137 bool mayHaveOtherDefinitions() { return R != nullptr; }
138
139 /// When other definitions are possible, returns the region whose runtime type
140 /// determines the method definition.
141 const MemRegion *getDispatchRegion() { return R; }
142};
143
144/// Represents an abstract call to a function or method along a
145/// particular path.
146///
147/// CallEvents are created through the factory methods of CallEventManager.
148///
149/// CallEvents should always be cheap to create and destroy. In order for
150/// CallEventManager to be able to re-use CallEvent-sized memory blocks,
151/// subclasses of CallEvent may not add any data members to the base class.
152/// Use the "Data" and "Location" fields instead.
154public:
156
157private:
158 ProgramStateRef State;
159 const LocationContext *LCtx;
160 llvm::PointerUnion<const Expr *, const Decl *> Origin;
161 CFGBlock::ConstCFGElementRef ElemRef = {nullptr, 0};
162 mutable std::optional<bool> Foreign; // Set by CTU analysis.
163
164protected:
165 // This is user data for subclasses.
166 const void *Data;
167
168 // This is user data for subclasses.
169 // This should come right before RefCount, so that the two fields can be
170 // packed together on LP64 platforms.
172
173private:
174 template <typename T> friend struct llvm::IntrusiveRefCntPtrInfo;
175
176 mutable unsigned RefCount = 0;
177
178 void Retain() const { ++RefCount; }
179 void Release() const;
180
181protected:
182 friend class CallEventManager;
183
184 CallEvent(const Expr *E, ProgramStateRef state, const LocationContext *lctx,
186 : State(std::move(state)), LCtx(lctx), Origin(E), ElemRef(ElemRef) {}
187
188 CallEvent(const Decl *D, ProgramStateRef state, const LocationContext *lctx,
190 : State(std::move(state)), LCtx(lctx), Origin(D), ElemRef(ElemRef) {}
191
192 // DO NOT MAKE PUBLIC
193 CallEvent(const CallEvent &Original)
194 : State(Original.State), LCtx(Original.LCtx), Origin(Original.Origin),
195 ElemRef(Original.ElemRef), Data(Original.Data),
196 Location(Original.Location) {}
197
198 /// Copies this CallEvent, with vtable intact, into a new block of memory.
199 virtual void cloneTo(void *Dest) const = 0;
200
201 /// Get the value of arbitrary expressions at this point in the path.
202 SVal getSVal(const Stmt *S) const {
203 return getState()->getSVal(S, getLocationContext());
204 }
205
207
208 /// Used to specify non-argument regions that will be invalidated as a
209 /// result of this call.
210 virtual void
212 RegionAndSymbolInvalidationTraits *ETraits) const {}
213
214public:
215 CallEvent &operator=(const CallEvent &) = delete;
216 virtual ~CallEvent() = default;
217
218 /// Returns the kind of call this is.
219 virtual Kind getKind() const = 0;
220 virtual StringRef getKindAsString() const = 0;
221
222 /// Returns the declaration of the function or method that will be
223 /// called. May be null.
224 virtual const Decl *getDecl() const {
225 return Origin.dyn_cast<const Decl *>();
226 }
227
228 bool isForeign() const {
229 assert(Foreign && "Foreign must be set before querying");
230 return *Foreign;
231 }
232 void setForeign(bool B) const { Foreign = B; }
233
234 /// The state in which the call is being evaluated.
235 const ProgramStateRef &getState() const { return State; }
236
237 /// The context in which the call is being evaluated.
238 const LocationContext *getLocationContext() const { return LCtx; }
239
241 return ElemRef;
242 }
243
244 /// Returns the definition of the function or method that will be
245 /// called.
247
248 /// Returns the expression whose value will be the result of this call.
249 /// May be null.
250 virtual const Expr *getOriginExpr() const {
251 return Origin.dyn_cast<const Expr *>();
252 }
253
254 /// Returns the number of arguments (explicit and implicit).
255 ///
256 /// Note that this may be greater than the number of parameters in the
257 /// callee's declaration, and that it may include arguments not written in
258 /// the source.
259 virtual unsigned getNumArgs() const = 0;
260
261 /// Returns true if the callee is known to be from a system header.
262 bool isInSystemHeader() const {
263 const Decl *D = getDecl();
264 if (!D)
265 return false;
266
268 if (Loc.isValid()) {
269 const SourceManager &SM =
270 getState()->getStateManager().getContext().getSourceManager();
271 return SM.isInSystemHeader(D->getLocation());
272 }
273
274 // Special case for implicitly-declared global operator new/delete.
275 // These should be considered system functions.
276 if (const auto *FD = dyn_cast<FunctionDecl>(D))
277 return FD->isOverloadedOperator() && FD->isImplicit() && FD->isGlobal();
278
279 return false;
280 }
281
282 /// Returns a source range for the entire call, suitable for
283 /// outputting in diagnostics.
284 virtual SourceRange getSourceRange() const {
285 return getOriginExpr()->getSourceRange();
286 }
287
288 /// Returns the value of a given argument at the time of the call.
289 virtual SVal getArgSVal(unsigned Index) const;
290
291 /// Returns the expression associated with a given argument.
292 /// May be null if this expression does not appear in the source.
293 virtual const Expr *getArgExpr(unsigned Index) const { return nullptr; }
294
295 /// Returns the source range for errors associated with this argument.
296 ///
297 /// May be invalid if the argument is not written in the source.
298 virtual SourceRange getArgSourceRange(unsigned Index) const;
299
300 /// Returns the result type, adjusted for references.
301 QualType getResultType() const;
302
303 /// Returns the return value of the call.
304 ///
305 /// This should only be called if the CallEvent was created using a state in
306 /// which the return value has already been bound to the origin expression.
307 SVal getReturnValue() const;
308
309 /// Returns true if the type of any of the non-null arguments satisfies
310 /// the condition.
312
313 /// Returns true if any of the arguments appear to represent callbacks.
314 bool hasNonZeroCallbackArg() const;
315
316 /// Returns true if any of the arguments is void*.
317 bool hasVoidPointerToNonConstArg() const;
318
319 /// Returns true if any of the arguments are known to escape to long-
320 /// term storage, even if this method will not modify them.
321 // NOTE: The exact semantics of this are still being defined!
322 // We don't really want a list of hardcoded exceptions in the long run,
323 // but we don't want duplicated lists of known APIs in the short term either.
324 virtual bool argumentsMayEscape() const { return hasNonZeroCallbackArg(); }
325
326 /// Returns true if the callee is an externally-visible function in the
327 /// top-level namespace, such as \c malloc.
328 ///
329 /// You can use this call to determine that a particular function really is
330 /// a library function and not, say, a C++ member function with the same name.
331 ///
332 /// If a name is provided, the function must additionally match the given
333 /// name.
334 ///
335 /// Note that this deliberately excludes C++ library functions in the \c std
336 /// namespace, but will include C library functions accessed through the
337 /// \c std namespace. This also does not check if the function is declared
338 /// as 'extern "C"', or if it uses C++ name mangling.
339 // FIXME: Add a helper for checking namespaces.
340 // FIXME: Move this down to AnyFunctionCall once checkers have more
341 // precise callbacks.
342 bool isGlobalCFunction(StringRef SpecificName = StringRef()) const;
343
344 /// Returns the name of the callee, if its name is a simple identifier.
345 ///
346 /// Note that this will fail for Objective-C methods, blocks, and C++
347 /// overloaded operators. The former is named by a Selector rather than a
348 /// simple identifier, and the latter two do not have names.
349 // FIXME: Move this down to AnyFunctionCall once checkers have more
350 // precise callbacks.
352 const auto *ND = dyn_cast_or_null<NamedDecl>(getDecl());
353 if (!ND)
354 return nullptr;
355 return ND->getIdentifier();
356 }
357
358 /// Returns an appropriate ProgramPoint for this call.
359 ProgramPoint getProgramPoint(bool IsPreVisit = false,
360 const ProgramPointTag *Tag = nullptr) const;
361
362 /// Returns a new state with all argument regions invalidated.
363 ///
364 /// This accepts an alternate state in case some processing has already
365 /// occurred.
366 ProgramStateRef invalidateRegions(unsigned BlockCount,
367 ProgramStateRef Orig = nullptr) const;
368
369 using FrameBindingTy = std::pair<SVal, SVal>;
371
372 /// Populates the given SmallVector with the bindings in the callee's stack
373 /// frame at the start of this call.
374 virtual void getInitialStackFrameContents(const StackFrameContext *CalleeCtx,
375 BindingsTy &Bindings) const = 0;
376
377 /// Returns a copy of this CallEvent, but using the given state.
378 template <typename T>
380
381 /// Returns a copy of this CallEvent, but using the given state.
383 return cloneWithState<CallEvent>(NewState);
384 }
385
386 /// Returns true if this is a statement is a function or method call
387 /// of some kind.
388 static bool isCallStmt(const Stmt *S);
389
390 /// Returns the result type of a function or method declaration.
391 ///
392 /// This will return a null QualType if the result type cannot be determined.
393 static QualType getDeclaredResultType(const Decl *D);
394
395 /// Returns true if the given decl is known to be variadic.
396 ///
397 /// \p D must not be null.
398 static bool isVariadic(const Decl *D);
399
400 /// Returns AnalysisDeclContext for the callee stack frame.
401 /// Currently may fail; returns null on failure.
403
404 /// Returns the callee stack frame. That stack frame will only be entered
405 /// during analysis if the call is inlined, but it may still be useful
406 /// in intermediate calculations even if the call isn't inlined.
407 /// May fail; returns null on failure.
408 const StackFrameContext *getCalleeStackFrame(unsigned BlockCount) const;
409
410 /// Returns memory location for a parameter variable within the callee stack
411 /// frame. The behavior is undefined if the block count is different from the
412 /// one that is there when call happens. May fail; returns null on failure.
413 const ParamVarRegion *getParameterLocation(unsigned Index,
414 unsigned BlockCount) const;
415
416 /// Returns true if on the current path, the argument was constructed by
417 /// calling a C++ constructor over it. This is an internal detail of the
418 /// analysis which doesn't necessarily represent the program semantics:
419 /// if we are supposed to construct an argument directly, we may still
420 /// not do that because we don't know how (i.e., construction context is
421 /// unavailable in the CFG or not supported by the analyzer).
422 bool isArgumentConstructedDirectly(unsigned Index) const {
423 // This assumes that the object was not yet removed from the state.
426 .has_value();
427 }
428
429 /// Some calls have parameter numbering mismatched from argument numbering.
430 /// This function converts an argument index to the corresponding
431 /// parameter index. Returns std::nullopt is the argument doesn't correspond
432 /// to any parameter variable.
433 virtual std::optional<unsigned>
434 getAdjustedParameterIndex(unsigned ASTArgumentIndex) const {
435 return ASTArgumentIndex;
436 }
437
438 /// Some call event sub-classes conveniently adjust mismatching AST indices
439 /// to match parameter indices. This function converts an argument index
440 /// as understood by CallEvent to the argument index as understood by the AST.
441 virtual unsigned getASTArgumentIndex(unsigned CallArgumentIndex) const {
442 return CallArgumentIndex;
443 }
444
445 /// Returns the construction context of the call, if it is a C++ constructor
446 /// call or a call of a function returning a C++ class instance. Otherwise
447 /// return nullptr.
449
450 /// If the call returns a C++ record type then the region of its return value
451 /// can be retrieved from its construction context.
452 std::optional<SVal> getReturnValueUnderConstruction() const;
453
454 // Returns the CallEvent representing the caller of this function
455 const CallEventRef<> getCaller() const;
456
457 // Returns true if the function was called from a standard library function.
458 // If not or could not get the caller (it may be a top level function)
459 // returns false.
460 bool isCalledFromSystemHeader() const;
461
462 // Iterator access to formal parameters and their types.
463private:
464 struct GetTypeFn {
465 QualType operator()(ParmVarDecl *PD) const { return PD->getType(); }
466 };
467
468public:
469 /// Return call's formal parameters.
470 ///
471 /// Remember that the number of formal parameters may not match the number
472 /// of arguments for all calls. However, the first parameter will always
473 /// correspond with the argument value returned by \c getArgSVal(0).
475
477 llvm::mapped_iterator<ArrayRef<ParmVarDecl *>::iterator, GetTypeFn>;
478
479 /// Returns an iterator over the types of the call's formal parameters.
480 ///
481 /// This uses the callee decl found by default name lookup rather than the
482 /// definition because it represents a public interface, and probably has
483 /// more annotations.
485 return llvm::map_iterator(parameters().begin(), GetTypeFn());
486 }
487 /// \sa param_type_begin()
489 return llvm::map_iterator(parameters().end(), GetTypeFn());
490 }
491
492 // For debugging purposes only
493 void dump(raw_ostream &Out) const;
494 void dump() const;
495};
496
497/// Represents a call to any sort of function that might have a
498/// FunctionDecl.
500protected:
502 const LocationContext *LCtx,
504 : CallEvent(E, St, LCtx, ElemRef) {}
506 const LocationContext *LCtx,
508 : CallEvent(D, St, LCtx, ElemRef) {}
510
511public:
512 // This function is overridden by subclasses, but they must return
513 // a FunctionDecl.
514 const FunctionDecl *getDecl() const override {
515 return cast<FunctionDecl>(CallEvent::getDecl());
516 }
517
519
520 bool argumentsMayEscape() const override;
521
523 BindingsTy &Bindings) const override;
524
525 ArrayRef<ParmVarDecl *> parameters() const override;
526
527 static bool classof(const CallEvent *CA) {
528 return CA->getKind() >= CE_BEG_FUNCTION_CALLS &&
530 }
531};
532
533/// Represents a C function or static C++ member function call.
534///
535/// Example: \c fun()
537 friend class CallEventManager;
538
539protected:
541 const LocationContext *LCtx,
543 : AnyFunctionCall(CE, St, LCtx, ElemRef) {}
545
546 void cloneTo(void *Dest) const override {
547 new (Dest) SimpleFunctionCall(*this);
548 }
549
550public:
551 const CallExpr *getOriginExpr() const override {
552 return cast<CallExpr>(AnyFunctionCall::getOriginExpr());
553 }
554
555 const FunctionDecl *getDecl() const override;
556
557 unsigned getNumArgs() const override { return getOriginExpr()->getNumArgs(); }
558
559 const Expr *getArgExpr(unsigned Index) const override {
560 return getOriginExpr()->getArg(Index);
561 }
562
563 Kind getKind() const override { return CE_Function; }
564 StringRef getKindAsString() const override { return "SimpleFunctionCall"; }
565
566 static bool classof(const CallEvent *CA) {
567 return CA->getKind() == CE_Function;
568 }
569};
570
571/// Represents a call to a block.
572///
573/// Example: <tt>^{ statement-body }()</tt>
574class BlockCall : public CallEvent {
575 friend class CallEventManager;
576
577protected:
580 : CallEvent(CE, St, LCtx, ElemRef) {}
581 BlockCall(const BlockCall &Other) = default;
582
583 void cloneTo(void *Dest) const override { new (Dest) BlockCall(*this); }
584
586 ValueList &Values,
587 RegionAndSymbolInvalidationTraits *ETraits) const override;
588
589public:
590 const CallExpr *getOriginExpr() const override {
591 return cast<CallExpr>(CallEvent::getOriginExpr());
592 }
593
594 unsigned getNumArgs() const override { return getOriginExpr()->getNumArgs(); }
595
596 const Expr *getArgExpr(unsigned Index) const override {
597 return getOriginExpr()->getArg(Index);
598 }
599
600 /// Returns the region associated with this instance of the block.
601 ///
602 /// This may be NULL if the block's origin is unknown.
603 const BlockDataRegion *getBlockRegion() const;
604
605 const BlockDecl *getDecl() const override {
606 const BlockDataRegion *BR = getBlockRegion();
607 if (!BR)
608 return nullptr;
609 return BR->getDecl();
610 }
611
613 const BlockDecl *BD = getDecl();
614 if (!BD)
615 return false;
616
617 return BD->isConversionFromLambda();
618 }
619
620 /// For a block converted from a C++ lambda, returns the block
621 /// VarRegion for the variable holding the captured C++ lambda record.
623 assert(isConversionFromLambda());
624 const BlockDataRegion *BR = getBlockRegion();
625 assert(BR && "Block converted from lambda must have a block region");
626
627 auto ReferencedVars = BR->referenced_vars();
628 assert(!ReferencedVars.empty());
629 return ReferencedVars.begin().getCapturedRegion();
630 }
631
634 return RuntimeDefinition(getDecl());
635
636 // Clang converts lambdas to blocks with an implicit user-defined
637 // conversion operator method on the lambda record that looks (roughly)
638 // like:
639 //
640 // typedef R(^block_type)(P1, P2, ...);
641 // operator block_type() const {
642 // auto Lambda = *this;
643 // return ^(P1 p1, P2 p2, ...){
644 // /* return Lambda(p1, p2, ...); */
645 // };
646 // }
647 //
648 // Here R is the return type of the lambda and P1, P2, ... are
649 // its parameter types. 'Lambda' is a fake VarDecl captured by the block
650 // that is initialized to a copy of the lambda.
651 //
652 // Sema leaves the body of a lambda-converted block empty (it is
653 // produced by CodeGen), so we can't analyze it directly. Instead, we skip
654 // the block body and analyze the operator() method on the captured lambda.
655 const VarDecl *LambdaVD = getRegionStoringCapturedLambda()->getDecl();
656 const CXXRecordDecl *LambdaDecl = LambdaVD->getType()->getAsCXXRecordDecl();
657 CXXMethodDecl *LambdaCallOperator = LambdaDecl->getLambdaCallOperator();
658
659 return RuntimeDefinition(LambdaCallOperator);
660 }
661
662 bool argumentsMayEscape() const override { return true; }
663
665 BindingsTy &Bindings) const override;
666
667 ArrayRef<ParmVarDecl *> parameters() const override;
668
669 Kind getKind() const override { return CE_Block; }
670 StringRef getKindAsString() const override { return "BlockCall"; }
671
672 static bool classof(const CallEvent *CA) { return CA->getKind() == CE_Block; }
673};
674
675/// Represents a non-static C++ member function call, no matter how
676/// it is written.
678protected:
680 const LocationContext *LCtx,
682 : AnyFunctionCall(CE, St, LCtx, ElemRef) {}
684 const LocationContext *LCtx,
686 : AnyFunctionCall(D, St, LCtx, ElemRef) {}
688
690 ValueList &Values,
691 RegionAndSymbolInvalidationTraits *ETraits) const override;
692
693public:
694 /// Returns the expression representing the implicit 'this' object.
695 virtual const Expr *getCXXThisExpr() const { return nullptr; }
696
697 /// Returns the value of the implicit 'this' object.
698 virtual SVal getCXXThisVal() const;
699
700 const FunctionDecl *getDecl() const override;
701
703
705 BindingsTy &Bindings) const override;
706
707 static bool classof(const CallEvent *CA) {
708 return CA->getKind() >= CE_BEG_CXX_INSTANCE_CALLS &&
710 }
711};
712
713/// Represents a static C++ operator call.
714///
715/// "A" in this example.
716/// However, "B" and "C" are represented by SimpleFunctionCall.
717/// \code
718/// struct S {
719/// int pad;
720/// static void operator()(int x, int y);
721/// };
722/// S s{10};
723/// void (*fptr)(int, int) = &S::operator();
724///
725/// s(1, 2); // A
726/// S::operator()(1, 2); // B
727/// fptr(1, 2); // C
728/// \endcode
730 friend class CallEventManager;
731
732protected:
734 const LocationContext *LCtx,
736 : SimpleFunctionCall(CE, St, LCtx, ElemRef) {}
738
739 void cloneTo(void *Dest) const override {
740 new (Dest) CXXStaticOperatorCall(*this);
741 }
742
743public:
744 const CXXOperatorCallExpr *getOriginExpr() const override {
745 return cast<CXXOperatorCallExpr>(SimpleFunctionCall::getOriginExpr());
746 }
747
748 unsigned getNumArgs() const override {
749 // Ignore the object parameter that is not used for static member functions.
750 assert(getOriginExpr()->getNumArgs() > 0);
751 return getOriginExpr()->getNumArgs() - 1;
752 }
753
754 const Expr *getArgExpr(unsigned Index) const override {
755 // Ignore the object parameter that is not used for static member functions.
756 return getOriginExpr()->getArg(Index + 1);
757 }
758
759 std::optional<unsigned>
760 getAdjustedParameterIndex(unsigned ASTArgumentIndex) const override {
761 // Ignore the object parameter that is not used for static member functions.
762 if (ASTArgumentIndex == 0)
763 return std::nullopt;
764 return ASTArgumentIndex - 1;
765 }
766
767 unsigned getASTArgumentIndex(unsigned CallArgumentIndex) const override {
768 // Account for the object parameter for the static member function.
769 return CallArgumentIndex + 1;
770 }
771
773 return getOriginExpr()->getOperator();
774 }
775
776 Kind getKind() const override { return CE_CXXStaticOperator; }
777 StringRef getKindAsString() const override { return "CXXStaticOperatorCall"; }
778
779 static bool classof(const CallEvent *CA) {
780 return CA->getKind() == CE_CXXStaticOperator;
781 }
782};
783
784/// Represents a non-static C++ member function call.
785///
786/// Example: \c obj.fun()
788 friend class CallEventManager;
789
790protected:
792 const LocationContext *LCtx,
794 : CXXInstanceCall(CE, St, LCtx, ElemRef) {}
796
797 void cloneTo(void *Dest) const override { new (Dest) CXXMemberCall(*this); }
798
799public:
800 const CXXMemberCallExpr *getOriginExpr() const override {
801 return cast<CXXMemberCallExpr>(CXXInstanceCall::getOriginExpr());
802 }
803
804 unsigned getNumArgs() const override {
805 if (const CallExpr *CE = getOriginExpr())
806 return CE->getNumArgs();
807 return 0;
808 }
809
810 const Expr *getArgExpr(unsigned Index) const override {
811 return getOriginExpr()->getArg(Index);
812 }
813
814 const Expr *getCXXThisExpr() const override;
815
817
818 Kind getKind() const override { return CE_CXXMember; }
819 StringRef getKindAsString() const override { return "CXXMemberCall"; }
820
821 static bool classof(const CallEvent *CA) {
822 return CA->getKind() == CE_CXXMember;
823 }
824};
825
826/// Represents a C++ overloaded operator call where the operator is
827/// implemented as a non-static member function.
828///
829/// Example: <tt>iter + 1</tt>
831 friend class CallEventManager;
832
833protected:
835 const LocationContext *LCtx,
837 : CXXInstanceCall(CE, St, LCtx, ElemRef) {}
839
840 void cloneTo(void *Dest) const override {
841 new (Dest) CXXMemberOperatorCall(*this);
842 }
843
844public:
845 const CXXOperatorCallExpr *getOriginExpr() const override {
846 return cast<CXXOperatorCallExpr>(CXXInstanceCall::getOriginExpr());
847 }
848
849 unsigned getNumArgs() const override {
850 return getOriginExpr()->getNumArgs() - 1;
851 }
852
853 const Expr *getArgExpr(unsigned Index) const override {
854 return getOriginExpr()->getArg(Index + 1);
855 }
856
857 const Expr *getCXXThisExpr() const override;
858
859 Kind getKind() const override { return CE_CXXMemberOperator; }
860 StringRef getKindAsString() const override { return "CXXMemberOperatorCall"; }
861
862 static bool classof(const CallEvent *CA) {
863 return CA->getKind() == CE_CXXMemberOperator;
864 }
865
866 std::optional<unsigned>
867 getAdjustedParameterIndex(unsigned ASTArgumentIndex) const override {
868 // For member operator calls argument 0 on the expression corresponds
869 // to implicit this-parameter on the declaration.
870 return (ASTArgumentIndex > 0)
871 ? std::optional<unsigned>(ASTArgumentIndex - 1)
872 : std::nullopt;
873 }
874
875 unsigned getASTArgumentIndex(unsigned CallArgumentIndex) const override {
876 // For member operator calls argument 0 on the expression corresponds
877 // to implicit this-parameter on the declaration.
878 return CallArgumentIndex + 1;
879 }
880
882 return getOriginExpr()->getOperator();
883 }
884};
885
886/// Represents an implicit call to a C++ destructor.
887///
888/// This can occur at the end of a scope (for automatic objects), at the end
889/// of a full-expression (for temporaries), or as part of a delete.
891 friend class CallEventManager;
892
893protected:
894 using DtorDataTy = llvm::PointerIntPair<const MemRegion *, 1, bool>;
895
896 /// Creates an implicit destructor.
897 ///
898 /// \param DD The destructor that will be called.
899 /// \param Trigger The statement whose completion causes this destructor call.
900 /// \param Target The object region to be destructed.
901 /// \param St The path-sensitive state at this point in the program.
902 /// \param LCtx The location context at this point in the program.
903 /// \param ElemRef The reference to this destructor in the CFG.
904 ///
905 /// FIXME: Eventually we want to drop \param Target and deduce it from
906 /// \param ElemRef. To do that we need to migrate the logic for target
907 /// region lookup from ExprEngine::ProcessImplicitDtor() and make it
908 /// independent from ExprEngine.
909 CXXDestructorCall(const CXXDestructorDecl *DD, const Stmt *Trigger,
910 const MemRegion *Target, bool IsBaseDestructor,
911 ProgramStateRef St, const LocationContext *LCtx,
913 : CXXInstanceCall(DD, St, LCtx, ElemRef) {
914 Data = DtorDataTy(Target, IsBaseDestructor).getOpaqueValue();
915 Location = Trigger->getEndLoc();
916 }
917
919
920 void cloneTo(void *Dest) const override {
921 new (Dest) CXXDestructorCall(*this);
922 }
923
924public:
925 SourceRange getSourceRange() const override { return Location; }
926 unsigned getNumArgs() const override { return 0; }
927
929
930 /// Returns the value of the implicit 'this' object.
931 SVal getCXXThisVal() const override;
932
933 /// Returns true if this is a call to a base class destructor.
934 bool isBaseDestructor() const {
935 return DtorDataTy::getFromOpaqueValue(Data).getInt();
936 }
937
938 Kind getKind() const override { return CE_CXXDestructor; }
939 StringRef getKindAsString() const override { return "CXXDestructorCall"; }
940
941 static bool classof(const CallEvent *CA) {
942 return CA->getKind() == CE_CXXDestructor;
943 }
944};
945
946/// Represents any constructor invocation. This includes regular constructors
947/// and inherited constructors.
949protected:
951 ProgramStateRef St, const LocationContext *LCtx,
953 : AnyFunctionCall(E, St, LCtx, ElemRef) {
954 assert(E && (isa<CXXConstructExpr>(E) || isa<CXXInheritedCtorInitExpr>(E)));
955 // Target may be null when the region is unknown.
956 Data = Target;
957 }
958
960 ValueList &Values,
961 RegionAndSymbolInvalidationTraits *ETraits) const override;
962
964 BindingsTy &Bindings) const override;
965
966public:
967 /// Returns the value of the implicit 'this' object.
968 SVal getCXXThisVal() const;
969
970 static bool classof(const CallEvent *Call) {
971 return Call->getKind() >= CE_BEG_CXX_CONSTRUCTOR_CALLS &&
973 }
974};
975
976/// Represents a call to a C++ constructor.
977///
978/// Example: \c T(1)
980 friend class CallEventManager;
981
982protected:
983 /// Creates a constructor call.
984 ///
985 /// \param CE The constructor expression as written in the source.
986 /// \param Target The region where the object should be constructed. If NULL,
987 /// a new symbolic region will be used.
988 /// \param St The path-sensitive state at this point in the program.
989 /// \param LCtx The location context at this point in the program.
990 /// \param ElemRef The reference to this constructor in the CFG.
991 ///
992 /// FIXME: Eventually we want to drop \param Target and deduce it from
993 /// \param ElemRef.
995 ProgramStateRef St, const LocationContext *LCtx,
997 : AnyCXXConstructorCall(CE, Target, St, LCtx, ElemRef) {}
998
1000
1001 void cloneTo(void *Dest) const override {
1002 new (Dest) CXXConstructorCall(*this);
1003 }
1004
1005public:
1006 const CXXConstructExpr *getOriginExpr() const override {
1007 return cast<CXXConstructExpr>(AnyFunctionCall::getOriginExpr());
1008 }
1009
1010 const CXXConstructorDecl *getDecl() const override {
1011 return getOriginExpr()->getConstructor();
1012 }
1013
1014 unsigned getNumArgs() const override { return getOriginExpr()->getNumArgs(); }
1015
1016 const Expr *getArgExpr(unsigned Index) const override {
1017 return getOriginExpr()->getArg(Index);
1018 }
1019
1020 Kind getKind() const override { return CE_CXXConstructor; }
1021 StringRef getKindAsString() const override { return "CXXConstructorCall"; }
1022
1023 static bool classof(const CallEvent *CA) {
1024 return CA->getKind() == CE_CXXConstructor;
1025 }
1026};
1027
1028/// Represents a call to a C++ inherited constructor.
1029///
1030/// Example: \c class T : public S { using S::S; }; T(1);
1031///
1032// Note, it is difficult to model the parameters. This is one of the reasons
1033// why we skip analysis of inheriting constructors as top-level functions.
1034// CXXInheritedCtorInitExpr doesn't take arguments and doesn't model parameter
1035// initialization because there is none: the arguments in the outer
1036// CXXConstructExpr directly initialize the parameters of the base class
1037// constructor, and no copies are made. (Making a copy of the parameter is
1038// incorrect, at least if it's done in an observable way.) The derived class
1039// constructor doesn't even exist in the formal model.
1040/// E.g., in:
1041///
1042/// struct X { X *p = this; ~X() {} };
1043/// struct A { A(X x) : b(x.p == &x) {} bool b; };
1044/// struct B : A { using A::A; };
1045/// B b = X{};
1046///
1047/// ... b.b is initialized to true.
1049 friend class CallEventManager;
1050
1051protected:
1053 const MemRegion *Target, ProgramStateRef St,
1054 const LocationContext *LCtx,
1056 : AnyCXXConstructorCall(CE, Target, St, LCtx, ElemRef) {}
1057
1059 default;
1060
1061 void cloneTo(void *Dest) const override {
1062 new (Dest) CXXInheritedConstructorCall(*this);
1063 }
1064
1065public:
1066 const CXXInheritedCtorInitExpr *getOriginExpr() const override {
1067 return cast<CXXInheritedCtorInitExpr>(AnyFunctionCall::getOriginExpr());
1068 }
1069
1070 const CXXConstructorDecl *getDecl() const override {
1071 return getOriginExpr()->getConstructor();
1072 }
1073
1074 /// Obtain the stack frame of the inheriting constructor. Argument expressions
1075 /// can be found on the call site of that stack frame.
1077
1078 /// Obtain the CXXConstructExpr for the sub-class that inherited the current
1079 /// constructor (possibly indirectly). It's the statement that contains
1080 /// argument expressions.
1082 return cast<CXXConstructExpr>(getInheritingStackFrame()->getCallSite());
1083 }
1084
1085 unsigned getNumArgs() const override {
1087 }
1088
1089 const Expr *getArgExpr(unsigned Index) const override {
1090 return getInheritingConstructor()->getArg(Index);
1091 }
1092
1093 SVal getArgSVal(unsigned Index) const override {
1094 return getState()->getSVal(
1095 getArgExpr(Index),
1096 getInheritingStackFrame()->getParent()->getStackFrame());
1097 }
1098
1099 Kind getKind() const override { return CE_CXXInheritedConstructor; }
1100 StringRef getKindAsString() const override {
1101 return "CXXInheritedConstructorCall";
1102 }
1103
1104 static bool classof(const CallEvent *CA) {
1105 return CA->getKind() == CE_CXXInheritedConstructor;
1106 }
1107};
1108
1109/// Represents the memory allocation call in a C++ new-expression.
1110///
1111/// This is a call to "operator new".
1113 friend class CallEventManager;
1114
1115protected:
1117 const LocationContext *LCtx,
1119 : AnyFunctionCall(E, St, LCtx, ElemRef) {}
1121
1122 void cloneTo(void *Dest) const override {
1123 new (Dest) CXXAllocatorCall(*this);
1124 }
1125
1126public:
1127 const CXXNewExpr *getOriginExpr() const override {
1128 return cast<CXXNewExpr>(AnyFunctionCall::getOriginExpr());
1129 }
1130
1131 const FunctionDecl *getDecl() const override {
1132 return getOriginExpr()->getOperatorNew();
1133 }
1134
1138 }
1139
1140 /// Number of non-placement arguments to the call. It is equal to 2 for
1141 /// C++17 aligned operator new() calls that have alignment implicitly
1142 /// passed as the second argument, and to 1 for other operator new() calls.
1143 unsigned getNumImplicitArgs() const {
1144 return getOriginExpr()->passAlignment() ? 2 : 1;
1145 }
1146
1147 unsigned getNumArgs() const override {
1149 }
1150
1151 bool isArray() const { return getOriginExpr()->isArray(); }
1152
1153 std::optional<const clang::Expr *> getArraySizeExpr() const {
1154 return getOriginExpr()->getArraySize();
1155 }
1156
1158 assert(isArray() && "The allocator call doesn't allocate and array!");
1159
1160 return getState()->getSVal(*getArraySizeExpr(), getLocationContext());
1161 }
1162
1163 const Expr *getArgExpr(unsigned Index) const override {
1164 // The first argument of an allocator call is the size of the allocation.
1165 if (Index < getNumImplicitArgs())
1166 return nullptr;
1168 }
1169
1170 /// Number of placement arguments to the operator new() call. For example,
1171 /// standard std::nothrow operator new and standard placement new both have
1172 /// 1 implicit argument (size) and 1 placement argument, while regular
1173 /// operator new() has 1 implicit argument and 0 placement arguments.
1174 const Expr *getPlacementArgExpr(unsigned Index) const {
1175 return getOriginExpr()->getPlacementArg(Index);
1176 }
1177
1178 Kind getKind() const override { return CE_CXXAllocator; }
1179 StringRef getKindAsString() const override { return "CXXAllocatorCall"; }
1180
1181 static bool classof(const CallEvent *CE) {
1182 return CE->getKind() == CE_CXXAllocator;
1183 }
1184};
1185
1186/// Represents the memory deallocation call in a C++ delete-expression.
1187///
1188/// This is a call to "operator delete".
1189// FIXME: CXXDeleteExpr isn't present for custom delete operators, or even for
1190// some those that are in the standard library, like the no-throw or align_val
1191// versions.
1192// Some pointers:
1193// http://lists.llvm.org/pipermail/cfe-dev/2020-April/065080.html
1194// clang/test/Analysis/cxx-dynamic-memory-analysis-order.cpp
1195// clang/unittests/StaticAnalyzer/CallEventTest.cpp
1197 friend class CallEventManager;
1198
1199protected:
1201 const LocationContext *LCtx,
1203 : AnyFunctionCall(E, St, LCtx, ElemRef) {}
1205
1206 void cloneTo(void *Dest) const override {
1207 new (Dest) CXXDeallocatorCall(*this);
1208 }
1209
1210public:
1211 const CXXDeleteExpr *getOriginExpr() const override {
1212 return cast<CXXDeleteExpr>(AnyFunctionCall::getOriginExpr());
1213 }
1214
1215 const FunctionDecl *getDecl() const override {
1216 return getOriginExpr()->getOperatorDelete();
1217 }
1218
1219 unsigned getNumArgs() const override { return getDecl()->getNumParams(); }
1220
1221 const Expr *getArgExpr(unsigned Index) const override {
1222 // CXXDeleteExpr's only have a single argument.
1223 return getOriginExpr()->getArgument();
1224 }
1225
1226 Kind getKind() const override { return CE_CXXDeallocator; }
1227 StringRef getKindAsString() const override { return "CXXDeallocatorCall"; }
1228
1229 static bool classof(const CallEvent *CE) {
1230 return CE->getKind() == CE_CXXDeallocator;
1231 }
1232};
1233
1234/// Represents the ways an Objective-C message send can occur.
1235//
1236// Note to maintainers: OCM_Message should always be last, since it does not
1237// need to fit in the Data field's low bits.
1239
1240/// Represents any expression that calls an Objective-C method.
1241///
1242/// This includes all of the kinds listed in ObjCMessageKind.
1244 friend class CallEventManager;
1245
1246 const PseudoObjectExpr *getContainingPseudoObjectExpr() const;
1247
1248protected:
1250 const LocationContext *LCtx,
1252 : CallEvent(Msg, St, LCtx, ElemRef) {
1253 Data = nullptr;
1254 }
1255
1257
1258 void cloneTo(void *Dest) const override { new (Dest) ObjCMethodCall(*this); }
1259
1261 ValueList &Values,
1262 RegionAndSymbolInvalidationTraits *ETraits) const override;
1263
1264 /// Check if the selector may have multiple definitions (may have overrides).
1265 virtual bool canBeOverridenInSubclass(ObjCInterfaceDecl *IDecl,
1266 Selector Sel) const;
1267
1268public:
1269 const ObjCMessageExpr *getOriginExpr() const override {
1270 return cast<ObjCMessageExpr>(CallEvent::getOriginExpr());
1271 }
1272
1273 const ObjCMethodDecl *getDecl() const override {
1274 return getOriginExpr()->getMethodDecl();
1275 }
1276
1277 unsigned getNumArgs() const override { return getOriginExpr()->getNumArgs(); }
1278
1279 const Expr *getArgExpr(unsigned Index) const override {
1280 return getOriginExpr()->getArg(Index);
1281 }
1282
1283 bool isInstanceMessage() const {
1284 return getOriginExpr()->isInstanceMessage();
1285 }
1286
1288 return getOriginExpr()->getMethodFamily();
1289 }
1290
1292
1293 SourceRange getSourceRange() const override;
1294
1295 /// Returns the value of the receiver at the time of this call.
1296 SVal getReceiverSVal() const;
1297
1298 /// Get the interface for the receiver.
1299 ///
1300 /// This works whether this is an instance message or a class message.
1301 /// However, it currently just uses the static type of the receiver.
1304 }
1305
1306 /// Checks if the receiver refers to 'self' or 'super'.
1307 bool isReceiverSelfOrSuper() const;
1308
1309 /// Returns how the message was written in the source (property access,
1310 /// subscript, or explicit message send).
1312
1313 /// Returns true if this property access or subscript is a setter (has the
1314 /// form of an assignment).
1315 bool isSetter() const {
1316 switch (getMessageKind()) {
1317 case OCM_Message:
1318 llvm_unreachable("This is not a pseudo-object access!");
1319 case OCM_PropertyAccess:
1320 return getNumArgs() > 0;
1321 case OCM_Subscript:
1322 return getNumArgs() > 1;
1323 }
1324 llvm_unreachable("Unknown message kind");
1325 }
1326
1327 // Returns the property accessed by this method, either explicitly via
1328 // property syntax or implicitly via a getter or setter method. Returns
1329 // nullptr if the call is not a prooperty access.
1331
1332 RuntimeDefinition getRuntimeDefinition() const override;
1333
1334 bool argumentsMayEscape() const override;
1335
1336 void getInitialStackFrameContents(const StackFrameContext *CalleeCtx,
1337 BindingsTy &Bindings) const override;
1338
1339 ArrayRef<ParmVarDecl *> parameters() const override;
1340
1341 Kind getKind() const override { return CE_ObjCMessage; }
1342 StringRef getKindAsString() const override { return "ObjCMethodCall"; }
1343
1344 static bool classof(const CallEvent *CA) {
1345 return CA->getKind() == CE_ObjCMessage;
1346 }
1347};
1348
1349/// Manages the lifetime of CallEvent objects.
1350///
1351/// CallEventManager provides a way to create arbitrary CallEvents "on the
1352/// stack" as if they were value objects by keeping a cache of CallEvent-sized
1353/// memory blocks. The CallEvents created by CallEventManager are only valid
1354/// for the lifetime of the OwnedCallEvent that holds them; right now these
1355/// objects cannot be copied and ownership cannot be transferred.
1357 friend class CallEvent;
1358
1359 llvm::BumpPtrAllocator &Alloc;
1361
1363
1364 void reclaim(const void *Memory) {
1365 Cache.push_back(const_cast<void *>(Memory));
1366 }
1367
1368 /// Returns memory that can be initialized as a CallEvent.
1369 void *allocate() {
1370 if (Cache.empty())
1371 return Alloc.Allocate<CallEventTemplateTy>();
1372 else
1373 return Cache.pop_back_val();
1374 }
1375
1376 template <typename T, typename Arg>
1377 T *create(Arg A, ProgramStateRef St, const LocationContext *LCtx,
1379 static_assert(sizeof(T) == sizeof(CallEventTemplateTy),
1380 "CallEvent subclasses are not all the same size");
1381 return new (allocate()) T(A, St, LCtx, ElemRef);
1382 }
1383
1384 template <typename T, typename Arg1, typename Arg2>
1385 T *create(Arg1 A1, Arg2 A2, ProgramStateRef St, const LocationContext *LCtx,
1387 static_assert(sizeof(T) == sizeof(CallEventTemplateTy),
1388 "CallEvent subclasses are not all the same size");
1389 return new (allocate()) T(A1, A2, St, LCtx, ElemRef);
1390 }
1391
1392 template <typename T, typename Arg1, typename Arg2, typename Arg3>
1393 T *create(Arg1 A1, Arg2 A2, Arg3 A3, ProgramStateRef St,
1394 const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef) {
1395 static_assert(sizeof(T) == sizeof(CallEventTemplateTy),
1396 "CallEvent subclasses are not all the same size");
1397 return new (allocate()) T(A1, A2, A3, St, LCtx, ElemRef);
1398 }
1399
1400 template <typename T, typename Arg1, typename Arg2, typename Arg3,
1401 typename Arg4>
1402 T *create(Arg1 A1, Arg2 A2, Arg3 A3, Arg4 A4, ProgramStateRef St,
1403 const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef) {
1404 static_assert(sizeof(T) == sizeof(CallEventTemplateTy),
1405 "CallEvent subclasses are not all the same size");
1406 return new (allocate()) T(A1, A2, A3, A4, St, LCtx, ElemRef);
1407 }
1408
1409public:
1410 CallEventManager(llvm::BumpPtrAllocator &alloc) : Alloc(alloc) {}
1411
1412 /// Gets an outside caller given a callee context.
1414 ProgramStateRef State);
1415
1416 /// Gets a call event for a function call, Objective-C method call,
1417 /// a 'new', or a 'delete' call.
1419 const LocationContext *LC,
1421
1423 const LocationContext *LCtx,
1425
1428 const LocationContext *LCtx,
1430 return create<ObjCMethodCall>(E, State, LCtx, ElemRef);
1431 }
1432
1435 ProgramStateRef State, const LocationContext *LCtx,
1437 return create<CXXConstructorCall>(E, Target, State, LCtx, ElemRef);
1438 }
1439
1442 const MemRegion *Target, ProgramStateRef State,
1443 const LocationContext *LCtx,
1445 return create<CXXInheritedConstructorCall>(E, Target, State, LCtx, ElemRef);
1446 }
1447
1450 const MemRegion *Target, bool IsBase,
1451 ProgramStateRef State, const LocationContext *LCtx,
1453 return create<CXXDestructorCall>(DD, Trigger, Target, IsBase, State, LCtx,
1454 ElemRef);
1455 }
1456
1459 const LocationContext *LCtx,
1461 return create<CXXAllocatorCall>(E, State, LCtx, ElemRef);
1462 }
1463
1466 const LocationContext *LCtx,
1468 return create<CXXDeallocatorCall>(E, State, LCtx, ElemRef);
1469 }
1470};
1471
1472template <typename T>
1474 assert(isa<T>(*this) && "Cloning to unrelated type");
1475 static_assert(sizeof(T) == sizeof(CallEvent),
1476 "Subclasses may not add fields");
1477
1478 if (NewState == State)
1479 return cast<T>(this);
1480
1481 CallEventManager &Mgr = State->getStateManager().getCallEventManager();
1482 T *Copy = static_cast<T *>(Mgr.allocate());
1483 cloneTo(Copy);
1484 assert(Copy->getKind() == this->getKind() && "Bad copy");
1485
1486 Copy->State = NewState;
1487 return Copy;
1488}
1489
1490inline void CallEvent::Release() const {
1491 assert(RefCount > 0 && "Reference count is already zero.");
1492 --RefCount;
1493
1494 if (RefCount > 0)
1495 return;
1496
1497 CallEventManager &Mgr = State->getStateManager().getCallEventManager();
1498 Mgr.reclaim(this);
1499
1500 this->~CallEvent();
1501}
1502
1503} // namespace ento
1504
1505} // namespace clang
1506
1507namespace llvm {
1508
1509// Support isa<>, cast<>, and dyn_cast<> for CallEventRef.
1510template <class T> struct simplify_type<clang::ento::CallEventRef<T>> {
1511 using SimpleType = const T *;
1512
1514 return Val.get();
1515 }
1516};
1517
1518} // namespace llvm
1519
1520#endif // LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_CALLEVENT_H
#define SM(sm)
Definition: Cuda.cpp:84
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
llvm::MachO::Target Target
Definition: MachO.h:50
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
TypePropertyCache< Private > Cache
Definition: Type.cpp:4470
C Language Family Type Representation.
AnalysisDeclContext contains the context data for the function, method or block under analysis.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4496
bool isConversionFromLambda() const
Definition: Decl.h:4639
ElementRefImpl< true > ConstCFGElementRef
Definition: CFG.h:915
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1542
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1685
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition: ExprCXX.h:1605
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Definition: ExprCXX.h:1682
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2535
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition: ExprCXX.h:2493
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:2532
Expr * getArgument()
Definition: ExprCXX.h:2534
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2799
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1733
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
Definition: ExprCXX.h:1770
Represents a call to a member function that may be written either with member call syntax (e....
Definition: ExprCXX.h:176
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2060
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition: ExprCXX.h:2236
bool isArray() const
Definition: ExprCXX.h:2344
std::optional< Expr * > getArraySize()
This might return std::nullopt even if isArray() returns true, since there might not be an array size...
Definition: ExprCXX.h:2349
Expr * getPlacementArg(unsigned I)
Definition: ExprCXX.h:2383
bool passAlignment() const
Indicates whether the required alignment should be implicitly passed to the allocation function.
Definition: ExprCXX.h:2427
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:2374
FunctionDecl * getOperatorNew() const
Definition: ExprCXX.h:2339
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:81
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Definition: ExprCXX.h:111
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
Definition: DeclCXX.cpp:1594
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2820
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:3011
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2998
ConstructionContext's subclasses describe different ways of constructing an object in C++.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
SourceLocation getLocation() const
Definition: DeclBase.h:445
This represents one expression.
Definition: Expr.h:110
Represents a function declaration or definition.
Definition: Decl.h:1971
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3687
One of these records is kept for each identifier that is lexed.
It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext ...
Represents an ObjC class declaration.
Definition: DeclObjC.h:1153
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:945
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: ExprObjC.h:1395
ObjCMethodFamily getMethodFamily() const
Definition: ExprObjC.h:1375
Selector getSelector() const
Definition: ExprObjC.cpp:293
bool isInstanceMessage() const
Determine whether this is an instance message to either a computed object or to super.
Definition: ExprObjC.h:1248
ObjCInterfaceDecl * getReceiverInterface() const
Retrieve the Objective-C interface to which this message is being directed, if known.
Definition: ExprObjC.cpp:314
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1356
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver.
Definition: ExprObjC.h:1382
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:140
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:730
Represents a parameter to a function.
Definition: Decl.h:1761
ProgramPoints can be "tagged" as representing points specific to a given analysis entity.
Definition: ProgramPoint.h:38
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:6305
A (possibly-)qualified type.
Definition: Type.h:940
Smart pointer class that efficiently represents Objective-C method names.
Encodes a location in the source.
This class handles loading and caching of source files into memory.
A trivial tuple used to represent a source range.
It represents a stack frame of the call stack (based on CallEvent).
Stmt - This represents one statement.
Definition: Stmt.h:84
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:350
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:326
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1881
QualType getType() const
Definition: Decl.h:717
Represents a variable declaration or definition.
Definition: Decl.h:918
Represents any constructor invocation.
Definition: CallEvent.h:948
void getInitialStackFrameContents(const StackFrameContext *CalleeCtx, BindingsTy &Bindings) const override
Populates the given SmallVector with the bindings in the callee's stack frame at the start of this ca...
Definition: CallEvent.cpp:935
AnyCXXConstructorCall(const Expr *E, const MemRegion *Target, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:950
void getExtraInvalidatedValues(ValueList &Values, RegionAndSymbolInvalidationTraits *ETraits) const override
Used to specify non-argument regions that will be invalidated as a result of this call.
Definition: CallEvent.cpp:926
SVal getCXXThisVal() const
Returns the value of the implicit 'this' object.
Definition: CallEvent.cpp:920
static bool classof(const CallEvent *Call)
Definition: CallEvent.h:970
Represents a call to any sort of function that might have a FunctionDecl.
Definition: CallEvent.h:499
const FunctionDecl * getDecl() const override
Returns the declaration of the function or method that will be called.
Definition: CallEvent.h:514
AnyFunctionCall(const Expr *E, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:501
ArrayRef< ParmVarDecl * > parameters() const override
Return call's formal parameters.
Definition: CallEvent.cpp:553
void getInitialStackFrameContents(const StackFrameContext *CalleeCtx, BindingsTy &Bindings) const override
Populates the given SmallVector with the bindings in the callee's stack frame at the start of this ca...
Definition: CallEvent.cpp:614
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:527
AnyFunctionCall(const Decl *D, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:505
bool argumentsMayEscape() const override
Returns true if any of the arguments are known to escape to long- term storage, even if this method w...
Definition: CallEvent.cpp:623
AnyFunctionCall(const AnyFunctionCall &Other)=default
RuntimeDefinition getRuntimeDefinition() const override
Returns the definition of the function or method that will be called.
Definition: CallEvent.cpp:560
Represents a call to a block.
Definition: CallEvent.h:574
const BlockDecl * getDecl() const override
Returns the declaration of the function or method that will be called.
Definition: CallEvent.h:605
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:583
bool argumentsMayEscape() const override
Returns true if any of the arguments are known to escape to long- term storage, even if this method w...
Definition: CallEvent.h:662
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:594
RuntimeDefinition getRuntimeDefinition() const override
Returns the definition of the function or method that will be called.
Definition: CallEvent.h:632
const BlockDataRegion * getBlockRegion() const
Returns the region associated with this instance of the block.
Definition: CallEvent.cpp:876
bool isConversionFromLambda() const
Definition: CallEvent.h:612
ArrayRef< ParmVarDecl * > parameters() const override
Return call's formal parameters.
Definition: CallEvent.cpp:883
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:669
void getExtraInvalidatedValues(ValueList &Values, RegionAndSymbolInvalidationTraits *ETraits) const override
Used to specify non-argument regions that will be invalidated as a result of this call.
Definition: CallEvent.cpp:890
const VarRegion * getRegionStoringCapturedLambda() const
For a block converted from a C++ lambda, returns the block VarRegion for the variable holding the cap...
Definition: CallEvent.h:622
const Expr * getArgExpr(unsigned Index) const override
Returns the expression associated with a given argument.
Definition: CallEvent.h:596
BlockCall(const CallExpr *CE, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:578
BlockCall(const BlockCall &Other)=default
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:672
void getInitialStackFrameContents(const StackFrameContext *CalleeCtx, BindingsTy &Bindings) const override
Populates the given SmallVector with the bindings in the callee's stack frame at the start of this ca...
Definition: CallEvent.cpp:897
StringRef getKindAsString() const override
Definition: CallEvent.h:670
const CallExpr * getOriginExpr() const override
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:590
BlockDataRegion - A region that represents a block instance.
Definition: MemRegion.h:673
LLVM_ATTRIBUTE_RETURNS_NONNULL const BlockDecl * getDecl() const
Definition: MemRegion.h:703
llvm::iterator_range< referenced_vars_iterator > referenced_vars() const
Definition: MemRegion.cpp:1754
Represents the memory allocation call in a C++ new-expression.
Definition: CallEvent.h:1112
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:1147
unsigned getNumImplicitArgs() const
Number of non-placement arguments to the call.
Definition: CallEvent.h:1143
const CXXNewExpr * getOriginExpr() const override
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:1127
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:1178
const Expr * getArgExpr(unsigned Index) const override
Returns the expression associated with a given argument.
Definition: CallEvent.h:1163
std::optional< const clang::Expr * > getArraySizeExpr() const
Definition: CallEvent.h:1153
static bool classof(const CallEvent *CE)
Definition: CallEvent.h:1181
const Expr * getPlacementArgExpr(unsigned Index) const
Number of placement arguments to the operator new() call.
Definition: CallEvent.h:1174
CXXAllocatorCall(const CXXAllocatorCall &Other)=default
const FunctionDecl * getDecl() const override
Returns the declaration of the function or method that will be called.
Definition: CallEvent.h:1131
StringRef getKindAsString() const override
Definition: CallEvent.h:1179
SVal getObjectUnderConstruction() const
Definition: CallEvent.h:1135
CXXAllocatorCall(const CXXNewExpr *E, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:1116
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:1122
Represents a call to a C++ constructor.
Definition: CallEvent.h:979
CXXConstructorCall(const CXXConstructorCall &Other)=default
const CXXConstructorDecl * getDecl() const override
Returns the declaration of the function or method that will be called.
Definition: CallEvent.h:1010
const CXXConstructExpr * getOriginExpr() const override
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:1006
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:1020
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:1001
const Expr * getArgExpr(unsigned Index) const override
Returns the expression associated with a given argument.
Definition: CallEvent.h:1016
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:1014
CXXConstructorCall(const CXXConstructExpr *CE, const MemRegion *Target, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Creates a constructor call.
Definition: CallEvent.h:994
StringRef getKindAsString() const override
Definition: CallEvent.h:1021
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:1023
Represents the memory deallocation call in a C++ delete-expression.
Definition: CallEvent.h:1196
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:1226
const CXXDeleteExpr * getOriginExpr() const override
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:1211
const Expr * getArgExpr(unsigned Index) const override
Returns the expression associated with a given argument.
Definition: CallEvent.h:1221
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:1219
CXXDeallocatorCall(const CXXDeallocatorCall &Other)=default
static bool classof(const CallEvent *CE)
Definition: CallEvent.h:1229
StringRef getKindAsString() const override
Definition: CallEvent.h:1227
const FunctionDecl * getDecl() const override
Returns the declaration of the function or method that will be called.
Definition: CallEvent.h:1215
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:1206
CXXDeallocatorCall(const CXXDeleteExpr *E, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:1200
Represents an implicit call to a C++ destructor.
Definition: CallEvent.h:890
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:941
SVal getCXXThisVal() const override
Returns the value of the implicit 'this' object.
Definition: CallEvent.cpp:957
RuntimeDefinition getRuntimeDefinition() const override
Returns the definition of the function or method that will be called.
Definition: CallEvent.cpp:963
bool isBaseDestructor() const
Returns true if this is a call to a base class destructor.
Definition: CallEvent.h:934
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:926
llvm::PointerIntPair< const MemRegion *, 1, bool > DtorDataTy
Definition: CallEvent.h:894
CXXDestructorCall(const CXXDestructorCall &Other)=default
SourceRange getSourceRange() const override
Returns a source range for the entire call, suitable for outputting in diagnostics.
Definition: CallEvent.h:925
CXXDestructorCall(const CXXDestructorDecl *DD, const Stmt *Trigger, const MemRegion *Target, bool IsBaseDestructor, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Creates an implicit destructor.
Definition: CallEvent.h:909
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:920
StringRef getKindAsString() const override
Definition: CallEvent.h:939
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:938
Represents a call to a C++ inherited constructor.
Definition: CallEvent.h:1048
CXXInheritedConstructorCall(const CXXInheritedCtorInitExpr *CE, const MemRegion *Target, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:1052
CXXInheritedConstructorCall(const CXXInheritedConstructorCall &Other)=default
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:1104
const CXXInheritedCtorInitExpr * getOriginExpr() const override
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:1066
const StackFrameContext * getInheritingStackFrame() const
Obtain the stack frame of the inheriting constructor.
Definition: CallEvent.cpp:950
StringRef getKindAsString() const override
Definition: CallEvent.h:1100
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:1099
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:1085
const Expr * getArgExpr(unsigned Index) const override
Returns the expression associated with a given argument.
Definition: CallEvent.h:1089
const CXXConstructorDecl * getDecl() const override
Returns the declaration of the function or method that will be called.
Definition: CallEvent.h:1070
const CXXConstructExpr * getInheritingConstructor() const
Obtain the CXXConstructExpr for the sub-class that inherited the current constructor (possibly indire...
Definition: CallEvent.h:1081
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:1061
SVal getArgSVal(unsigned Index) const override
Returns the value of a given argument at the time of the call.
Definition: CallEvent.h:1093
Represents a non-static C++ member function call, no matter how it is written.
Definition: CallEvent.h:677
CXXInstanceCall(const CXXInstanceCall &Other)=default
CXXInstanceCall(const CallExpr *CE, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:679
CXXInstanceCall(const FunctionDecl *D, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:683
void getExtraInvalidatedValues(ValueList &Values, RegionAndSymbolInvalidationTraits *ETraits) const override
Used to specify non-argument regions that will be invalidated as a result of this call.
Definition: CallEvent.cpp:704
virtual SVal getCXXThisVal() const
Returns the value of the implicit 'this' object.
Definition: CallEvent.cpp:735
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:707
RuntimeDefinition getRuntimeDefinition() const override
Returns the definition of the function or method that will be called.
Definition: CallEvent.cpp:750
virtual const Expr * getCXXThisExpr() const
Returns the expression representing the implicit 'this' object.
Definition: CallEvent.h:695
const FunctionDecl * getDecl() const override
Returns the declaration of the function or method that will be called.
Definition: CallEvent.cpp:692
void getInitialStackFrameContents(const StackFrameContext *CalleeCtx, BindingsTy &Bindings) const override
Populates the given SmallVector with the bindings in the callee's stack frame at the start of this ca...
Definition: CallEvent.cpp:815
Represents a non-static C++ member function call.
Definition: CallEvent.h:787
const Expr * getArgExpr(unsigned Index) const override
Returns the expression associated with a given argument.
Definition: CallEvent.h:810
CXXMemberCall(const CXXMemberCall &Other)=default
const CXXMemberCallExpr * getOriginExpr() const override
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:800
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:821
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:804
CXXMemberCall(const CXXMemberCallExpr *CE, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:791
const Expr * getCXXThisExpr() const override
Returns the expression representing the implicit 'this' object.
Definition: CallEvent.cpp:856
StringRef getKindAsString() const override
Definition: CallEvent.h:819
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:797
RuntimeDefinition getRuntimeDefinition() const override
Returns the definition of the function or method that will be called.
Definition: CallEvent.cpp:860
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:818
Represents a C++ overloaded operator call where the operator is implemented as a non-static member fu...
Definition: CallEvent.h:830
std::optional< unsigned > getAdjustedParameterIndex(unsigned ASTArgumentIndex) const override
Some calls have parameter numbering mismatched from argument numbering.
Definition: CallEvent.h:867
OverloadedOperatorKind getOverloadedOperator() const
Definition: CallEvent.h:881
const Expr * getArgExpr(unsigned Index) const override
Returns the expression associated with a given argument.
Definition: CallEvent.h:853
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:849
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:859
StringRef getKindAsString() const override
Definition: CallEvent.h:860
const Expr * getCXXThisExpr() const override
Returns the expression representing the implicit 'this' object.
Definition: CallEvent.cpp:872
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:840
CXXMemberOperatorCall(const CXXOperatorCallExpr *CE, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:834
const CXXOperatorCallExpr * getOriginExpr() const override
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:845
CXXMemberOperatorCall(const CXXMemberOperatorCall &Other)=default
unsigned getASTArgumentIndex(unsigned CallArgumentIndex) const override
Some call event sub-classes conveniently adjust mismatching AST indices to match parameter indices.
Definition: CallEvent.h:875
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:862
Represents a static C++ operator call.
Definition: CallEvent.h:729
std::optional< unsigned > getAdjustedParameterIndex(unsigned ASTArgumentIndex) const override
Some calls have parameter numbering mismatched from argument numbering.
Definition: CallEvent.h:760
CXXStaticOperatorCall(const CXXStaticOperatorCall &Other)=default
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:739
OverloadedOperatorKind getOverloadedOperator() const
Definition: CallEvent.h:772
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:748
StringRef getKindAsString() const override
Definition: CallEvent.h:777
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:776
const Expr * getArgExpr(unsigned Index) const override
Returns the expression associated with a given argument.
Definition: CallEvent.h:754
const CXXOperatorCallExpr * getOriginExpr() const override
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:744
CXXStaticOperatorCall(const CXXOperatorCallExpr *CE, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:733
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:779
unsigned getASTArgumentIndex(unsigned CallArgumentIndex) const override
Some call event sub-classes conveniently adjust mismatching AST indices to match parameter indices.
Definition: CallEvent.h:767
Manages the lifetime of CallEvent objects.
Definition: CallEvent.h:1356
CallEventRef< CXXDestructorCall > getCXXDestructorCall(const CXXDestructorDecl *DD, const Stmt *Trigger, const MemRegion *Target, bool IsBase, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:1449
CallEventRef getCall(const Stmt *S, ProgramStateRef State, const LocationContext *LC, CFGBlock::ConstCFGElementRef ElemRef)
Gets a call event for a function call, Objective-C method call, a 'new', or a 'delete' call.
Definition: CallEvent.cpp:1485
CallEventRef< CXXDeallocatorCall > getCXXDeallocatorCall(const CXXDeleteExpr *E, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:1465
CallEventRef getSimpleCall(const CallExpr *E, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.cpp:1403
CallEventRef< ObjCMethodCall > getObjCMethodCall(const ObjCMessageExpr *E, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:1427
CallEventRef< CXXAllocatorCall > getCXXAllocatorCall(const CXXNewExpr *E, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:1458
CallEventRef< CXXConstructorCall > getCXXConstructorCall(const CXXConstructExpr *E, const MemRegion *Target, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:1434
CallEventRef< CXXInheritedConstructorCall > getCXXInheritedConstructorCall(const CXXInheritedCtorInitExpr *E, const MemRegion *Target, ProgramStateRef State, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:1441
CallEventManager(llvm::BumpPtrAllocator &alloc)
Definition: CallEvent.h:1410
CallEventRef getCaller(const StackFrameContext *CalleeCtx, ProgramStateRef State)
Gets an outside caller given a callee context.
Definition: CallEvent.cpp:1428
CallEventRef(const T *Call)
Definition: CallEvent.h:85
CallEventRef(const CallEventRef &Orig)
Definition: CallEvent.h:86
CallEventRef & operator=(const CallEventRef &)=delete
CallEventRef< T > cloneWithState(ProgramStateRef State) const
Definition: CallEvent.h:92
Represents an abstract call to a function or method along a particular path.
Definition: CallEvent.h:153
virtual SourceRange getArgSourceRange(unsigned Index) const
Returns the source range for errors associated with this argument.
Definition: CallEvent.cpp:315
virtual void getExtraInvalidatedValues(ValueList &Values, RegionAndSymbolInvalidationTraits *ETraits) const
Used to specify non-argument regions that will be invalidated as a result of this call.
Definition: CallEvent.h:211
virtual StringRef getKindAsString() const =0
void setForeign(bool B) const
Definition: CallEvent.h:232
virtual const Expr * getOriginExpr() const
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:250
virtual RuntimeDefinition getRuntimeDefinition() const =0
Returns the definition of the function or method that will be called.
CallEventRef cloneWithState(ProgramStateRef NewState) const
Returns a copy of this CallEvent, but using the given state.
Definition: CallEvent.h:382
static bool isCallStmt(const Stmt *S)
Returns true if this is a statement is a function or method call of some kind.
Definition: CallEvent.cpp:347
CallEvent & operator=(const CallEvent &)=delete
llvm::mapped_iterator< ArrayRef< ParmVarDecl * >::iterator, GetTypeFn > param_type_iterator
Definition: CallEvent.h:477
const ConstructionContext * getConstructionContext() const
Returns the construction context of the call, if it is a C++ constructor call or a call of a function...
Definition: CallEvent.cpp:503
param_type_iterator param_type_end() const
Definition: CallEvent.h:488
const ParamVarRegion * getParameterLocation(unsigned Index, unsigned BlockCount) const
Returns memory location for a parameter variable within the callee stack frame.
Definition: CallEvent.cpp:194
bool isCalledFromSystemHeader() const
Definition: CallEvent.cpp:533
const IdentifierInfo * getCalleeIdentifier() const
Returns the name of the callee, if its name is a simple identifier.
Definition: CallEvent.h:351
AnalysisDeclContext * getCalleeAnalysisDeclContext() const
Returns AnalysisDeclContext for the callee stack frame.
Definition: CallEvent.cpp:152
ProgramStateRef invalidateRegions(unsigned BlockCount, ProgramStateRef Orig=nullptr) const
Returns a new state with all argument regions invalidated.
Definition: CallEvent.cpp:233
virtual std::optional< unsigned > getAdjustedParameterIndex(unsigned ASTArgumentIndex) const
Some calls have parameter numbering mismatched from argument numbering.
Definition: CallEvent.h:434
const ProgramStateRef & getState() const
The state in which the call is being evaluated.
Definition: CallEvent.h:235
QualType getResultType() const
Returns the result type, adjusted for references.
Definition: CallEvent.cpp:71
CallEvent(const Expr *E, ProgramStateRef state, const LocationContext *lctx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:184
CallEventRef< T > cloneWithState(ProgramStateRef NewState) const
Returns a copy of this CallEvent, but using the given state.
Definition: CallEvent.h:1473
bool isInSystemHeader() const
Returns true if the callee is known to be from a system header.
Definition: CallEvent.h:262
bool isForeign() const
Definition: CallEvent.h:228
bool isGlobalCFunction(StringRef SpecificName=StringRef()) const
Returns true if the callee is an externally-visible function in the top-level namespace,...
Definition: CallEvent.cpp:144
virtual bool argumentsMayEscape() const
Returns true if any of the arguments are known to escape to long- term storage, even if this method w...
Definition: CallEvent.h:324
CallEvent(const CallEvent &Original)
Definition: CallEvent.h:193
param_type_iterator param_type_begin() const
Returns an iterator over the types of the call's formal parameters.
Definition: CallEvent.h:484
SourceLocation Location
Definition: CallEvent.h:171
const void * Data
Definition: CallEvent.h:166
std::pair< SVal, SVal > FrameBindingTy
Definition: CallEvent.h:369
ProgramPoint getProgramPoint(bool IsPreVisit=false, const ProgramPointTag *Tag=nullptr) const
Returns an appropriate ProgramPoint for this call.
Definition: CallEvent.cpp:288
virtual ~CallEvent()=default
const StackFrameContext * getCalleeStackFrame(unsigned BlockCount) const
Returns the callee stack frame.
Definition: CallEvent.cpp:164
static QualType getDeclaredResultType(const Decl *D)
Returns the result type of a function or method declaration.
Definition: CallEvent.cpp:351
SVal getSVal(const Stmt *S) const
Get the value of arbitrary expressions at this point in the path.
Definition: CallEvent.h:202
virtual void getInitialStackFrameContents(const StackFrameContext *CalleeCtx, BindingsTy &Bindings) const =0
Populates the given SmallVector with the bindings in the callee's stack frame at the start of this ca...
virtual void cloneTo(void *Dest) const =0
Copies this CallEvent, with vtable intact, into a new block of memory.
static bool isVariadic(const Decl *D)
Returns true if the given decl is known to be variadic.
Definition: CallEvent.cpp:380
virtual SVal getArgSVal(unsigned Index) const
Returns the value of a given argument at the time of the call.
Definition: CallEvent.cpp:308
bool hasNonNullArgumentsWithType(bool(*Condition)(QualType)) const
Returns true if the type of any of the non-null arguments satisfies the condition.
Definition: CallEvent.cpp:113
std::optional< SVal > getReturnValueUnderConstruction() const
If the call returns a C++ record type then the region of its return value can be retrieved from its c...
Definition: CallEvent.cpp:540
virtual const Expr * getArgExpr(unsigned Index) const
Returns the expression associated with a given argument.
Definition: CallEvent.h:293
virtual unsigned getNumArgs() const =0
Returns the number of arguments (explicit and implicit).
bool hasVoidPointerToNonConstArg() const
Returns true if any of the arguments is void*.
Definition: CallEvent.cpp:140
const CallEventRef getCaller() const
Definition: CallEvent.cpp:520
bool isArgumentConstructedDirectly(unsigned Index) const
Returns true if on the current path, the argument was constructed by calling a C++ constructor over i...
Definition: CallEvent.h:422
SmallVectorImpl< FrameBindingTy > BindingsTy
Definition: CallEvent.h:370
SVal getReturnValue() const
Returns the return value of the call.
Definition: CallEvent.cpp:322
virtual const Decl * getDecl() const
Returns the declaration of the function or method that will be called.
Definition: CallEvent.h:224
const LocationContext * getLocationContext() const
The context in which the call is being evaluated.
Definition: CallEvent.h:238
const CFGBlock::ConstCFGElementRef & getCFGElementRef() const
Definition: CallEvent.h:240
CallEvent(const Decl *D, ProgramStateRef state, const LocationContext *lctx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:188
virtual ArrayRef< ParmVarDecl * > parameters() const =0
Return call's formal parameters.
bool hasNonZeroCallbackArg() const
Returns true if any of the arguments appear to represent callbacks.
Definition: CallEvent.cpp:136
virtual Kind getKind() const =0
Returns the kind of call this is.
virtual SourceRange getSourceRange() const
Returns a source range for the entire call, suitable for outputting in diagnostics.
Definition: CallEvent.h:284
virtual unsigned getASTArgumentIndex(unsigned CallArgumentIndex) const
Some call event sub-classes conveniently adjust mismatching AST indices to match parameter indices.
Definition: CallEvent.h:441
bool isValid() const =delete
static std::optional< SVal > getObjectUnderConstruction(ProgramStateRef State, const ConstructionContextItem &Item, const LocationContext *LC)
By looking at a certain item that may be potentially part of an object's ConstructionContext,...
Definition: ExprEngine.cpp:603
MemRegion - The root abstract class for all memory regions.
Definition: MemRegion.h:96
Represents any expression that calls an Objective-C method.
Definition: CallEvent.h:1243
ObjCMethodCall(const ObjCMethodCall &Other)=default
const ObjCMethodDecl * getDecl() const override
Returns the declaration of the function or method that will be called.
Definition: CallEvent.h:1273
void getExtraInvalidatedValues(ValueList &Values, RegionAndSymbolInvalidationTraits *ETraits) const override
Used to specify non-argument regions that will be invalidated as a result of this call.
Definition: CallEvent.cpp:979
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:1344
bool isInstanceMessage() const
Definition: CallEvent.h:1283
const Expr * getArgExpr(unsigned Index) const override
Returns the expression associated with a given argument.
Definition: CallEvent.h:1279
ObjCMessageKind getMessageKind() const
Returns how the message was written in the source (property access, subscript, or explicit message se...
Definition: CallEvent.cpp:1065
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:1277
bool isSetter() const
Returns true if this property access or subscript is a setter (has the form of an assignment).
Definition: CallEvent.h:1315
const ObjCMessageExpr * getOriginExpr() const override
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:1269
ObjCMethodFamily getMethodFamily() const
Definition: CallEvent.h:1287
ObjCMethodCall(const ObjCMessageExpr *Msg, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:1249
ArrayRef< ParmVarDecl * > parameters() const override
Return call's formal parameters.
Definition: CallEvent.cpp:972
StringRef getKindAsString() const override
Definition: CallEvent.h:1342
SourceRange getSourceRange() const override
Returns a source range for the entire call, suitable for outputting in diagnostics.
Definition: CallEvent.cpp:1034
virtual bool canBeOverridenInSubclass(ObjCInterfaceDecl *IDecl, Selector Sel) const
Check if the selector may have multiple definitions (may have overrides).
Definition: CallEvent.cpp:1131
bool argumentsMayEscape() const override
Returns true if any of the arguments are known to escape to long- term storage, even if this method w...
Definition: CallEvent.cpp:1374
SVal getReceiverSVal() const
Returns the value of the receiver at the time of this call.
Definition: CallEvent.cpp:1004
RuntimeDefinition getRuntimeDefinition() const override
Returns the definition of the function or method that will be called.
Definition: CallEvent.cpp:1271
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:1258
const ObjCInterfaceDecl * getReceiverInterface() const
Get the interface for the receiver.
Definition: CallEvent.h:1302
bool isReceiverSelfOrSuper() const
Checks if the receiver refers to 'self' or 'super'.
Definition: CallEvent.cpp:1020
Selector getSelector() const
Definition: CallEvent.h:1291
const ObjCPropertyDecl * getAccessedProperty() const
Definition: CallEvent.cpp:1109
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:1341
void getInitialStackFrameContents(const StackFrameContext *CalleeCtx, BindingsTy &Bindings) const override
Populates the given SmallVector with the bindings in the callee's stack frame at the start of this ca...
Definition: CallEvent.cpp:1385
ParamVarRegion - Represents a region for paremters.
Definition: MemRegion.h:1029
Information about invalidation for a particular region/symbol.
Definition: MemRegion.h:1624
Defines the runtime definition of the called function.
Definition: CallEvent.h:110
RuntimeDefinition(const Decl *InD, const MemRegion *InR)
Definition: CallEvent.h:129
RuntimeDefinition(const Decl *InD, bool Foreign)
Definition: CallEvent.h:128
const MemRegion * getDispatchRegion()
When other definitions are possible, returns the region whose runtime type determines the method defi...
Definition: CallEvent.h:141
RuntimeDefinition(const Decl *InD)
Definition: CallEvent.h:127
bool mayHaveOtherDefinitions()
Check if the definition we have is precise.
Definition: CallEvent.h:137
SVal - This represents a symbolic expression, which can be either an L-value or an R-value.
Definition: SVals.h:55
Represents a C function or static C++ member function call.
Definition: CallEvent.h:536
static bool classof(const CallEvent *CA)
Definition: CallEvent.h:566
Kind getKind() const override
Returns the kind of call this is.
Definition: CallEvent.h:563
unsigned getNumArgs() const override
Returns the number of arguments (explicit and implicit).
Definition: CallEvent.h:557
SimpleFunctionCall(const CallExpr *CE, ProgramStateRef St, const LocationContext *LCtx, CFGBlock::ConstCFGElementRef ElemRef)
Definition: CallEvent.h:540
void cloneTo(void *Dest) const override
Copies this CallEvent, with vtable intact, into a new block of memory.
Definition: CallEvent.h:546
SimpleFunctionCall(const SimpleFunctionCall &Other)=default
StringRef getKindAsString() const override
Definition: CallEvent.h:564
const Expr * getArgExpr(unsigned Index) const override
Returns the expression associated with a given argument.
Definition: CallEvent.h:559
const CallExpr * getOriginExpr() const override
Returns the expression whose value will be the result of this call.
Definition: CallEvent.h:551
const FunctionDecl * getDecl() const override
Returns the declaration of the function or method that will be called.
Definition: CallEvent.cpp:684
const VarDecl * getDecl() const override=0
IntrusiveRefCntPtr< const ProgramState > ProgramStateRef
@ CE_CXXMember
Definition: CallEvent.h:63
@ CE_ObjCMessage
Definition: CallEvent.h:77
@ CE_END_CXX_CONSTRUCTOR_CALLS
Definition: CallEvent.h:71
@ CE_CXXInheritedConstructor
Definition: CallEvent.h:69
@ CE_END_FUNCTION_CALLS
Definition: CallEvent.h:75
@ CE_CXXStaticOperator
Definition: CallEvent.h:62
@ CE_END_CXX_INSTANCE_CALLS
Definition: CallEvent.h:67
@ CE_CXXDestructor
Definition: CallEvent.h:65
@ CE_BEG_CXX_INSTANCE_CALLS
Definition: CallEvent.h:66
@ CE_CXXDeallocator
Definition: CallEvent.h:73
@ CE_CXXAllocator
Definition: CallEvent.h:72
@ CE_CXXConstructor
Definition: CallEvent.h:68
@ CE_BEG_CXX_CONSTRUCTOR_CALLS
Definition: CallEvent.h:70
@ CE_CXXMemberOperator
Definition: CallEvent.h:64
@ CE_BEG_FUNCTION_CALLS
Definition: CallEvent.h:74
ObjCMessageKind
Represents the ways an Objective-C message send can occur.
Definition: CallEvent.h:1238
@ OCM_PropertyAccess
Definition: CallEvent.h:1238
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
ObjCMethodFamily
A family of Objective-C methods.
const FunctionProtoType * T
@ Other
Other implicit parameter.
Diagnostic wrappers for TextAPI types for error reporting.
Definition: Dominators.h:30
Definition: Format.h:5433
static SimpleType getSimplifiedValue(clang::ento::CallEventRef< T > Val)
Definition: CallEvent.h:1513