|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
tools/clang/include/clang/AST/ExprCXX.h 78 class CXXOperatorCallExpr final : public CallExpr {
171 class CXXMemberCallExpr final : public CallExpr {
224 class CUDAKernelCallExpr final : public CallExpr {
564 class UserDefinedLiteral final : public CallExpr {
Declarations
gen/tools/clang/include/clang/AST/StmtNodes.inc 789 CALLEXPR(CallExpr, Expr)
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h 45 class CallExpr;
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h 68 class CallExpr;
tools/clang/include/clang/Analysis/PathDiagnostic.h 44 class CallExpr;
tools/clang/include/clang/Sema/Sema.h 97 class CallExpr;
tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h 29 class CallExpr;
References
include/llvm/ADT/STLExtras.h 75 typename std::add_pointer<typename std::add_const<T>::type>::type;
include/llvm/Support/Casting.h 57 static inline bool doit(const From &Val) {
58 return To::classof(&Val);
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
106 return isa_impl<To, From>::doit(*Val);
122 return isa_impl_wrap<To, SimpleFrom,
132 return isa_impl_cl<To,FromTy>::doit(Val);
142 return isa_impl_wrap<X, const Y,
172 using ret_type = To *; // Pointer arg case, return Ty*
176 using ret_type = const To *; // Constant pointer arg case, return const Ty*
198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
309 return cast<X>(Val);
337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
tools/clang/include/clang/AST/ASTTypeTraits.h 65 return ASTNodeKind(KindToKindId<T>::Id);
174 struct KindToKindId<const T> : KindToKindId<T> {};
234 static DynTypedNode create(const T &Node) {
235 return BaseConverter<T>::create(Node);
251 const T *get() const {
252 return BaseConverter<T>::get(NodeKind, Storage.buffer);
259 const T &getUnchecked() const {
260 return BaseConverter<T>::getUnchecked(NodeKind, Storage.buffer);
394 static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
395 if (ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind))
399 static const T &getUnchecked(ASTNodeKind NodeKind, const char Storage[]) {
401 return *cast<T>(static_cast<const BaseT *>(
474 : public DynCastPtrConverter<T, Stmt> {};
tools/clang/include/clang/AST/Expr.h 2617 static CallExpr *Create(const ASTContext &Ctx, Expr *Fn,
2630 static CallExpr *CreateTemporary(void *Mem, Expr *Fn, QualType Ty,
2635 static CallExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs,
tools/clang/include/clang/AST/ExprCXX.h 78 class CXXOperatorCallExpr final : public CallExpr {
171 class CXXMemberCallExpr final : public CallExpr {
224 class CUDAKernelCallExpr final : public CallExpr {
232 CUDAKernelCallExpr(Expr *Fn, CallExpr *Config, ArrayRef<Expr *> Args,
240 CallExpr *Config, ArrayRef<Expr *> Args,
247 const CallExpr *getConfig() const {
248 return cast_or_null<CallExpr>(getPreArg(CONFIG));
250 CallExpr *getConfig() { return cast_or_null<CallExpr>(getPreArg(CONFIG)); }
250 CallExpr *getConfig() { return cast_or_null<CallExpr>(getPreArg(CONFIG)); }
564 class UserDefinedLiteral final : public CallExpr {
tools/clang/include/clang/AST/JSONNodeDumper.h 269 void VisitCallExpr(const CallExpr *CE);
tools/clang/include/clang/AST/OSLog.h 155 bool computeOSLogBufferLayout(clang::ASTContext &Ctx, const clang::CallExpr *E,
tools/clang/include/clang/AST/TextNodeDumper.h 232 void VisitCallExpr(const CallExpr *Node);
tools/clang/include/clang/ASTMatchers/ASTMatchFinder.h 266 const NodeT *
269 if (const NodeT *Node = N.getNodeAs<NodeT>(BoundTo))
269 if (const NodeT *Node = N.getNodeAs<NodeT>(BoundTo))
tools/clang/include/clang/ASTMatchers/ASTMatchers.h 110 const T *getNodeAs(StringRef ID) const {
111 return MyBoundNodes.getNodeAs<T>(ID);
1272 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
tools/clang/include/clang/ASTMatchers/ASTMatchersInternal.h 160 const T *getNodeAs(StringRef ID) const {
165 return It->second.get<T>();
302 virtual bool matches(const T &Node,
309 return matches(DynNode.getUnchecked<T>(), Finder, Builder);
345 DynTypedMatcher(MatcherInterface<T> *Implementation)
346 : SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()),
436 return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
445 template <typename T> Matcher<T> convertTo() const {
447 return unconditionalConvertTo<T>();
479 class WrapperMatcherInterface : public MatcherInterface<T> {
499 explicit Matcher(MatcherInterface<T> *Implementation)
506 Matcher(const Matcher<From> &Other,
507 typename std::enable_if<std::is_base_of<From, T>::value &&
507 typename std::enable_if<std::is_base_of<From, T>::value &&
508 !std::is_same<From, T>::value>::type * = nullptr)
508 !std::is_same<From, T>::value>::type * = nullptr)
520 std::is_same<T, QualType>::value &&
529 static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
534 bool matches(const T &Node,
581 return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
751 class HasDeclarationMatcher : public WrapperMatcherInterface<T> {
759 bool matches(const T &Node, ASTMatchFinder *Finder,
857 bool matchesSpecialized(const CallExpr &Node, ASTMatchFinder *Finder,
994 bool matchesChildOf(const T &Node, const DynTypedMatcher &Matcher,
997 static_assert(std::is_base_of<Decl, T>::value ||
998 std::is_base_of<Stmt, T>::value ||
999 std::is_base_of<NestedNameSpecifier, T>::value ||
1000 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1001 std::is_base_of<TypeLoc, T>::value ||
1002 std::is_base_of<QualType, T>::value,
1026 bool matchesAncestorOf(const T &Node,
1030 static_assert(std::is_base_of<Decl, T>::value ||
1031 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1032 std::is_base_of<Stmt, T>::value ||
1033 std::is_base_of<TypeLoc, T>::value,
1067 using head = T1;
1084 std::is_base_of<typename AnyTypeList::head, T>::value ||
1085 TypeListContainsSuperOf<typename AnyTypeList::tail, T>::value;
1116 TypeList<CallExpr, CXXConstructExpr, CXXNewExpr, DeclRefExpr, EnumType,
1146 template <typename To> operator Matcher<To>() const {
1184 operator Matcher<T>() const {
1185 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1202 operator Matcher<T>() const {
1203 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1223 operator Matcher<T>() const {
1224 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1243 operator Matcher<T>() const {
1245 ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
1246 .template unconditionalConvertTo<T>();
1255 class BindableMatcher : public Matcher<T> {
1257 explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {}
1258 explicit BindableMatcher(MatcherInterface<T> *Implementation)
1265 Matcher<T> bind(StringRef ID) const {
1285 class HasMatcher : public WrapperMatcherInterface<T> {
1290 bool matches(const T &Node, ASTMatchFinder *Finder,
1335 template <typename T> operator Matcher<T>() const {
1337 Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1338 getMatchers<T>(std::index_sequence_for<Ps...>()))
1339 .template unconditionalConvertTo<T>();
1370 inline Matcher<T> DynTypedMatcher::unconditionalConvertTo() const {
1376 BindableMatcher<T> makeAllOfComposite(
1377 ArrayRef<const Matcher<T> *> InnerMatchers) {
1388 using PI = llvm::pointee_iterator<const Matcher<T> *const *>;
1395 ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1397 .template unconditionalConvertTo<T>());
1408 ArrayRef<const Matcher<InnerT> *> InnerMatchers) {
1438 class HasParentMatcher : public WrapperMatcherInterface<T> {
1446 bool matches(const T &Node, ASTMatchFinder *Finder,
1458 class HasAncestorMatcher : public WrapperMatcherInterface<T> {
1466 bool matches(const T &Node, ASTMatchFinder *Finder,
1557 : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
1558 makeDynCastAllOfComposite<SourceT, TargetT>> {
tools/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h 199 ast_matchers::internal::Matcher<T> getTypedMatcher() const {
202 ->template convertTo<T>();
227 : MatcherOps(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) {}
228 typedef ast_matchers::internal::Matcher<T> MatcherT;
232 return DynTypedMatcher(Matcher.convertTo<T>());
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h 401 til::SExpr *translateCallExpr(const CallExpr *CE, CallingContext *Ctx,
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h 965 Call(SExpr *T, const CallExpr *Ce = nullptr)
974 const CallExpr *clangCallExpr() const { return Cexpr; }
989 const CallExpr *Cexpr;
tools/clang/include/clang/Analysis/AnyCall.h 66 AnyCall(const CallExpr *CE) : E(CE) {
109 } else if (const auto *CE = dyn_cast<CallExpr>(E)) {
109 } else if (const auto *CE = dyn_cast<CallExpr>(E)) {
160 return cast<CallExpr>(E)->getCallReturnType(Ctx);
169 return cast<CallExpr>(E)->getCallReturnType(Ctx);
tools/clang/include/clang/Analysis/ConstructionContext.h 107 ConstructionContextItem(const CallExpr *CE, unsigned Index)
tools/clang/include/clang/Analysis/RetainSummaryManager.h 651 Optional<BehaviorSummary> canEval(const CallExpr *CE, const FunctionDecl *FD,
tools/clang/include/clang/Sema/Overload.h 821 CallExpr::ADLCallKind IsADLCandidate : 1;
882 : IsADLCandidate(CallExpr::NotADL), RewriteKind(CRK_None) {}
tools/clang/include/clang/Sema/Sema.h 1055 SmallVector<CallExpr *, 8> DelayedDecltypeCalls;
3077 using ADLCallKind = CallExpr::ADLCallKind;
3337 CallExpr *CE, FunctionDecl *FD);
4765 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
11247 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
11251 bool CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
11253 bool CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto);
11268 unsigned BuiltinID, CallExpr *TheCall);
11269 void checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall);
11271 bool CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
11273 bool CheckNeonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
11274 bool CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
11275 bool CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
11277 bool CheckAArch64BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
11278 bool CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
11279 bool CheckHexagonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
11280 bool CheckHexagonBuiltinCpu(unsigned BuiltinID, CallExpr *TheCall);
11281 bool CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall);
11282 bool CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
11283 bool CheckSystemZBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
11284 bool CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall);
11285 bool CheckX86BuiltinGatherScatterScale(unsigned BuiltinID, CallExpr *TheCall);
11286 bool CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
11287 bool CheckPPCBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
11289 bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
11290 bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
11291 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
11292 bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs);
11293 bool SemaBuiltinVSX(CallExpr *TheCall);
11294 bool SemaBuiltinOSLogFormat(CallExpr *TheCall);
11298 ExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
11304 bool SemaBuiltinPrefetch(CallExpr *TheCall);
11305 bool SemaBuiltinAllocaWithAlign(CallExpr *TheCall);
11306 bool SemaBuiltinAssume(CallExpr *TheCall);
11307 bool SemaBuiltinAssumeAligned(CallExpr *TheCall);
11308 bool SemaBuiltinLongjmp(CallExpr *TheCall);
11309 bool SemaBuiltinSetjmp(CallExpr *TheCall);
11316 bool SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
11318 bool SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low,
11320 bool SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
11322 bool SemaBuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum);
11323 bool SemaBuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum);
11324 bool SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall, int ArgNum);
11325 bool SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
11328 bool SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall);
11362 void CheckAbsoluteValueFunction(const CallExpr *Call,
11365 void CheckMaxUnsignedZero(const CallExpr *Call, const FunctionDecl *FDecl);
11367 void CheckMemaccessArguments(const CallExpr *Call,
11371 void CheckStrlcpycatArguments(const CallExpr *Call,
11374 void CheckStrncatArguments(const CallExpr *Call,
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h 108 virtual std::string getMessageForReturn(const CallExpr *CallExpr) {
tools/clang/include/clang/StaticAnalyzer/Core/Checker.h 85 ((const CHECKER *)checker)->checkPreStmt(cast<STMT>(S), C);
89 return isa<STMT>(S);
104 ((const CHECKER *)checker)->checkPostStmt(cast<STMT>(S), C);
108 return isa<STMT>(S);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h 500 SimpleFunctionCall(const CallExpr *CE, ProgramStateRef St,
510 virtual const CallExpr *getOriginExpr() const {
511 return cast<CallExpr>(AnyFunctionCall::getOriginExpr());
536 BlockCall(const CallExpr *CE, ProgramStateRef St,
547 virtual const CallExpr *getOriginExpr() const {
548 return cast<CallExpr>(CallEvent::getOriginExpr());
640 CXXInstanceCall(const CallExpr *CE, ProgramStateRef St,
691 if (const CallExpr *CE = getOriginExpr())
1213 getSimpleCall(const CallExpr *E, ProgramStateRef State,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h 279 const FunctionDecl *getCalleeDecl(const CallExpr *CE) const;
285 const IdentifierInfo *getCalleeIdentifier(const CallExpr *CE) const {
294 StringRef getCalleeName(const CallExpr *CE) const {
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h 442 void VisitCallExpr(const CallExpr *CE, ExplodedNode *Pred,
tools/clang/include/clang/Tooling/FixIt.h 43 template <typename T> CharSourceRange getSourceRange(const T &Node) {
50 StringRef getText(const T &Node, const ASTContext &Context) {
56 template <typename T> FixItHint createRemoval(const T &Node) {
tools/clang/include/clang/Tooling/Transformer/SourceCode.h 32 CharSourceRange getExtendedRange(const T &Node, tok::TokenKind Next,
43 StringRef getText(const T &Node, const ASTContext &Context) {
71 StringRef getExtendedText(const T &Node, tok::TokenKind Next,
tools/clang/lib/ARCMigrate/ObjCMT.cpp 229 return !(isa<ArraySubscriptExpr>(Expr) || isa<CallExpr>(Expr) ||
tools/clang/lib/ARCMigrate/TransGCCalls.cpp 36 bool VisitCallExpr(CallExpr *E) {
tools/clang/lib/ARCMigrate/TransUnbridgedCasts.cpp 134 if (CallExpr *callE = dyn_cast<CallExpr>(inner)) {
134 if (CallExpr *callE = dyn_cast<CallExpr>(inner)) {
274 void rewriteCastForCFRetain(CastExpr *castE, CallExpr *callE) {
354 CallExpr *callE;
414 bool isPassedToCFRetain(Expr *E, CallExpr *&callE) const {
415 if ((callE = dyn_cast_or_null<CallExpr>(
428 if (CallExpr *callE = dyn_cast_or_null<CallExpr>(
428 if (CallExpr *callE = dyn_cast_or_null<CallExpr>(
tools/clang/lib/ARCMigrate/Transforms.cpp 84 if (const CallExpr *
85 callE = dyn_cast<CallExpr>(E->IgnoreParenCasts())) {
tools/clang/lib/AST/ASTImporter.cpp 601 ExpectedStmt VisitCallExpr(CallExpr *E);
7475 ExpectedStmt ASTNodeImporter::VisitCallExpr(CallExpr *E) {
7497 return CallExpr::Create(Importer.getToContext(), ToCallee, ToArgs, ToType,
tools/clang/lib/AST/Expr.cpp 1381 CallExpr *CallExpr::Create(const ASTContext &Ctx, Expr *Fn,
1387 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
1389 Ctx.Allocate(sizeof(CallExpr) + SizeOfTrailingObjects, alignof(CallExpr));
1389 Ctx.Allocate(sizeof(CallExpr) + SizeOfTrailingObjects, alignof(CallExpr));
1390 return new (Mem) CallExpr(CallExprClass, Fn, /*PreArgs=*/{}, Args, Ty, VK,
1394 CallExpr *CallExpr::CreateTemporary(void *Mem, Expr *Fn, QualType Ty,
1399 return new (Mem) CallExpr(CallExprClass, Fn, /*PreArgs=*/{}, /*Args=*/{}, Ty,
1403 CallExpr *CallExpr::CreateEmpty(const ASTContext &Ctx, unsigned NumArgs,
1406 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
1408 Ctx.Allocate(sizeof(CallExpr) + SizeOfTrailingObjects, alignof(CallExpr));
1408 Ctx.Allocate(sizeof(CallExpr) + SizeOfTrailingObjects, alignof(CallExpr));
1409 return new (Mem) CallExpr(CallExprClass, /*NumPreArgs=*/0, NumArgs, Empty);
1415 return sizeof(CallExpr);
2542 const CallExpr *CE = cast<CallExpr>(this);
2542 const CallExpr *CE = cast<CallExpr>(this);
2676 !isa<CallExpr>(CE->getSubExpr()->IgnoreParens())) {
3423 const Decl *FD = cast<CallExpr>(this)->getCalleeDecl();
3638 void VisitCallExpr(const CallExpr *E) {
tools/clang/lib/AST/ExprCXX.cpp 642 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
654 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
701 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
712 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
941 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
952 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs);
1719 CUDAKernelCallExpr::CUDAKernelCallExpr(Expr *Fn, CallExpr *Config,
1731 CUDAKernelCallExpr::Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config,
1737 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/END_PREARG, NumArgs);
1748 CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/END_PREARG, NumArgs);
tools/clang/lib/AST/ExprClassification.cpp 308 return ClassifyUnnamed(Ctx, cast<CallExpr>(E)->getCallReturnType(Ctx));
tools/clang/lib/AST/ExprConstant.cpp 147 static const AllocSizeAttr *getAllocSizeAttr(const CallExpr *CE) {
156 static const CallExpr *tryUnwrapAllocSizeCall(const Expr *E) {
170 if (const auto *CE = dyn_cast<CallExpr>(E))
170 if (const auto *CE = dyn_cast<CallExpr>(E))
1850 static bool IsStringLiteralCall(const CallExpr *E) {
1897 return IsStringLiteralCall(cast<CallExpr>(E));
5959 static bool HandleOperatorNewCall(EvalInfo &Info, const CallExpr *E,
6089 bool HandleOperatorDeleteCall(EvalInfo &Info, const CallExpr *E) {
6799 if (const CallExpr *CallCE =
6800 dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts()))
6834 bool VisitCallExpr(const CallExpr *E) {
6841 bool handleCallExpr(const CallExpr *E, APValue &Result,
7701 const CallExpr *Call,
7753 const CallExpr *CE = tryUnwrapAllocSizeCall(Base);
7812 bool visitNonBuiltinCallExpr(const CallExpr *E);
7842 bool VisitCallExpr(const CallExpr *E);
7843 bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
8113 bool PointerExprEvaluator::visitNonBuiltinCallExpr(const CallExpr *E) {
8126 bool PointerExprEvaluator::VisitCallExpr(const CallExpr *E) {
8136 bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
8769 bool VisitCallExpr(const CallExpr *E) {
9199 bool VisitCallExpr(const CallExpr *E) {
9435 bool VisitCallExpr(const CallExpr *E) {
9732 bool VisitCallExpr(const CallExpr *E);
9733 bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
10089 EvaluateBuiltinClassifyType(const CallExpr *E, const LangOptions &LangOpts) {
10494 bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
10501 bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
12389 bool VisitCallExpr(const CallExpr *E);
12446 bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) {
13170 bool VisitCallExpr(const CallExpr *E) {
13954 const CallExpr *CE = cast<CallExpr>(E);
13954 const CallExpr *CE = cast<CallExpr>(E);
14175 if (const CallExpr *CallCE
14176 = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
tools/clang/lib/AST/ItaniumMangle.cpp 3510 static bool isParenthesizedADLCallee(const CallExpr *call) {
3762 const CallExpr *CE = cast<CallExpr>(E);
3762 const CallExpr *CE = cast<CallExpr>(E);
tools/clang/lib/AST/JSONNodeDumper.cpp 1225 void JSONNodeDumper::VisitCallExpr(const CallExpr *CE) {
tools/clang/lib/AST/OSLog.cpp 181 ASTContext &Ctx, const CallExpr *E, OSLogBufferLayout &Layout) {
tools/clang/lib/AST/StmtPrinter.cpp 129 void PrintCallArgs(CallExpr *E);
1334 void StmtPrinter::PrintCallArgs(CallExpr *Call) {
1346 void StmtPrinter::VisitCallExpr(CallExpr *Call) {
1688 VisitCallExpr(cast<CallExpr>(Node));
tools/clang/lib/AST/StmtProfile.cpp 1146 void StmtProfiler::VisitCallExpr(const CallExpr *S) {
tools/clang/lib/AST/TextNodeDumper.cpp 694 void TextNodeDumper::VisitCallExpr(const CallExpr *Node) {
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp 621 const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
tools/clang/lib/ASTMatchers/Dynamic/Marshallers.h 75 return Value.isMatcher() && Value.getMatcher().hasTypedMatcher<T>();
78 static ast_matchers::internal::Matcher<T> get(const VariantValue &Value) {
79 return Value.getMatcher().getTypedMatcher<T>();
83 return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
361 RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
466 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
469 DerivedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<DerivedT>()) {
778 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT>
tools/clang/lib/Analysis/BodyFarm.cpp 249 static CallExpr *create_call_once_funcptr_call(ASTContext &C, ASTMaker M,
271 return CallExpr::Create(C, SubExpr, CallArgs, C.VoidTy, VK_RValue,
275 static CallExpr *create_call_once_lambda_call(ASTContext &C, ASTMaker M,
429 CallExpr *CallbackCall;
511 CallExpr *CE = CallExpr::Create(
511 CallExpr *CE = CallExpr::Create(
581 CallExpr *CE =
582 CallExpr::Create(C, ICE, None, C.VoidTy, VK_RValue, SourceLocation());
tools/clang/lib/Analysis/CFG.cpp 429 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
429 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
548 CFGBlock *VisitCallExpr(CallExpr *C, AddStmtChoice asc);
726 void findConstructionContextsForArguments(CallLikeExpr *E) {
810 void appendCall(CFGBlock *B, CallExpr *CE) {
2157 return VisitCallExpr(cast<CallExpr>(S), asc);
2564 CFGBlock *CFGBuilder::VisitCallExpr(CallExpr *C, AddStmtChoice asc) {
tools/clang/lib/Analysis/CallGraph.cpp 55 Decl *getDeclFromCall(CallExpr *CE) {
76 void VisitCallExpr(CallExpr *CE) {
tools/clang/lib/Analysis/Consumed.cpp 497 bool handleCall(const CallExpr *Call, const Expr *ObjArg,
501 void VisitCallExpr(const CallExpr *Call);
611 bool ConsumedStmtVisitor::handleCall(const CallExpr *Call, const Expr *ObjArg,
740 void ConsumedStmtVisitor::VisitCallExpr(const CallExpr *Call) {
tools/clang/lib/Analysis/ReachableCode.cpp 76 if (const auto *CE = dyn_cast<CallExpr>(CS->getStmt())) {
76 if (const auto *CE = dyn_cast<CallExpr>(CS->getStmt())) {
215 dyn_cast_or_null<FunctionDecl>(cast<CallExpr>(S)->getCalleeDecl());
tools/clang/lib/Analysis/RetainSummaryManager.cpp 713 RetainSummaryManager::canEval(const CallExpr *CE, const FunctionDecl *FD,
tools/clang/lib/Analysis/ThreadSafety.cpp 1046 const CallExpr* getTrylockCallExpr(const Stmt *Cond, LocalVarContext C,
1424 const CallExpr* ThreadSafetyAnalyzer::getTrylockCallExpr(const Stmt *Cond,
1430 if (const auto *CallExp = dyn_cast<CallExpr>(Cond)) {
1430 if (const auto *CallExp = dyn_cast<CallExpr>(Cond)) {
1510 const auto *Exp = getTrylockCallExpr(Cond, LVarCtx, Negate);
1592 CallExpr::const_arg_iterator ArgBegin,
1593 CallExpr::const_arg_iterator ArgEnd,
1604 void VisitCallExpr(const CallExpr *Exp);
2003 CallExpr::const_arg_iterator ArgBegin,
2004 CallExpr::const_arg_iterator ArgEnd,
2032 void BuildLockset::VisitCallExpr(const CallExpr *Exp) {
2153 } else if (isa<CallExpr>(E) && E->isRValue()) {
tools/clang/lib/Analysis/ThreadSafetyCommon.cpp 115 } else if (const auto *CE = dyn_cast<CallExpr>(DeclExp)) {
115 } else if (const auto *CE = dyn_cast<CallExpr>(DeclExp)) {
217 return translateCallExpr(cast<CallExpr>(S), Ctx);
374 til::SExpr *SExprBuilder::translateCallExpr(const CallExpr *CE,
412 return translateCallExpr(cast<CallExpr>(ME), Ctx,
427 return translateCallExpr(cast<CallExpr>(OCE), Ctx);
tools/clang/lib/Analysis/UninitializedValues.cpp 351 void VisitCallExpr(CallExpr *CE);
468 void ClassifyRefs::VisitCallExpr(CallExpr *CE) {
480 for (CallExpr::arg_iterator I = CE->arg_begin(), E = CE->arg_end();
536 void VisitCallExpr(CallExpr *ce);
741 void TransferFunctions::VisitCallExpr(CallExpr *ce) {
tools/clang/lib/Analysis/plugins/SampleAnalyzer/MainCallChecker.cpp 10 class MainCallChecker : public Checker<check::PreStmt<CallExpr>> {
14 void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
18 void MainCallChecker::checkPreStmt(const CallExpr *CE,
tools/clang/lib/CodeGen/Address.h 108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGBlocks.cpp 1254 RValue CodeGenFunction::EmitBlockCallExpr(const CallExpr *E,
tools/clang/lib/CodeGen/CGBuiltin.cpp 118 CodeGenFunction &CGF, llvm::AtomicRMWInst::BinOp Kind, const CallExpr *E,
145 static Value *EmitNontemporalStore(CodeGenFunction &CGF, const CallExpr *E) {
159 static Value *EmitNontemporalLoad(CodeGenFunction &CGF, const CallExpr *E) {
169 const CallExpr *E) {
178 const CallExpr *E,
225 static Value *MakeAtomicCmpXchgValue(CodeGenFunction &CGF, const CallExpr *E,
269 Value *EmitAtomicCmpXchgForMSIntrin(CodeGenFunction &CGF, const CallExpr *E,
295 static Value *EmitAtomicIncrementValue(CodeGenFunction &CGF, const CallExpr *E,
308 static Value *EmitAtomicDecrementValue(CodeGenFunction &CGF, const CallExpr *E,
322 static Value *EmitISOVolatileLoad(CodeGenFunction &CGF, const CallExpr *E) {
335 static Value *EmitISOVolatileStore(CodeGenFunction &CGF, const CallExpr *E) {
352 const CallExpr *E,
362 const CallExpr *E,
373 const CallExpr *E,
385 const CallExpr *E,
396 const CallExpr *E,
446 const CallExpr *E, llvm::Constant *calleeValue) {
697 const CallExpr *E, Value *BitBase,
744 const CallExpr *E) {
832 const CallExpr *E) {
912 const CallExpr *E) {
1224 RValue CodeGenFunction::emitBuiltinOSLogFormat(const CallExpr &E) {
1516 RValue CodeGenFunction::emitRotate(const CallExpr *E, bool IsRotateRight) {
1532 const CallExpr *E,
3382 const CallExpr *Call = cast<CallExpr>(E->getArg(0));
3382 const CallExpr *Call = cast<CallExpr>(E->getArg(0));
4231 unsigned BuiltinID, const CallExpr *E,
4272 const CallExpr *E,
5136 const CallExpr *E) {
5175 const CallExpr *E) {
5237 const char *NameHint, unsigned Modifier, const CallExpr *E,
5911 const CallExpr *E,
6008 const CallExpr *E,
6790 const CallExpr *E,
6891 const CallExpr *E,
7048 const CallExpr *E,
9433 const CallExpr *E) {
10004 Value *CodeGenFunction::EmitX86CpuIs(const CallExpr *E) {
10012 const CallExpr *E,
10067 Value *CodeGenFunction::EmitX86CpuSupports(const CallExpr *E) {
10157 const CallExpr *E) {
12380 const CallExpr *E) {
12824 const CallExpr *E) {
13020 const CallExpr *E) {
13034 const CallExpr *E) {
13616 CodeGenFunction::EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E) {
14066 const CallExpr *E) {
14448 const CallExpr *E) {
tools/clang/lib/CodeGen/CGCall.cpp 3405 llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange,
3457 CallExpr::const_arg_iterator Arg = ArgRange.begin() + Idx;
4592 const CallExpr *CE = getVirtualCallExpr();
tools/clang/lib/CodeGen/CGCall.h 84 const CallExpr *CE;
144 static CGCallee forVirtual(const CallExpr *CE, GlobalDecl MD, Address Addr,
195 const CallExpr *getVirtualCallExpr() const {
tools/clang/lib/CodeGen/CGClass.cpp 1176 } else if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
1176 } else if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
tools/clang/lib/CodeGen/CGCoroutine.cpp 82 CallExpr const *CoroIdExpr = nullptr;
92 CallExpr const *CoroIdExpr = nullptr) {
296 return cast<CallExpr>(RE)->getCallReturnType(Ctx);
696 RValue CodeGenFunction::EmitCoroutineIntrinsic(const CallExpr *E,
tools/clang/lib/CodeGen/CGException.cpp 1691 void VisitCallExpr(const CallExpr *E) {
tools/clang/lib/CodeGen/CGExpr.cpp 1269 return EmitCallExprLValue(cast<CallExpr>(E));
4508 RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
4540 RValue CodeGenFunction::EmitSimpleCallExpr(const CallExpr *E,
4657 LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
4773 const CallExpr *E, ReturnValueSlot ReturnValue,
tools/clang/lib/CodeGen/CGExprAgg.cpp 146 void VisitCallExpr(const CallExpr *E);
888 void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
tools/clang/lib/CodeGen/CGExprCXX.cpp 38 QualType ImplicitParamTy, const CallExpr *CE,
82 const CallExpr *CE, CallArgList *RtlArgs) {
95 llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *CE) {
207 const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue,
1313 const CallExpr *TheCall,
tools/clang/lib/CodeGen/CGExprComplex.cpp 182 ComplexPairTy VisitCallExpr(const CallExpr *E);
406 ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
tools/clang/lib/CodeGen/CGExprConstant.cpp 1768 ConstantLValue VisitCallExpr(const CallExpr *E);
1959 ConstantLValueEmitter::VisitCallExpr(const CallExpr *E) {
tools/clang/lib/CodeGen/CGExprScalar.cpp 576 Value *VisitCallExpr(const CallExpr *E) {
tools/clang/lib/CodeGen/CGGPUBuiltin.cpp 69 CodeGenFunction::EmitNVPTXDevicePrintfCallExpr(const CallExpr *E,
tools/clang/lib/CodeGen/CGObjC.cpp 1292 if (CallExpr *call = dyn_cast<CallExpr>(setter)) {
1292 if (CallExpr *call = dyn_cast<CallExpr>(setter)) {
3115 } else if (isa<CallExpr>(e) ||
3554 CallExpr *CalleeExp = cast<CallExpr>(PID->getSetterCXXAssignment());
3554 CallExpr *CalleeExp = cast<CallExpr>(PID->getSetterCXXAssignment());
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 793 if (const auto *CE = dyn_cast<CallExpr>(ReductionOp))
793 if (const auto *CE = dyn_cast<CallExpr>(ReductionOp))
810 const auto *CE = cast<CallExpr>(InitOp);
810 const auto *CE = cast<CallExpr>(InitOp);
5542 if (const auto *CE = dyn_cast<CallExpr>(ReductionOp))
5542 if (const auto *CE = dyn_cast<CallExpr>(ReductionOp))
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 511 void VisitCallExpr(const CallExpr *E) {
tools/clang/lib/CodeGen/CGStmt.cpp 1709 auto *Call = dyn_cast<CallExpr>(S.getCond());
tools/clang/lib/CodeGen/CodeGenFunction.cpp 1537 auto *Call = dyn_cast<CallExpr>(Cond->IgnoreImpCasts());
2176 void CodeGenFunction::checkTargetFeatures(const CallExpr *E,
tools/clang/lib/CodeGen/CodeGenFunction.h 2580 const CallExpr *TheCallExpr, bool IsDelete);
2907 RValue EmitCoroutineIntrinsic(const CallExpr *E, unsigned int IID);
3497 LValue EmitCallExprLValue(const CallExpr *E);
3608 RValue EmitCall(QualType FnType, const CGCallee &Callee, const CallExpr *E,
3610 RValue EmitCallExpr(const CallExpr *E,
3612 RValue EmitSimpleCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
3615 void checkTargetFeatures(const CallExpr *E, const FunctionDecl *TargetDecl);
3679 QualType ImplicitParamTy, const CallExpr *E,
3684 QualType ImplicitParamTy, const CallExpr *E);
3687 RValue EmitCXXMemberOrOperatorMemberCallExpr(const CallExpr *CE,
3710 RValue EmitNVPTXDevicePrintfCallExpr(const CallExpr *E,
3714 const CallExpr *E, ReturnValueSlot ReturnValue);
3716 RValue emitRotate(const CallExpr *E, bool IsRotateRight);
3719 RValue emitBuiltinOSLogFormat(const CallExpr &E);
3725 RValue EmitBlockCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue);
3729 llvm::Value *EmitTargetBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
3736 llvm::Value *EmitARMBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
3739 llvm::Value *EmitARMMVEBuiltinExpr(unsigned BuiltinID, const CallExpr *E,
3748 const CallExpr *E,
3755 const CallExpr *E);
3766 llvm::Value *EmitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
3768 llvm::Value *EmitBPFBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
3771 llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
3772 llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
3773 llvm::Value *EmitAMDGPUBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
3774 llvm::Value *EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
3775 llvm::Value *EmitNVPTXBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
3777 const CallExpr *E);
3778 llvm::Value *EmitHexagonBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
3784 llvm::Value *EmitMSVCBuiltinExpr(MSVCIntrin BuiltinID, const CallExpr *E);
4248 llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange,
4253 CallExpr::const_arg_iterator Arg = ArgRange.begin();
4295 llvm::iterator_range<CallExpr::const_arg_iterator> ArgRange,
4363 llvm::Value *EmitX86CpuIs(const CallExpr *E);
4365 llvm::Value *EmitX86CpuSupports(const CallExpr *E);
tools/clang/lib/CodeGen/CodeGenModule.cpp 2582 bool VisitCallExpr(const CallExpr *E) {
tools/clang/lib/CodeGen/CoverageMappingGen.cpp 940 void VisitCallExpr(const CallExpr *E) {
tools/clang/lib/Edit/RewriteObjCFoundationAPI.cpp 894 isa<CallExpr>(Expr) ||
916 isa<CallExpr>(Expr) ||
tools/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp 412 CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD,
476 Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp);
2081 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2088 CallExpr *
2107 CallExpr *Exp = CallExpr::Create(
2107 CallExpr *Exp = CallExpr::Create(
2635 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2644 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2688 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2688 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2728 CallExpr::Create(*Context, NSArrayDRE, InitExprs, NSArrayFType, VK_LValue,
2758 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2768 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2809 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2809 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2857 CallExpr::Create(*Context, NSDictDRE, ValueExprs, NSDictFType, VK_LValue,
2876 Expr *NSKeyCallExpr = CallExpr::Create(
2900 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2909 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2960 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2960 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
3172 CallExpr *STCE = CallExpr::Create(*Context, DRE, MsgExprs, castType,
3172 CallExpr *STCE = CallExpr::Create(*Context, DRE, MsgExprs, castType,
3250 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetMetaClassFunctionDecl,
3273 SuperRep = CallExpr::Create(*Context, DRE, InitExprs, superType,
3314 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
3345 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
3368 SuperRep = CallExpr::Create(*Context, DRE, InitExprs, superType,
3419 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
3533 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
3533 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
4550 Stmt *RewriteModernObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
4640 for (CallExpr::arg_iterator I = Exp->arg_begin(),
4644 CallExpr *CE = CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(),
4644 CallExpr *CE = CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(),
5386 NewRep = CallExpr::Create(*Context, DRE, InitExprs, FType, VK_LValue,
5631 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
5631 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
tools/clang/lib/Frontend/Rewrite/RewriteObjC.cpp 349 CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD,
353 CallExpr *SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
386 Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp);
1996 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2003 CallExpr *
2023 CallExpr *Exp = CallExpr::Create(
2023 CallExpr *Exp = CallExpr::Create(
2583 CallExpr *RewriteObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
2609 CallExpr *STCE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2609 CallExpr *STCE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2676 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetMetaClassFunctionDecl,
2702 SuperRep = CallExpr::Create(*Context, DRE, InitExprs, superType,
2743 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2770 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2797 SuperRep = CallExpr::Create(*Context, DRE, InitExprs, superType,
2848 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2962 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2962 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2971 CallExpr *STCE = SynthMsgSendStretCallExpr(MsgSendStretFlavor,
3718 Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
3808 for (CallExpr::arg_iterator I = Exp->arg_begin(),
3812 CallExpr *CE = CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(),
3812 CallExpr *CE = CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(),
4522 NewRep = CallExpr::Create(*Context, DRE, InitExprs, FType, VK_LValue,
4733 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
4733 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
tools/clang/lib/Index/IndexBody.cpp 93 } else if (auto CE = dyn_cast<CallExpr>(Parent)) {
tools/clang/lib/Sema/AnalysisBasedWarnings.cpp 192 const CallExpr *CE = dyn_cast<CallExpr>(B.getAs<CFGStmt>()->getStmt());
192 const CallExpr *CE = dyn_cast<CallExpr>(B.getAs<CFGStmt>()->getStmt());
tools/clang/lib/Sema/SemaCUDA.cpp 529 } else if (const CallExpr *CE = dyn_cast<CallExpr>(Init)) {
529 } else if (const CallExpr *CE = dyn_cast<CallExpr>(Init)) {
tools/clang/lib/Sema/SemaCast.cpp 2552 if (!isa<CallExpr>(SrcExpr.get()))
tools/clang/lib/Sema/SemaChecking.cpp 110 static bool checkArgCount(Sema &S, CallExpr *call, unsigned desiredArgCount) {
130 static bool SemaBuiltinAnnotation(Sema &S, CallExpr *TheCall) {
156 static bool SemaBuiltinMSVCAnnotation(Sema &S, CallExpr *TheCall) {
180 static bool SemaBuiltinAddressof(Sema &S, CallExpr *TheCall) {
196 static bool SemaBuiltinPreserveAI(Sema &S, CallExpr *TheCall) {
204 static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall) {
249 static bool SemaBuiltinCallWithStaticChain(Sema &S, CallExpr *BuiltinCall) {
264 auto CE = cast<CallExpr>(Call);
316 CallExpr *TheCall) {
455 static bool SemaBuiltinSEHScopeCheck(Sema &SemaRef, CallExpr *TheCall,
516 static bool checkOpenCLSubgroupExt(Sema &S, CallExpr *Call) {
525 static bool SemaOpenCLBuiltinNDRangeAndBlock(Sema &S, CallExpr *TheCall) {
552 static bool SemaOpenCLBuiltinKernelWorkGroupSize(Sema &S, CallExpr *TheCall) {
569 static bool checkOpenCLEnqueueLocalSizeArgs(Sema &S, CallExpr *TheCall,
580 static bool checkOpenCLEnqueueVariadicArgs(Sema &S, CallExpr *TheCall,
628 static bool SemaOpenCLBuiltinEnqueueKernel(Sema &S, CallExpr *TheCall) {
754 static bool checkOpenCLPipeArg(Sema &S, CallExpr *Call) {
804 static bool checkOpenCLPipePacketType(Sema &S, CallExpr *Call, unsigned Idx) {
827 static bool SemaBuiltinRWPipe(Sema &S, CallExpr *Call) {
882 static bool SemaBuiltinReserveRWPipe(Sema &S, CallExpr *Call) {
911 static bool SemaBuiltinCommitRWPipe(Sema &S, CallExpr *Call) {
934 static bool SemaBuiltinPipePackets(Sema &S, CallExpr *Call) {
954 CallExpr *Call) {
997 static ExprResult SemaBuiltinLaunder(Sema &S, CallExpr *TheCall) {
1060 CheckBuiltinTargetSupport(Sema &S, unsigned BuiltinID, CallExpr *TheCall,
1073 CallExpr *TheCall) {
1652 bool Sema::CheckNeonBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
1720 bool Sema::CheckMVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
1728 bool Sema::CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall,
1843 bool Sema::CheckARMBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
1896 CallExpr *TheCall) {
1959 CallExpr *TheCall) {
1992 bool Sema::CheckHexagonBuiltinCpu(unsigned BuiltinID, CallExpr *TheCall) {
2811 bool Sema::CheckHexagonBuiltinArgument(unsigned BuiltinID, CallExpr *TheCall) {
3047 CallExpr *TheCall) {
3062 bool Sema::CheckMipsBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
3235 bool Sema::CheckPPCBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
3301 CallExpr *TheCall) {
3368 static bool SemaBuiltinCpuSupports(Sema &S, CallExpr *TheCall) {
3388 static bool SemaBuiltinCpuIs(Sema &S, CallExpr *TheCall) {
3406 bool Sema::CheckX86BuiltinRoundingOrSAE(unsigned BuiltinID, CallExpr *TheCall) {
3612 CallExpr *TheCall) {
3724 bool Sema::CheckX86BuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
4373 bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
4439 bool Sema::CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
4472 bool Sema::CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto) {
4515 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
4515 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
4999 static bool checkBuiltinArgument(Sema &S, CallExpr *E, unsigned ArgIndex) {
5025 CallExpr *TheCall = static_cast<CallExpr *>(TheCallResult.get());
5392 CallExpr *TheCall = (CallExpr *)TheCallResult.get();
5591 bool Sema::SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall) {
5670 bool Sema::SemaBuiltinVAStartARMMicrosoft(CallExpr *Call) {
5720 bool Sema::SemaBuiltinUnorderedCompare(CallExpr *TheCall) {
5765 bool Sema::SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs) {
5816 bool Sema::SemaBuiltinVSX(CallExpr *TheCall) {
5870 ExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {
5988 bool Sema::SemaBuiltinPrefetch(CallExpr *TheCall) {
6008 bool Sema::SemaBuiltinAssume(CallExpr *TheCall) {
6023 bool Sema::SemaBuiltinAllocaWithAlign(CallExpr *TheCall) {
6056 bool Sema::SemaBuiltinAssumeAligned(CallExpr *TheCall) {
6096 bool Sema::SemaBuiltinOSLogFormat(CallExpr *TheCall) {
6178 bool Sema::SemaBuiltinConstantArg(CallExpr *TheCall, int ArgNum,
6195 bool Sema::SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum,
6228 bool Sema::SemaBuiltinConstantArgMultiple(CallExpr *TheCall, int ArgNum,
6250 bool Sema::SemaBuiltinConstantArgPower2(CallExpr *TheCall, int ArgNum) {
6296 bool Sema::SemaBuiltinConstantArgShiftedByte(CallExpr *TheCall, int ArgNum) {
6320 bool Sema::SemaBuiltinConstantArgShiftedByteOrXXFF(CallExpr *TheCall,
6344 bool Sema::SemaBuiltinARMMemoryTaggingCall(unsigned BuiltinID, CallExpr *TheCall) {
6499 bool Sema::SemaBuiltinARMSpecialReg(unsigned BuiltinID, CallExpr *TheCall,
6600 bool Sema::SemaBuiltinLongjmp(CallExpr *TheCall) {
6621 bool Sema::SemaBuiltinSetjmp(CallExpr *TheCall) {
6958 const CallExpr *CE = cast<CallExpr>(E);
6958 const CallExpr *CE = cast<CallExpr>(E);
9165 void Sema::CheckAbsoluteValueFunction(const CallExpr *Call,
9245 void Sema::CheckMaxUnsignedZero(const CallExpr *Call,
9524 static void CheckMemaccessSize(Sema &S, unsigned BId, const CallExpr *Call) {
9577 void Sema::CheckMemaccessArguments(const CallExpr *Call,
9805 void Sema::CheckStrlcpycatArguments(const CallExpr *Call,
9826 if (const CallExpr *SizeCall = dyn_cast<CallExpr>(SizeArg)) {
9826 if (const CallExpr *SizeCall = dyn_cast<CallExpr>(SizeArg)) {
9881 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
9881 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
9893 void Sema::CheckStrncatArguments(const CallExpr *CE,
10036 if (CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
10036 if (CallExpr* CL = dyn_cast<CallExpr>(LeftExprSansParen))
10040 if (CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
10040 if (CallExpr* CR = dyn_cast<CallExpr>(RightExprSansParen))
11277 static void CheckImplicitArgumentConversions(Sema &S, CallExpr *TheCall,
11305 if (isa<CallExpr>(E))
11699 if (Target->isBooleanType() && isa<CallExpr>(E)) {
11703 CallExpr *CEx = cast<CallExpr>(E);
11703 CallExpr *CEx = cast<CallExpr>(E);
12065 if (CallExpr *Call = dyn_cast<CallExpr>(E))
12065 if (CallExpr *Call = dyn_cast<CallExpr>(E))
12182 } else if (const CallExpr *Call = dyn_cast<CallExpr>(E)) {
12182 } else if (const CallExpr *Call = dyn_cast<CallExpr>(E)) {
12279 if (auto *Call = dyn_cast<CallExpr>(E->IgnoreParenImpCasts())) {
12279 if (auto *Call = dyn_cast<CallExpr>(E->IgnoreParenImpCasts())) {
12457 else if (auto Call = dyn_cast<CallExpr>(E))
12922 void VisitCallExpr(CallExpr *CE) {
13613 } else if (CallExpr *CE = dyn_cast<CallExpr>(e)) {
13613 } else if (CallExpr *CE = dyn_cast<CallExpr>(e)) {
14142 const CallExpr *CE = dyn_cast<CallExpr>(RHSExpr);
14142 const CallExpr *CE = dyn_cast<CallExpr>(RHSExpr);
tools/clang/lib/Sema/SemaCoroutine.cpp 425 CallExpr *AwaitReady = cast<CallExpr>(Calls.Results[ACT::ACT_Ready]);
425 CallExpr *AwaitReady = cast<CallExpr>(Calls.Results[ACT::ACT_Ready]);
440 CallExpr *AwaitSuspend = cast<CallExpr>(Calls.Results[ACT::ACT_Suspend]);
440 CallExpr *AwaitSuspend = cast<CallExpr>(Calls.Results[ACT::ACT_Suspend]);
tools/clang/lib/Sema/SemaDecl.cpp11020 void VisitCallExpr(CallExpr *E) {
tools/clang/lib/Sema/SemaDeclCXX.cpp 3729 void VisitCallExpr(CallExpr *E) {
tools/clang/lib/Sema/SemaExceptionSpec.cpp 992 if (S.getLangOpts().CPlusPlus17 && isa<CallExpr>(E)) {
993 E = cast<CallExpr>(E)->getCallee();
1103 const CallExpr *CE = cast<CallExpr>(E);
1103 const CallExpr *CE = cast<CallExpr>(E);
tools/clang/lib/Sema/SemaExpr.cpp 5026 Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
5631 return CallExpr::Create(Context, Fn, /*Args=*/{}, Context.VoidTy,
5645 Context, Fn, cast<CallExpr>(ExecConfig), ArgExprs,
5653 return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
5682 return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
5870 CallExpr *TheCall;
5875 CUDAKernelCallExpr::Create(Context, Fn, cast<CallExpr>(Config), Args,
5878 TheCall = CallExpr::Create(Context, Fn, Args, ResultTy, VK_RValue,
5892 CallExpr *TheOldCall = TheCall;
5893 TheCall = dyn_cast<CallExpr>(Result.get());
5905 Context, Fn, cast<CallExpr>(Config), Args, ResultTy, VK_RValue,
5908 TheCall = CallExpr::Create(Context, Fn, Args, ResultTy, VK_RValue,
7314 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
7314 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
11582 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
11582 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
17141 CallExpr *CE, FunctionDecl *FD) {
17155 CallExpr *CE;
17158 CallReturnIncompleteDiagnoser(FunctionDecl *FD, CallExpr *CE)
17475 if (isa<CallExpr>(E->getSubExpr())) {
17817 if (CallExpr *call = dyn_cast<CallExpr>(E)) {
17817 if (CallExpr *call = dyn_cast<CallExpr>(E)) {
17934 return CallExpr::Create(Context, E, /*Args=*/{}, Context.IntTy,
tools/clang/lib/Sema/SemaExprCXX.cpp 1329 if (Ty->isDependentType() || CallExpr::hasAnyTypeDependentArguments(Exprs)) {
3443 static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall,
3533 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
3533 CallExpr *TheCall = cast<CallExpr>(TheCallResult.get());
6376 if (CallExpr *Call = dyn_cast<CallExpr>(E)) {
6376 if (CallExpr *Call = dyn_cast<CallExpr>(E)) {
6613 CallExpr *TopCall = TopBind ? dyn_cast<CallExpr>(TopBind->getSubExpr())
6613 CallExpr *TopCall = TopBind ? dyn_cast<CallExpr>(TopBind->getSubExpr())
6637 CallExpr *Call = ExprEvalContexts.back().DelayedDecltypeCalls[I];
6775 CallExpr *CE = dyn_cast<CallExpr>(Base);
6775 CallExpr *CE = dyn_cast<CallExpr>(Base);
7858 if (auto *CE = dyn_cast<CallExpr>(ResultCall))
7858 if (auto *CE = dyn_cast<CallExpr>(ResultCall))
tools/clang/lib/Sema/SemaExprObjC.cpp 3447 ACCResult VisitCallExpr(CallExpr *e) {
tools/clang/lib/Sema/SemaFixItUtils.cpp 69 isa<CallExpr>(Expr) ||
tools/clang/lib/Sema/SemaInit.cpp 6813 } else if (auto *CE = dyn_cast<CallExpr>(Call)) {
6813 } else if (auto *CE = dyn_cast<CallExpr>(Call)) {
6850 if (auto *CE = dyn_cast<CallExpr>(Call)) {
6850 if (auto *CE = dyn_cast<CallExpr>(Call)) {
6953 if (isa<CallExpr>(Init)) {
7200 if (isa<CallExpr>(Init) || isa<CXXConstructExpr>(Init)) {
7606 const CallExpr *CE = dyn_cast<CallExpr>(InitExpr->IgnoreParens());
7606 const CallExpr *CE = dyn_cast<CallExpr>(InitExpr->IgnoreParens());
tools/clang/lib/Sema/SemaOpenMP.cpp13556 CallExpr::Create(Context, OVE, Args, Context.VoidTy, VK_RValue, ELoc);
tools/clang/lib/Sema/SemaOverload.cpp 7157 alignas(CallExpr) char Buffer[sizeof(CallExpr) + sizeof(Stmt *)];
7158 CallExpr *TheTemporaryCall = CallExpr::CreateTemporary(
7158 CallExpr *TheTemporaryCall = CallExpr::CreateTemporary(
12354 CallExpr *CE = CallExpr::Create(Context, Fn, Args, Context.DependentTy,
12354 CallExpr *CE = CallExpr::Create(Context, Fn, Args, Context.DependentTy,
12642 CallExpr *TheCall = CXXOperatorCallExpr::Create(
13365 return CallExpr::Create(Context, MemExprE, Args, Context.VoidTy, VK_RValue,
tools/clang/lib/Sema/SemaStmt.cpp 281 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
281 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
2036 CallExpr *CE = dyn_cast<CallExpr>(E);
2036 CallExpr *CE = dyn_cast<CallExpr>(E);
tools/clang/lib/Sema/TreeTransform.h 3242 ExprResult TheCall = CallExpr::Create(
3247 return SemaRef.SemaBuiltinShuffleVector(cast<CallExpr>(TheCall.get()));
tools/clang/lib/Serialization/ASTReaderStmt.cpp 771 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
2675 S = CallExpr::CreateEmpty(
tools/clang/lib/Serialization/ASTWriterStmt.cpp 680 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
685 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
1230 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp 342 class CFNumberChecker : public Checker< check::PreStmt<CallExpr> > {
348 void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
427 void CFNumberChecker::checkPreStmt(const CallExpr *CE,
tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp 108 void evalMemcpy(CheckerContext &C, const CallExpr *CE) const;
109 void evalMempcpy(CheckerContext &C, const CallExpr *CE) const;
110 void evalMemmove(CheckerContext &C, const CallExpr *CE) const;
111 void evalBcopy(CheckerContext &C, const CallExpr *CE) const;
112 void evalCopyCommon(CheckerContext &C, const CallExpr *CE,
120 void evalMemcmp(CheckerContext &C, const CallExpr *CE) const;
122 void evalstrLength(CheckerContext &C, const CallExpr *CE) const;
123 void evalstrnLength(CheckerContext &C, const CallExpr *CE) const;
125 const CallExpr *CE,
128 void evalStrcpy(CheckerContext &C, const CallExpr *CE) const;
129 void evalStrncpy(CheckerContext &C, const CallExpr *CE) const;
130 void evalStpcpy(CheckerContext &C, const CallExpr *CE) const;
131 void evalStrlcpy(CheckerContext &C, const CallExpr *CE) const;
133 const CallExpr *CE,
139 void evalStrcat(CheckerContext &C, const CallExpr *CE) const;
140 void evalStrncat(CheckerContext &C, const CallExpr *CE) const;
141 void evalStrlcat(CheckerContext &C, const CallExpr *CE) const;
143 void evalStrcmp(CheckerContext &C, const CallExpr *CE) const;
144 void evalStrncmp(CheckerContext &C, const CallExpr *CE) const;
145 void evalStrcasecmp(CheckerContext &C, const CallExpr *CE) const;
146 void evalStrncasecmp(CheckerContext &C, const CallExpr *CE) const;
148 const CallExpr *CE,
152 void evalStrsep(CheckerContext &C, const CallExpr *CE) const;
154 void evalStdCopy(CheckerContext &C, const CallExpr *CE) const;
155 void evalStdCopyBackward(CheckerContext &C, const CallExpr *CE) const;
156 void evalStdCopyCommon(CheckerContext &C, const CallExpr *CE) const;
157 void evalMemset(CheckerContext &C, const CallExpr *CE) const;
158 void evalBzero(CheckerContext &C, const CallExpr *CE) const;
1139 const CallExpr *CE,
1240 void CStringChecker::evalMemcpy(CheckerContext &C, const CallExpr *CE) const {
1249 void CStringChecker::evalMempcpy(CheckerContext &C, const CallExpr *CE) const {
1258 void CStringChecker::evalMemmove(CheckerContext &C, const CallExpr *CE) const {
1267 void CStringChecker::evalBcopy(CheckerContext &C, const CallExpr *CE) const {
1273 void CStringChecker::evalMemcmp(CheckerContext &C, const CallExpr *CE) const {
1347 const CallExpr *CE) const {
1353 const CallExpr *CE) const {
1358 void CStringChecker::evalstrLengthCommon(CheckerContext &C, const CallExpr *CE,
1477 void CStringChecker::evalStrcpy(CheckerContext &C, const CallExpr *CE) const {
1485 void CStringChecker::evalStrncpy(CheckerContext &C, const CallExpr *CE) const {
1493 void CStringChecker::evalStpcpy(CheckerContext &C, const CallExpr *CE) const {
1501 void CStringChecker::evalStrlcpy(CheckerContext &C, const CallExpr *CE) const {
1510 void CStringChecker::evalStrcat(CheckerContext &C, const CallExpr *CE) const {
1518 void CStringChecker::evalStrncat(CheckerContext &C, const CallExpr *CE) const {
1526 void CStringChecker::evalStrlcat(CheckerContext &C, const CallExpr *CE) const {
1539 void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallExpr *CE,
1882 void CStringChecker::evalStrcmp(CheckerContext &C, const CallExpr *CE) const {
1887 void CStringChecker::evalStrncmp(CheckerContext &C, const CallExpr *CE) const {
1893 const CallExpr *CE) const {
1899 const CallExpr *CE) const {
1904 void CStringChecker::evalStrcmpCommon(CheckerContext &C, const CallExpr *CE,
2031 void CStringChecker::evalStrsep(CheckerContext &C, const CallExpr *CE) const {
2090 void CStringChecker::evalStdCopy(CheckerContext &C, const CallExpr *CE) const {
2095 const CallExpr *CE) const {
2100 const CallExpr *CE) const {
2127 void CStringChecker::evalMemset(CheckerContext &C, const CallExpr *CE) const {
2175 void CStringChecker::evalBzero(CheckerContext &C, const CallExpr *CE) const {
2224 const auto *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
2224 const auto *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
2263 const auto *CE = cast<CallExpr>(Call.getOriginExpr());
2263 const auto *CE = cast<CallExpr>(Call.getOriginExpr());
tools/clang/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp 55 if (const auto *CE = dyn_cast<CallExpr>(E)) {
55 if (const auto *CE = dyn_cast<CallExpr>(E)) {
80 bool containsBadStrncatPattern(const CallExpr *CE);
101 bool containsBadStrlcpyStrlcatPattern(const CallExpr *CE);
112 void VisitCallExpr(CallExpr *CE);
122 bool WalkAST::containsBadStrncatPattern(const CallExpr *CE) {
153 bool WalkAST::containsBadStrlcpyStrlcatPattern(const CallExpr *CE) {
213 void WalkAST::VisitCallExpr(CallExpr *CE) {
tools/clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp 32 : public Checker< check::PreStmt<CallExpr>,
54 void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
314 void CallAndMessageChecker::checkPreStmt(const CallExpr *CE,
tools/clang/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp 85 void VisitCallExpr(CallExpr *CE);
93 bool checkCall_strCommon(const CallExpr *CE, const FunctionDecl *FD);
99 void checkCall_bcmp(const CallExpr *CE, const FunctionDecl *FD);
100 void checkCall_bcopy(const CallExpr *CE, const FunctionDecl *FD);
101 void checkCall_bzero(const CallExpr *CE, const FunctionDecl *FD);
102 void checkCall_gets(const CallExpr *CE, const FunctionDecl *FD);
103 void checkCall_getpw(const CallExpr *CE, const FunctionDecl *FD);
104 void checkCall_mktemp(const CallExpr *CE, const FunctionDecl *FD);
105 void checkCall_mkstemp(const CallExpr *CE, const FunctionDecl *FD);
106 void checkCall_strcpy(const CallExpr *CE, const FunctionDecl *FD);
107 void checkCall_strcat(const CallExpr *CE, const FunctionDecl *FD);
108 void checkDeprecatedOrUnsafeBufferHandling(const CallExpr *CE,
110 void checkCall_rand(const CallExpr *CE, const FunctionDecl *FD);
111 void checkCall_random(const CallExpr *CE, const FunctionDecl *FD);
112 void checkCall_vfork(const CallExpr *CE, const FunctionDecl *FD);
113 void checkUncheckedReturnValue(CallExpr *CE);
127 void WalkAST::VisitCallExpr(CallExpr *CE) {
188 if (CallExpr *CE = dyn_cast<CallExpr>(Child))
188 if (CallExpr *CE = dyn_cast<CallExpr>(Child))
330 void WalkAST::checkCall_bcmp(const CallExpr *CE, const FunctionDecl *FD) {
372 void WalkAST::checkCall_bcopy(const CallExpr *CE, const FunctionDecl *FD) {
415 void WalkAST::checkCall_bzero(const CallExpr *CE, const FunctionDecl *FD) {
457 void WalkAST::checkCall_gets(const CallExpr *CE, const FunctionDecl *FD) {
493 void WalkAST::checkCall_getpw(const CallExpr *CE, const FunctionDecl *FD) {
533 void WalkAST::checkCall_mktemp(const CallExpr *CE, const FunctionDecl *FD) {
574 void WalkAST::checkCall_mkstemp(const CallExpr *CE, const FunctionDecl *FD) {
659 void WalkAST::checkCall_strcpy(const CallExpr *CE, const FunctionDecl *FD) {
698 void WalkAST::checkCall_strcat(const CallExpr *CE, const FunctionDecl *FD) {
735 void WalkAST::checkDeprecatedOrUnsafeBufferHandling(const CallExpr *CE,
806 bool WalkAST::checkCall_strCommon(const CallExpr *CE, const FunctionDecl *FD) {
837 void WalkAST::checkCall_rand(const CallExpr *CE, const FunctionDecl *FD) {
880 void WalkAST::checkCall_random(const CallExpr *CE, const FunctionDecl *FD) {
908 void WalkAST::checkCall_vfork(const CallExpr *CE, const FunctionDecl *FD) {
931 void WalkAST::checkUncheckedReturnValue(CallExpr *CE) {
tools/clang/lib/StaticAnalyzer/Checkers/CheckerDocumentation.cpp 229 bool evalCall(const CallExpr *CE, CheckerContext &C) const { return true; }
tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp 33 mutable llvm::DenseMap<const CallExpr *, ReachedStat> ReachedStats;
35 void analyzerEval(const CallExpr *CE, CheckerContext &C) const;
36 void analyzerCheckInlined(const CallExpr *CE, CheckerContext &C) const;
37 void analyzerWarnIfReached(const CallExpr *CE, CheckerContext &C) const;
38 void analyzerNumTimesReached(const CallExpr *CE, CheckerContext &C) const;
39 void analyzerCrash(const CallExpr *CE, CheckerContext &C) const;
40 void analyzerWarnOnDeadSymbol(const CallExpr *CE, CheckerContext &C) const;
41 void analyzerDump(const CallExpr *CE, CheckerContext &C) const;
42 void analyzerExplain(const CallExpr *CE, CheckerContext &C) const;
43 void analyzerPrintState(const CallExpr *CE, CheckerContext &C) const;
44 void analyzerGetExtent(const CallExpr *CE, CheckerContext &C) const;
45 void analyzerHashDump(const CallExpr *CE, CheckerContext &C) const;
46 void analyzerDenote(const CallExpr *CE, CheckerContext &C) const;
47 void analyzerExpress(const CallExpr *CE, CheckerContext &C) const;
69 const auto *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
69 const auto *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
103 static const char *getArgumentValueString(const CallExpr *CE,
155 void ExprInspectionChecker::analyzerEval(const CallExpr *CE,
167 void ExprInspectionChecker::analyzerWarnIfReached(const CallExpr *CE,
172 void ExprInspectionChecker::analyzerNumTimesReached(const CallExpr *CE,
181 void ExprInspectionChecker::analyzerCheckInlined(const CallExpr *CE,
196 void ExprInspectionChecker::analyzerExplain(const CallExpr *CE,
208 void ExprInspectionChecker::analyzerDump(const CallExpr *CE,
223 void ExprInspectionChecker::analyzerGetExtent(const CallExpr *CE,
242 void ExprInspectionChecker::analyzerPrintState(const CallExpr *CE,
247 void ExprInspectionChecker::analyzerWarnOnDeadSymbol(const CallExpr *CE,
297 void ExprInspectionChecker::analyzerCrash(const CallExpr *CE,
302 void ExprInspectionChecker::analyzerHashDump(const CallExpr *CE,
314 void ExprInspectionChecker::analyzerDenote(const CallExpr *CE,
390 void ExprInspectionChecker::analyzerExpress(const CallExpr *CE,
tools/clang/lib/StaticAnalyzer/Checkers/GCDAntipatternChecker.cpp 186 const auto *SW = Nodes.getNodeAs<CallExpr>(WarnAtNode);
186 const auto *SW = Nodes.getNodeAs<CallExpr>(WarnAtNode);
tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp 38 : public Checker<check::PostStmt<CallExpr>, check::PreStmt<CallExpr>> {
38 : public Checker<check::PostStmt<CallExpr>, check::PreStmt<CallExpr>> {
45 void checkPostStmt(const CallExpr *CE, CheckerContext &C) const;
47 void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
102 bool checkPre(const CallExpr *CE, CheckerContext &C) const;
105 void addSourcesPre(const CallExpr *CE, CheckerContext &C) const;
108 bool propagateFromPre(const CallExpr *CE, CheckerContext &C) const;
121 bool checkUncontrolledFormatString(const CallExpr *CE,
130 bool checkSystemCall(const CallExpr *CE, StringRef Name,
139 bool checkTaintedBufferSize(const CallExpr *CE, const FunctionDecl *FDecl,
145 bool checkCustomSinks(const CallExpr *CE, StringRef Name,
166 using PropagationFuncType = bool (*)(bool IsTainted, const CallExpr *,
225 ProgramStateRef process(const CallExpr *CE, CheckerContext &C) const;
228 static bool postSocket(bool IsTainted, const CallExpr *CE,
443 void GenericTaintChecker::checkPreStmt(const CallExpr *CE,
455 void GenericTaintChecker::checkPostStmt(const CallExpr *CE,
467 void GenericTaintChecker::addSourcesPre(const CallExpr *CE,
494 bool GenericTaintChecker::propagateFromPre(const CallExpr *CE,
532 bool GenericTaintChecker::checkPre(const CallExpr *CE,
584 GenericTaintChecker::TaintPropagationRule::process(const CallExpr *CE,
650 const CallExpr *CE,
697 static bool getPrintfFormatArgumentNum(const CallExpr *CE,
749 const CallExpr *CE, CheckerContext &C) const {
761 bool GenericTaintChecker::checkSystemCall(const CallExpr *CE, StringRef Name,
787 bool GenericTaintChecker::checkTaintedBufferSize(const CallExpr *CE,
824 bool GenericTaintChecker::checkCustomSinks(const CallExpr *CE, StringRef Name,
tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp 1220 bool VisitCallExpr(const CallExpr *CE);
1280 bool PluralMisuseChecker::MethodCrawler::VisitCallExpr(const CallExpr *CE) {
tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp 29 class MacOSKeychainAPIChecker : public Checker<check::PreStmt<CallExpr>,
30 check::PostStmt<CallExpr>,
59 void checkPreStmt(const CallExpr *S, CheckerContext &C) const;
60 void checkPostStmt(const CallExpr *S, CheckerContext &C) const;
249 void MacOSKeychainAPIChecker::checkPreStmt(const CallExpr *CE,
402 void MacOSKeychainAPIChecker::checkPostStmt(const CallExpr *CE,
634 const CallExpr *CE =
635 cast<CallExpr>(N->getLocation().castAs<StmtPoint>().getStmt());
tools/clang/lib/StaticAnalyzer/Checkers/MacOSXAPIChecker.cpp 32 class MacOSXAPIChecker : public Checker< check::PreStmt<CallExpr> > {
38 void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
40 void CheckDispatchOnce(CheckerContext &C, const CallExpr *CE,
64 void MacOSXAPIChecker::CheckDispatchOnce(CheckerContext &C, const CallExpr *CE,
152 void MacOSXAPIChecker::checkPreStmt(const CallExpr *CE,
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp 333 check::PostStmt<CallExpr>, check::PostStmt<CXXNewExpr>,
360 void checkPostStmt(const CallExpr *CE, CheckerContext &C) const;
436 const CallExpr *CE,
449 static ProgramStateRef MallocMemAux(CheckerContext &C, const CallExpr *CE,
463 static ProgramStateRef MallocMemAux(CheckerContext &C, const CallExpr *CE,
474 performKernelMalloc(const CallExpr *CE, CheckerContext &C,
494 ProgramStateRef FreeMemAttr(CheckerContext &C, const CallExpr *CE,
517 ProgramStateRef FreeMemAux(CheckerContext &C, const CallExpr *CE,
559 ProgramStateRef ReallocMemAux(CheckerContext &C, const CallExpr *CE,
576 static ProgramStateRef CallocMem(CheckerContext &C, const CallExpr *CE,
581 bool suppressDeallocationsInSuspiciousContexts(const CallExpr *CE,
709 return (Stmt && (isa<CallExpr>(Stmt) || isa<CXXNewExpr>(Stmt)) &&
732 (isa<CallExpr>(Stmt) || isa<ObjCMessageExpr>(Stmt) ||
745 return ((!Stmt || !isa<CallExpr>(Stmt)) &&
788 std::string getMessageForReturn(const CallExpr *CallExpr) override {
967 const CallExpr *CE, CheckerContext &C, const ProgramStateRef &State) const {
1055 void MallocChecker::checkPostStmt(const CallExpr *CE, CheckerContext &C) const {
1241 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1241 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1482 MallocChecker::MallocMemReturnsAttr(CheckerContext &C, const CallExpr *CE,
1500 const CallExpr *CE,
1511 const CallExpr *CE,
1579 const CallExpr *CE,
1600 ProgramStateRef MallocChecker::FreeMemAux(CheckerContext &C, const CallExpr *CE,
1636 if (const CallExpr *CE = dyn_cast<CallExpr>(S)) {
1636 if (const CallExpr *CE = dyn_cast<CallExpr>(S)) {
1681 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1681 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
2393 const CallExpr *CE,
2497 ProgramStateRef MallocChecker::CallocMem(CheckerContext &C, const CallExpr *CE,
2808 const CallExpr *CE, CheckerContext &C) const {
3251 } else if (const auto *CallE = dyn_cast<CallExpr>(S)) {
3251 } else if (const auto *CallE = dyn_cast<CallExpr>(S)) {
tools/clang/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp 311 if (const CallExpr *TheCall = dyn_cast<CallExpr>(CS->getStmt())) {
311 if (const CallExpr *TheCall = dyn_cast<CallExpr>(CS->getStmt())) {
tools/clang/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp 30 typedef std::pair<const TypeSourceInfo *, const CallExpr *> TypeCallPair;
42 const CallExpr *AllocCall;
46 const CallExpr *AllocCall)
90 TypeCallPair VisitCallExpr(const CallExpr *E) {
190 for (CallExpr::const_arg_iterator ai = i->AllocCall->arg_begin(),
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp 80 void VisitCallExpr(CallExpr *CE);
84 static StringRef getCalleeName(CallExpr *CE) {
96 void WalkAST::VisitCallExpr(CallExpr *CE) {
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp 30 class ObjCContainersChecker : public Checker< check::PreStmt<CallExpr>,
31 check::PostStmt<CallExpr>,
53 void checkPostStmt(const CallExpr *CE, CheckerContext &C) const;
54 void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
86 void ObjCContainersChecker::checkPostStmt(const CallExpr *CE,
109 void ObjCContainersChecker::checkPreStmt(const CallExpr *CE,
tools/clang/lib/StaticAnalyzer/Checkers/PointerArithChecker.cpp 48 check::PostStmt<CallExpr>, check::DeadSymbols> {
69 void checkPostStmt(const CallExpr *CE, CheckerContext &C) const;
217 void PointerArithChecker::checkPostStmt(const CallExpr *CE,
tools/clang/lib/StaticAnalyzer/Checkers/PointerSortingChecker.cpp 40 const auto *MarkedStmt = Match.getNodeAs<CallExpr>(WarnAtNode);
40 const auto *MarkedStmt = Match.getNodeAs<CallExpr>(WarnAtNode);
tools/clang/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp 69 : public Checker<check::PostStmt<CallExpr>, check::DeadSymbols> {
81 void checkPostStmt(const CallExpr *CE, CheckerContext &C) const;
86 void AcquireLock(CheckerContext &C, const CallExpr *CE, SVal lock,
89 void ReleaseLock(CheckerContext &C, const CallExpr *CE, SVal lock) const;
90 void DestroyLock(CheckerContext &C, const CallExpr *CE, SVal Lock,
92 void InitLock(CheckerContext &C, const CallExpr *CE, SVal Lock) const;
93 void reportUseDestroyedBug(CheckerContext &C, const CallExpr *CE) const;
109 void PthreadLockChecker::checkPostStmt(const CallExpr *CE,
216 void PthreadLockChecker::AcquireLock(CheckerContext &C, const CallExpr *CE,
288 void PthreadLockChecker::ReleaseLock(CheckerContext &C, const CallExpr *CE,
346 void PthreadLockChecker::DestroyLock(CheckerContext &C, const CallExpr *CE,
408 void PthreadLockChecker::InitLock(CheckerContext &C, const CallExpr *CE,
449 const CallExpr *CE) const {
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp 896 const auto *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
896 const auto *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp 204 if (const auto *CE = dyn_cast<CallExpr>(S))
204 if (const auto *CE = dyn_cast<CallExpr>(S))
216 if (const CallExpr *CE = dyn_cast<CallExpr>(S)) {
216 if (const CallExpr *CE = dyn_cast<CallExpr>(S)) {
557 if (const CallExpr *CE = dyn_cast<CallExpr>(S)) {
557 if (const CallExpr *CE = dyn_cast<CallExpr>(S)) {
tools/clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp 193 bool matchesCall(const CallExpr *CE) const;
217 static QualType getArgType(const CallExpr *CE, ArgNoTy ArgNo) {
231 const CallExpr *CE,
345 const CallExpr *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
345 const CallExpr *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
376 const auto *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
376 const auto *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
404 const CallExpr *CE) const {
433 const CallExpr *CE,
tools/clang/lib/StaticAnalyzer/Checkers/StreamChecker.cpp 79 void Fopen(CheckerContext &C, const CallExpr *CE) const;
80 void Tmpfile(CheckerContext &C, const CallExpr *CE) const;
81 void Fclose(CheckerContext &C, const CallExpr *CE) const;
82 void Fread(CheckerContext &C, const CallExpr *CE) const;
83 void Fwrite(CheckerContext &C, const CallExpr *CE) const;
84 void Fseek(CheckerContext &C, const CallExpr *CE) const;
85 void Ftell(CheckerContext &C, const CallExpr *CE) const;
86 void Rewind(CheckerContext &C, const CallExpr *CE) const;
87 void Fgetpos(CheckerContext &C, const CallExpr *CE) const;
88 void Fsetpos(CheckerContext &C, const CallExpr *CE) const;
89 void Clearerr(CheckerContext &C, const CallExpr *CE) const;
90 void Feof(CheckerContext &C, const CallExpr *CE) const;
91 void Ferror(CheckerContext &C, const CallExpr *CE) const;
92 void Fileno(CheckerContext &C, const CallExpr *CE) const;
94 void OpenFileAux(CheckerContext &C, const CallExpr *CE) const;
98 ProgramStateRef CheckDoubleClose(const CallExpr *CE, ProgramStateRef state,
112 const auto *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
112 const auto *CE = dyn_cast_or_null<CallExpr>(Call.getOriginExpr());
206 void StreamChecker::Fopen(CheckerContext &C, const CallExpr *CE) const {
210 void StreamChecker::Tmpfile(CheckerContext &C, const CallExpr *CE) const {
214 void StreamChecker::OpenFileAux(CheckerContext &C, const CallExpr *CE) const {
241 void StreamChecker::Fclose(CheckerContext &C, const CallExpr *CE) const {
247 void StreamChecker::Fread(CheckerContext &C, const CallExpr *CE) const {
253 void StreamChecker::Fwrite(CheckerContext &C, const CallExpr *CE) const {
259 void StreamChecker::Fseek(CheckerContext &C, const CallExpr *CE) const {
285 void StreamChecker::Ftell(CheckerContext &C, const CallExpr *CE) const {
291 void StreamChecker::Rewind(CheckerContext &C, const CallExpr *CE) const {
297 void StreamChecker::Fgetpos(CheckerContext &C, const CallExpr *CE) const {
303 void StreamChecker::Fsetpos(CheckerContext &C, const CallExpr *CE) const {
309 void StreamChecker::Clearerr(CheckerContext &C, const CallExpr *CE) const {
315 void StreamChecker::Feof(CheckerContext &C, const CallExpr *CE) const {
321 void StreamChecker::Ferror(CheckerContext &C, const CallExpr *CE) const {
327 void StreamChecker::Fileno(CheckerContext &C, const CallExpr *CE) const {
356 ProgramStateRef StreamChecker::CheckDoubleClose(const CallExpr *CE,
tools/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp 40 class UnixAPIMisuseChecker : public Checker< check::PreStmt<CallExpr> > {
47 void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
49 void CheckOpen(CheckerContext &C, const CallExpr *CE) const;
50 void CheckOpenAt(CheckerContext &C, const CallExpr *CE) const;
51 void CheckPthreadOnce(CheckerContext &C, const CallExpr *CE) const;
54 const CallExpr *CE, OpenVariant Variant) const;
63 class UnixAPIPortabilityChecker : public Checker< check::PreStmt<CallExpr> > {
65 void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
70 void CheckCallocZero(CheckerContext &C, const CallExpr *CE) const;
71 void CheckMallocZero(CheckerContext &C, const CallExpr *CE) const;
72 void CheckReallocZero(CheckerContext &C, const CallExpr *CE) const;
73 void CheckReallocfZero(CheckerContext &C, const CallExpr *CE) const;
74 void CheckAllocaZero(CheckerContext &C, const CallExpr *CE) const;
75 void CheckAllocaWithAlignZero(CheckerContext &C, const CallExpr *CE) const;
76 void CheckVallocZero(CheckerContext &C, const CallExpr *CE) const;
83 const CallExpr *CE,
103 void UnixAPIMisuseChecker::checkPreStmt(const CallExpr *CE,
144 const CallExpr *CE) const {
149 const CallExpr *CE) const {
154 const CallExpr *CE,
274 const CallExpr *CE) const {
364 const CallExpr *CE,
393 const CallExpr *CE) const {
429 const CallExpr *CE) const {
434 const CallExpr *CE) const {
439 const CallExpr *CE) const {
444 const CallExpr *CE) const {
450 const CallExpr *CE) const {
455 const CallExpr *CE) const {
459 void UnixAPIPortabilityChecker::checkPreStmt(const CallExpr *CE,
tools/clang/lib/StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp 133 if (const CallExpr *CE = dyn_cast<CallExpr>(S->getStmt())) {
133 if (const CallExpr *CE = dyn_cast<CallExpr>(S->getStmt())) {
tools/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp 62 static bool isVirtualCall(const CallExpr *CE) {
109 const auto *CE = cast<CallExpr>(Call.getOriginExpr());
109 const auto *CE = cast<CallExpr>(Call.getOriginExpr());
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp 289 const auto *CE = dyn_cast_or_null<CallExpr>(CallSite);
289 const auto *CE = dyn_cast_or_null<CallExpr>(CallSite);
295 for (CallExpr::const_arg_iterator I = CE->arg_begin(),
tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp 457 return isa<CallExpr>(S) || isa<ObjCMessageExpr>(S)
670 const auto *CE = cast_or_null<CallExpr>(getOriginExpr());
670 const auto *CE = cast_or_null<CallExpr>(getOriginExpr());
1359 CallEventManager::getSimpleCall(const CallExpr *CE, ProgramStateRef State,
1432 if (const auto *CE = dyn_cast<CallExpr>(S)) {
1432 if (const auto *CE = dyn_cast<CallExpr>(S)) {
tools/clang/lib/StaticAnalyzer/Core/CheckerContext.cpp 21 const FunctionDecl *CheckerContext::getCalleeDecl(const CallExpr *CE) const {
tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp 665 cast<CallExpr>(Call.getOriginExpr()),
tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp 1591 VisitCallExpr(cast<CallExpr>(S), Pred, Dst);
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp 353 if (const auto *CE = dyn_cast<CallExpr>(E)) {
353 if (const auto *CE = dyn_cast<CallExpr>(E)) {
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp 496 void ExprEngine::VisitCallExpr(const CallExpr *CE, ExplodedNode *Pred,
tools/clang/lib/Tooling/Refactoring/ASTSelection.cpp 279 else if (const auto *CE = dyn_cast<CallExpr>(Parent)) {
279 else if (const auto *CE = dyn_cast<CallExpr>(Parent)) {
tools/clang/lib/Tooling/Transformer/RangeSelector.cpp 100 static SourceLocation findOpenParen(const CallExpr &E, const SourceManager &SM,
241 if (const auto *Arg = N->get<T>())
241 if (const auto *Arg = N->get<T>())
268 const CallExpr &CE) {
tools/clang/tools/extra/clang-change-namespace/ChangeNamespace.cpp 631 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
631 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
tools/clang/tools/extra/clang-tidy/abseil/DurationAdditionCheck.cpp 35 const CallExpr *Call = Result.Nodes.getNodeAs<clang::CallExpr>("call");
35 const CallExpr *Call = Result.Nodes.getNodeAs<clang::CallExpr>("call");
tools/clang/tools/extra/clang-tidy/abseil/DurationFactoryFloatCheck.cpp 45 const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>("call");
45 const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>("call");
tools/clang/tools/extra/clang-tidy/abseil/DurationFactoryScaleCheck.cpp 141 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
141 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
tools/clang/tools/extra/clang-tidy/abseil/FasterStrsplitDelimiterCheck.cpp 122 << (Result.Nodes.getNodeAs<CallExpr>("StrSplit") ? 0 : 1)
tools/clang/tools/extra/clang-tidy/abseil/RedundantStrcatCallsCheck.cpp 51 void RemoveCallLeaveArgs(const CallExpr* Call, StrCatCheckResult* CheckResult) {
62 const clang::CallExpr* ProcessArgument(const Expr* Arg,
69 if (const auto* SubStrcatCall = selectFirst<const CallExpr>(
69 if (const auto* SubStrcatCall = selectFirst<const CallExpr>(
81 StrCatCheckResult ProcessCall(const CallExpr* RootCall, bool IsAppend,
84 std::deque<const CallExpr*> CallsToProcess = {RootCall};
89 const CallExpr* CallExpr = CallsToProcess.front();
96 if (const clang::CallExpr* Sub =
109 const CallExpr* RootCall;
110 if ((RootCall = Result.Nodes.getNodeAs<CallExpr>("StrCat")))
112 else if ((RootCall = Result.Nodes.getNodeAs<CallExpr>("StrAppend")))
tools/clang/tools/extra/clang-tidy/abseil/StrCatAppendCheck.cpp 76 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("Call");
76 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("Call");
tools/clang/tools/extra/clang-tidy/abseil/TimeSubtractionCheck.cpp 140 const auto *OuterCall = Result.Nodes.getNodeAs<CallExpr>("outer_call");
140 const auto *OuterCall = Result.Nodes.getNodeAs<CallExpr>("outer_call");
161 const auto *MaybeCallArg = selectFirst<const CallExpr>(
161 const auto *MaybeCallArg = selectFirst<const CallExpr>(
tools/clang/tools/extra/clang-tidy/android/CloexecCheck.cpp 55 const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
55 const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
76 const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
76 const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
84 const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
84 const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
104 const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
104 const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
tools/clang/tools/extra/clang-tidy/boost/UseToStringCheck.cpp 44 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("to_string");
44 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("to_string");
tools/clang/tools/extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp 331 if (const auto *Call = dyn_cast<CallExpr>(E)) {
331 if (const auto *Call = dyn_cast<CallExpr>(E)) {
tools/clang/tools/extra/clang-tidy/bugprone/AssertSideEffectCheck.cpp 54 if (const auto *CExpr = dyn_cast<CallExpr>(E)) {
54 if (const auto *CExpr = dyn_cast<CallExpr>(E)) {
tools/clang/tools/extra/clang-tidy/bugprone/FoldInitTypeCheck.cpp 109 const CallExpr &CallNode) {
127 const auto *CallNode = Result.Nodes.getNodeAs<CallExpr>("Call");
127 const auto *CallNode = Result.Nodes.getNodeAs<CallExpr>("Call");
tools/clang/tools/extra/clang-tidy/bugprone/FoldInitTypeCheck.h 36 const ASTContext &Context, const CallExpr &CallNode);
tools/clang/tools/extra/clang-tidy/bugprone/InaccurateEraseCheck.cpp 60 const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("alg");
60 const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("alg");
tools/clang/tools/extra/clang-tidy/bugprone/InfiniteLoopCheck.cpp 110 } else if (isa<MemberExpr>(Cond) || isa<CallExpr>(Cond)) {
tools/clang/tools/extra/clang-tidy/bugprone/MisplacedOperatorInStrlenInAllocCheck.cpp 74 const Expr *Alloc = Result.Nodes.getNodeAs<CallExpr>("Alloc");
80 const auto *StrLen = Result.Nodes.getNodeAs<CallExpr>("StrLen");
80 const auto *StrLen = Result.Nodes.getNodeAs<CallExpr>("StrLen");
tools/clang/tools/extra/clang-tidy/bugprone/MoveForwardingReferenceCheck.cpp 97 const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
97 const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
tools/clang/tools/extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp 103 static const CallExpr *getStrlenExpr(const MatchFinder::MatchResult &Result) {
104 if (const auto *StrlenExpr =
105 Result.Nodes.getNodeAs<CallExpr>(WrongLengthExprName))
130 if (const CallExpr *StrlenCE = getStrlenExpr(Result))
238 if (const CallExpr *StrlenCE = getStrlenExpr(Result))
374 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
374 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
413 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
413 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
425 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
425 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
450 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
450 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
471 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
471 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
792 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
792 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
843 diag(Result.Nodes.getNodeAs<CallExpr>(FunctionExprName)->getBeginLoc(),
915 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
915 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
951 diag(Result.Nodes.getNodeAs<CallExpr>(FunctionExprName)->getBeginLoc(),
961 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
961 const auto *FunctionExpr = Result.Nodes.getNodeAs<CallExpr>(FunctionExprName);
966 if (const CallExpr *StrlenExpr = getStrlenExpr(Result)) {
997 diag(Result.Nodes.getNodeAs<CallExpr>(FunctionExprName)->getBeginLoc(),
tools/clang/tools/extra/clang-tidy/bugprone/PosixReturnCheck.cpp 22 const CallExpr *MatchedCall = cast<CallExpr>(
22 const CallExpr *MatchedCall = cast<CallExpr>(
tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousMemsetUsageCheck.cpp 91 else if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call")) {
91 else if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call")) {
tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp 171 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
171 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
tools/clang/tools/extra/clang-tidy/bugprone/SwappedArgumentsCheck.cpp 51 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
51 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
tools/clang/tools/extra/clang-tidy/bugprone/UndefinedMemoryManipulationCheck.cpp 50 if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("dest")) {
50 if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("dest")) {
58 if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("src")) {
58 if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("src")) {
tools/clang/tools/extra/clang-tidy/bugprone/UnusedReturnValueCheck.cpp 87 if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("match")) {
87 if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("match")) {
tools/clang/tools/extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp 410 const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
410 const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
tools/clang/tools/extra/clang-tidy/cert/CommandProcessorCheck.cpp 37 const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr");
37 const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr");
tools/clang/tools/extra/clang-tidy/cert/LimitedRandomnessCheck.cpp 31 const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator");
31 const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator");
tools/clang/tools/extra/clang-tidy/cert/ProperlySeededRandomGeneratorCheck.cpp 88 const auto *Srand = Result.Nodes.getNodeAs<CallExpr>("srand");
88 const auto *Srand = Result.Nodes.getNodeAs<CallExpr>("srand");
tools/clang/tools/extra/clang-tidy/cert/ProperlySeededRandomGeneratorCheck.h 36 const T *Func);
tools/clang/tools/extra/clang-tidy/cert/SetLongJmpCheck.cpp 73 const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr");
73 const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr");
tools/clang/tools/extra/clang-tidy/cert/StrToNumCheck.cpp 181 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("expr");
181 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("expr");
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/NoMallocCheck.cpp 63 const CallExpr *Call = nullptr;
66 if ((Call = Result.Nodes.getNodeAs<CallExpr>("allocation")))
68 else if ((Call = Result.Nodes.getNodeAs<CallExpr>("realloc")))
70 else if ((Call = Result.Nodes.getNodeAs<CallExpr>("free")))
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp 220 const auto *LegacyConsumer = Nodes.getNodeAs<CallExpr>("legacy_consumer");
220 const auto *LegacyConsumer = Nodes.getNodeAs<CallExpr>("legacy_consumer");
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProTypeVarargCheck.cpp 31 static bool hasSingleVariadicArgumentWithValue(const CallExpr *C, uint64_t I) {
52 if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("callvararg")) {
52 if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("callvararg")) {
tools/clang/tools/extra/clang-tidy/darwin/AvoidSpinlockCheck.cpp 28 const auto *MatchedExpr = Result.Nodes.getNodeAs<CallExpr>("spinlock");
28 const auto *MatchedExpr = Result.Nodes.getNodeAs<CallExpr>("spinlock");
tools/clang/tools/extra/clang-tidy/google/ExplicitMakePairCheck.cpp 47 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
47 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
tools/clang/tools/extra/clang-tidy/linuxkernel/MustCheckErrsCheck.cpp 36 const CallExpr *MatchedCallExpr = Result.Nodes.getNodeAs<CallExpr>("call");
36 const CallExpr *MatchedCallExpr = Result.Nodes.getNodeAs<CallExpr>("call");
42 const CallExpr *MatchedTransitiveCallExpr =
43 Result.Nodes.getNodeAs<CallExpr>("transitive_call");
tools/clang/tools/extra/clang-tidy/llvm/PreferIsaOrDynCastInConditionalsCheck.cpp 72 if (const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("assign")) {
72 if (const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("assign")) {
81 } else if (const auto *MatchedDecl =
82 Result.Nodes.getNodeAs<CallExpr>("call")) {
97 const auto *RHS = Result.Nodes.getNodeAs<CallExpr>("rhs");
97 const auto *RHS = Result.Nodes.getNodeAs<CallExpr>("rhs");
tools/clang/tools/extra/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp 124 else if (isa<CallExpr>(currentSubExpr))
tools/clang/tools/extra/clang-tidy/misc/UnusedParametersCheck.cpp 66 const CallExpr *Call, unsigned Index) {
78 const std::unordered_set<const CallExpr *> &
98 bool WalkUpFromCallExpr(CallExpr *Call) {
113 std::unordered_set<const CallExpr *> Calls;
165 for (const CallExpr *Call : Indexer->getFnCalls(Function))
tools/clang/tools/extra/clang-tidy/modernize/AvoidBindCheck.cpp 57 B.Kind = isa<CallExpr>(TE) ? BK_CallExpr : BK_Temporary;
132 const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("bind");
132 const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("bind");
tools/clang/tools/extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp 61 const auto *MatchedCallExpr = Result.Nodes.getNodeAs<CallExpr>("match");
61 const auto *MatchedCallExpr = Result.Nodes.getNodeAs<CallExpr>("match");
tools/clang/tools/extra/clang-tidy/modernize/UseAutoCheck.cpp 489 return cast<CallExpr>(Expr->IgnoreImplicit())
tools/clang/tools/extra/clang-tidy/modernize/UseEmplaceCheck.cpp 124 const auto *MakeCall = Result.Nodes.getNodeAs<CallExpr>("make");
124 const auto *MakeCall = Result.Nodes.getNodeAs<CallExpr>("make");
tools/clang/tools/extra/clang-tidy/modernize/UseUncaughtExceptionsCheck.cpp 53 const CallExpr *C = Result.Nodes.getNodeAs<CallExpr>("init_call_expr");
53 const CallExpr *C = Result.Nodes.getNodeAs<CallExpr>("init_call_expr");
59 } else if (const auto *E = Result.Nodes.getNodeAs<CallExpr>("call_expr")) {
59 } else if (const auto *E = Result.Nodes.getNodeAs<CallExpr>("call_expr")) {
tools/clang/tools/extra/clang-tidy/mpi/BufferDerefCheck.cpp 27 const auto *CE = Result.Nodes.getNodeAs<CallExpr>("CE");
27 const auto *CE = Result.Nodes.getNodeAs<CallExpr>("CE");
tools/clang/tools/extra/clang-tidy/mpi/TypeMismatchCheck.cpp 234 static const Type *argumentType(const CallExpr *const CE, const size_t idx) {
245 const auto *const CE = Result.Nodes.getNodeAs<CallExpr>("CE");
245 const auto *const CE = Result.Nodes.getNodeAs<CallExpr>("CE");
tools/clang/tools/extra/clang-tidy/performance/InefficientAlgorithmCheck.cpp 68 const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("IneffAlg");
68 const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("IneffAlg");
tools/clang/tools/extra/clang-tidy/performance/MoveConstArgCheck.cpp 19 static void ReplaceCallWithArg(const CallExpr *Call, DiagnosticBuilder &Diag,
62 const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
62 const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
tools/clang/tools/extra/clang-tidy/performance/TypePromotionInMathFnCheck.cpp 159 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
159 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
tools/clang/tools/extra/clang-tidy/portability/SIMDIntrinsicsCheck.cpp 111 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
111 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
tools/clang/tools/extra/clang-tidy/readability/NonConstParameterCheck.cpp 61 } else if (const auto *CE = dyn_cast<CallExpr>(S)) {
61 } else if (const auto *CE = dyn_cast<CallExpr>(S)) {
tools/clang/tools/extra/clang-tidy/readability/RedundantStringCStrCheck.cpp 175 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
175 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
tools/clang/tools/extra/clang-tidy/utils/ExceptionAnalyzer.cpp 193 } else if (const auto *Call = dyn_cast<CallExpr>(St)) {
193 } else if (const auto *Call = dyn_cast<CallExpr>(St)) {
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractVariable.cpp 328 const CallExpr *CE =
329 llvm::dyn_cast_or_null<CallExpr>(MaybeCall->ASTNode.get<Expr>());
tools/clang/tools/extra/unittests/clang-tidy/NamespaceAliaserTest.cpp 33 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("foo");
33 const auto *Call = Result.Nodes.getNodeAs<CallExpr>("foo");
tools/clang/tools/extra/unittests/clang-tidy/UsingInserterTest.cpp 35 const auto *Call = Result.Nodes.getNodeAs<clang::CallExpr>("foo");
35 const auto *Call = Result.Nodes.getNodeAs<clang::CallExpr>("foo");
tools/clang/tools/libclang/CIndex.cpp 3701 static StringLiteral* getCFSTR_value(CallExpr *callExpr) {
3809 CallExpr *callExpr;
4359 if (const CallExpr *CE = dyn_cast<CallExpr>(E))
4359 if (const CallExpr *CE = dyn_cast<CallExpr>(E))
tools/clang/tools/libclang/CXCursor.cpp 1184 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1184 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1211 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1211 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1585 else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
1585 else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
1616 else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
1616 else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
tools/clang/unittests/AST/ASTTypeTraitsTest.cpp 25 return ASTNodeKind::getFromNodeKind<T>();
tools/clang/unittests/ASTMatchers/ASTMatchersTest.h 421 if (Nodes->getNodeAs<T>(Id)) {
tools/clang/unittests/StaticAnalyzer/CallDescriptionTest.cpp 59 const CallExpr *CE = findNode<CallExpr>(D, callExpr());
59 const CallExpr *CE = findNode<CallExpr>(D, callExpr());
tools/clang/unittests/StaticAnalyzer/Reusables.h 22 const T *findNode(const Decl *Where, MatcherT What) {
28 const T *Node = selectFirst<T>("root", Matches);
28 const T *Node = selectFirst<T>("root", Matches);
tools/clang/unittests/Tooling/ASTSelectionTest.cpp 107 typename std::enable_if<std::is_base_of<Stmt, T>::value, T>::type
107 typename std::enable_if<std::is_base_of<Stmt, T>::value, T>::type
109 checkNodeImpl(isa<T>(StmtNode.Node.get<Stmt>()), StmtNode, SelectionKind,
319 allChildrenOf(checkNode<CallExpr>(Body.Children[0],
340 checkNode<CallExpr>(Body.Children[0],
365 checkNode<CallExpr>(Body.Children[1],
tools/clang/unittests/Tooling/FixItTest.cpp 22 bool VisitCallExpr(CallExpr *Expr) {
27 std::function<void(CallExpr *, ASTContext *Context)> OnCall;
tools/clang/unittests/Tooling/LookupTest.cpp 15 std::function<void(CallExpr *)> OnCall;
19 bool VisitCallExpr(CallExpr *Expr) {
tools/clang/unittests/Tooling/RefactoringTest.cpp 725 bool VisitCallExpr(CallExpr *Call) {
tools/clang/unittests/Tooling/SourceCodeTest.cpp 36 bool VisitCallExpr(CallExpr *Expr) {
41 std::function<void(CallExpr *, ASTContext *Context)> OnCall;
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
326 : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
354 : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
567 : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
631 : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
798 typedef decltype(__test<_Tp>(0)) type;
811 remove_all_extents<_Tp>::type>::type
825 : public __is_destructible_safe<_Tp>::type
1447 : public __and_<is_destructible<_Tp>, integral_constant<bool,
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1580 { typedef _Tp const type; };
1629 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1955 { typedef _Tp type; };
1983 { typedef _Up type; };
1999 { typedef typename remove_reference<_Tp>::type* type; };
2003 : public __add_pointer_helper<_Tp>
2157 { typedef _Tp type; };