|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/Analysis/ProfileSummaryInfo.h 31 class CallSite;
References
include/llvm/ADT/DenseMap.h 65 using key_type = KeyT;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
121 const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
122 if (is_trivially_copyable<KeyT>::value &&
145 size_type count(const_arg_type_t<KeyT> Val) const {
156 const_iterator find(const_arg_type_t<KeyT> Val) const {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
272 bool erase(const KeyT &Val) {
291 value_type& FindAndConstruct(const KeyT &Key) {
299 ValueT &operator[](const KeyT &Key) {
303 value_type& FindAndConstruct(KeyT &&Key) {
311 ValueT &operator[](KeyT &&Key) {
334 const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
349 const KeyT EmptyKey = getEmptyKey();
351 ::new (&B->getFirst()) KeyT(EmptyKey);
369 const KeyT EmptyKey = getEmptyKey();
370 const KeyT TombstoneKey = getTombstoneKey();
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
414 static unsigned getHashValue(const KeyT &Val) {
419 static unsigned getHashValue(const LookupKeyT &Val) {
423 static const KeyT getEmptyKey() {
429 static const KeyT getTombstoneKey() {
437 if (shouldReverseIterate<KeyT>()) {
515 BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
525 BucketT *InsertIntoBucketWithLookup(BucketT *TheBucket, KeyT &&Key,
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
566 const KeyT EmptyKey = getEmptyKey();
578 bool LookupBucketFor(const LookupKeyT &Val,
590 const KeyT EmptyKey = getEmptyKey();
591 const KeyT TombstoneKey = getTombstoneKey();
629 bool LookupBucketFor(const LookupKeyT &Val, BucketT *&FoundBucket) {
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
685 KeyT, ValueT, KeyInfoT, BucketT> {
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
852 SmallDenseMap<KeyT, ValueT, InlineBuckets, KeyInfoT, BucketT>, KeyT,
852 SmallDenseMap<KeyT, ValueT, InlineBuckets, KeyInfoT, BucketT>, KeyT,
1023 const KeyT EmptyKey = this->getEmptyKey();
1024 const KeyT TombstoneKey = this->getTombstoneKey();
1030 ::new (&TmpEnd->getFirst()) KeyT(std::move(P->getFirst()));
1163 using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
1186 if (shouldReverseIterate<KeyT>()) {
1199 const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
1249 const KeyT Empty = KeyInfoT::getEmptyKey();
1250 const KeyT Tombstone = KeyInfoT::getTombstoneKey();
1259 const KeyT Empty = KeyInfoT::getEmptyKey();
1260 const KeyT Tombstone = KeyInfoT::getTombstoneKey();
include/llvm/ADT/DenseSet.h 35 KeyT key;
38 KeyT &getFirst() { return key; }
39 const KeyT &getFirst() const { return key; }
55 static_assert(sizeof(typename MapTy::value_type) == sizeof(ValueT),
63 using key_type = ValueT;
64 using value_type = ValueT;
69 DenseSetImpl(std::initializer_list<ValueT> Elems)
91 size_type count(const_arg_type_t<ValueT> V) const {
95 bool erase(const ValueT &V) {
112 using value_type = ValueT;
120 ValueT &operator*() { return I->getFirst(); }
121 const ValueT &operator*() const { return I->getFirst(); }
122 ValueT *operator->() { return &I->getFirst(); }
123 const ValueT *operator->() const { return &I->getFirst(); }
165 iterator find(const_arg_type_t<ValueT> V) { return Iterator(TheMap.find(V)); }
166 const_iterator find(const_arg_type_t<ValueT> V) const {
187 std::pair<iterator, bool> insert(const ValueT &V) {
192 std::pair<iterator, bool> insert(ValueT &&V) {
200 std::pair<iterator, bool> insert_as(const ValueT &V,
205 std::pair<iterator, bool> insert_as(ValueT &&V, const LookupKeyT &LookupKey) {
250 ValueT, DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
250 ValueT, DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
251 detail::DenseSetPair<ValueT>>,
254 detail::DenseSetImpl<ValueT,
255 DenseMap<ValueT, detail::DenseSetEmpty, ValueInfoT,
256 detail::DenseSetPair<ValueT>>,
269 ValueT, SmallDenseMap<ValueT, detail::DenseSetEmpty, InlineBuckets,
269 ValueT, SmallDenseMap<ValueT, detail::DenseSetEmpty, InlineBuckets,
270 ValueInfoT, detail::DenseSetPair<ValueT>>,
273 ValueT, SmallDenseMap<ValueT, detail::DenseSetEmpty, InlineBuckets,
273 ValueT, SmallDenseMap<ValueT, detail::DenseSetEmpty, InlineBuckets,
274 ValueInfoT, detail::DenseSetPair<ValueT>>,
include/llvm/ADT/STLExtras.h 108 Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
112 static Ret callback_fn(intptr_t callable, Params ...params) {
114 std::forward<Params>(params)...);
129 Ret operator()(Params ...params) const {
130 return callback(callable, std::forward<Params>(params)...);
include/llvm/ADT/SetVector.h 42 using value_type = T;
43 using key_type = T;
44 using reference = T&;
45 using const_reference = const T&;
63 ArrayRef<T> getArrayRef() const { return vector_; }
122 const T &front() const {
128 const T &back() const {
227 LLVM_NODISCARD T pop_back_val() {
298 : public SetVector<T, SmallVector<T, N>, SmallDenseSet<T, N>> {
298 : public SetVector<T, SmallVector<T, N>, SmallDenseSet<T, N>> {
298 : public SetVector<T, SmallVector<T, N>, SmallDenseSet<T, N>> {
include/llvm/ADT/SmallVector.h 75 AlignedCharArrayUnion<T> FirstEl;
114 using value_type = T;
115 using iterator = T *;
116 using const_iterator = const T *;
121 using reference = T &;
122 using const_reference = const T &;
123 using pointer = T *;
124 using const_pointer = const T *;
259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
264 static void destroy_range(T *, T *) {}
264 static void destroy_range(T *, T *) {}
299 void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
302 void push_back(const T &Elt) {
305 memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
316 using SuperClass = SmallVectorTemplateBase<T>;
357 void resize(size_type N, const T &NV) {
374 LLVM_NODISCARD T pop_back_val() {
397 void append(size_type NumInputs, const T &Elt) {
405 void append(std::initializer_list<T> IL) {
412 void assign(size_type NumElts, const T &Elt) {
429 void assign(std::initializer_list<T> IL) {
467 iterator insert(iterator I, T &&Elt) {
497 iterator insert(iterator I, const T &Elt) {
526 iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
637 void insert(iterator I, std::initializer_list<T> IL) {
820 AlignedCharArrayUnion<T> InlineElts[N];
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
846 explicit SmallVector(size_t Size, const T &Value = T())
865 SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
884 SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
include/llvm/Analysis/CGSCCPassManager.h 594 if (auto CS = CallSite(&I)) {
637 auto CS = CallSite(CallH);
include/llvm/Analysis/MemoryBuiltins.h 262 SizeOffsetType visitCallSite(CallSite CS);
332 SizeOffsetEvalType visitCallSite(CallSite CS);
include/llvm/Analysis/ProfileSummaryInfo.h 139 bool isHotCallSite(const CallSite &CS, BlockFrequencyInfo *BFI);
141 bool isColdCallSite(const CallSite &CS, BlockFrequencyInfo *BFI);
include/llvm/Analysis/PtrUseVisitor.h 298 void visitCallSite(CallSite CS) {
include/llvm/Analysis/TypeMetadataUtils.h 36 CallSite CS;
include/llvm/IR/CallSite.h 684 bool operator==(const CallSite &CS) const { return I == CS.I; }
685 bool operator!=(const CallSite &CS) const { return I != CS.I; }
686 bool operator<(const CallSite &CS) const {
744 CallSite CS;
775 CallSite getCallSite() const { return CS; }
882 using BaseInfo = DenseMapInfo<decltype(CallSite::I)>;
884 static CallSite getEmptyKey() {
885 CallSite CS;
890 static CallSite getTombstoneKey() {
891 CallSite CS;
896 static unsigned getHashValue(const CallSite &CS) {
900 static bool isEqual(const CallSite &LHS, const CallSite &RHS) {
900 static bool isEqual(const CallSite &LHS, const CallSite &RHS) {
914 ImmutableCallSite(CallSite CS) : CallSiteBase(CS.getInstruction()) {}
include/llvm/IR/InstVisitor.h 286 RetTy visitCallSite(CallSite CS) {
include/llvm/Support/AlignOf.h 30 T t;
39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
50 llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/type_traits.h 65 using type = const T &;
91 T t;
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
145 std::is_copy_constructible<detail::trivial_helper<T>>::value;
147 !std::is_copy_constructible<T>::value;
151 std::is_move_constructible<detail::trivial_helper<T>>::value;
153 !std::is_move_constructible<T>::value;
157 is_copy_assignable<detail::trivial_helper<T>>::value;
159 !is_copy_assignable<T>::value;
163 is_move_assignable<detail::trivial_helper<T>>::value;
165 !is_move_assignable<T>::value;
169 std::is_destructible<detail::trivial_helper<T>>::value;
include/llvm/Transforms/IPO/Attributor.h 457 CallSite CS = CallSite(&getAnchorValue());
include/llvm/Transforms/IPO/Inliner.h 54 virtual InlineCost getInlineCost(CallSite CS) = 0;
include/llvm/Transforms/Scalar/MemCpyOptimizer.h 69 bool processByValArgument(CallSite CS, unsigned ArgNo);
include/llvm/Transforms/Utils/CallPromotionUtils.h 28 bool isLegalToPromote(CallSite CS, Function *Callee,
38 Instruction *promoteCall(CallSite CS, Function *Callee,
48 Instruction *promoteCallWithIfThenElse(CallSite CS, Function *Callee,
include/llvm/Transforms/Utils/Cloning.h 204 SmallVector<CallSite, 8> InlinedCallSites;
235 InlineResult InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
include/llvm/Transforms/Utils/Evaluator.h 77 Function *getCalleeWithFormalArgs(CallSite &CS,
82 bool getFormalParams(CallSite &CS, Function *F,
lib/Analysis/CGSCCPassManager.cpp 451 if (auto CS = CallSite(&I))
lib/Analysis/LazyCallGraph.cpp 102 if (auto CS = CallSite(&I))
lib/Analysis/Lint.cpp 95 void visitCallSite(CallSite CS);
224 void Lint::visitCallSite(CallSite CS) {
254 CallSite::arg_iterator AI = CS.arg_begin(), AE = CS.arg_end();
270 for (CallSite::arg_iterator BI = CS.arg_begin(); BI != AE;
lib/Analysis/LoopInfo.cpp 482 if (auto CS = CallSite(&I))
lib/Analysis/MemoryBuiltins.cpp 664 SizeOffsetType ObjectSizeOffsetVisitor::visitCallSite(CallSite CS) {
929 SizeOffsetEvalType ObjectSizeOffsetEvaluator::visitCallSite(CallSite CS) {
lib/Analysis/ProfileSummaryInfo.cpp 335 bool ProfileSummaryInfo::isHotCallSite(const CallSite &CS,
341 bool ProfileSummaryInfo::isColdCallSite(const CallSite &CS,
lib/CodeGen/IntrinsicLowering.cpp 214 CallSite CS(CI);
241 CallSite CS(CI);
lib/CodeGen/SafeStack.cpp 202 bool ShouldInlinePointerAddress(CallSite &CS);
708 bool SafeStack::ShouldInlinePointerAddress(CallSite &CS) {
725 CallSite CS(UnsafeStackPtr);
lib/CodeGen/WinEHPrepare.cpp 943 CallSite CS(&I);
lib/ExecutionEngine/Interpreter/Execution.cpp 1116 void Interpreter::visitCallSite(CallSite CS) {
1165 for (CallSite::arg_iterator i = SF.Caller.arg_begin(),
lib/ExecutionEngine/Interpreter/Interpreter.h 64 CallSite Caller; // Holds the call that called subframes.
153 void visitCallSite(CallSite CS);
lib/Target/AMDGPU/AMDGPUAnnotateKernelFeatures.cpp 277 CallSite CS(&I);
lib/Target/AMDGPU/AMDGPUFixFunctionBitcasts.cpp 34 void visitCallSite(CallSite CS) {
lib/Target/AMDGPU/AMDGPUInline.cpp 70 unsigned getInlineThreshold(CallSite CS) const;
72 InlineCost getInlineCost(CallSite CS) override;
109 unsigned AMDGPUInliner::getInlineThreshold(CallSite CS) const {
159 static bool isWrapperOnlyCall(CallSite CS) {
177 InlineCost AMDGPUInliner::getInlineCost(CallSite CS) {
lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp 223 CallSite CS(const_cast<Instruction *>(&I));
lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp 76 CallSite CS(U.getUser());
lib/Target/WebAssembly/WebAssemblyOptimizeReturned.cpp 45 void visitCallSite(CallSite CS);
58 void OptimizeReturned::visitCallSite(CallSite CS) {
lib/Target/X86/X86WinEHState.cpp 69 bool isStateStoreNeeded(EHPersonality Personality, CallSite CS);
70 void rewriteSetJmpCallSite(IRBuilder<> &Builder, Function &F, CallSite CS,
75 WinEHFuncInfo &FuncInfo, CallSite CS);
463 CallSite CS, Value *State) {
493 CallSite NewCS;
536 CallSite CS) {
625 CallSite CS) {
679 CallSite CS(&I);
746 CallSite CS(&I);
763 SmallVector<CallSite, 1> SetJmp3CallSites;
766 CallSite CS(&I);
777 for (CallSite CS : SetJmp3CallSites) {
lib/Transforms/Coroutines/CoroEarly.cpp 31 void lowerResumeOrDestroy(CallSite CS, CoroSubFnInst::ResumeKind);
50 void Lowerer::lowerResumeOrDestroy(CallSite CS,
159 if (auto CS = CallSite(&I)) {
lib/Transforms/Coroutines/CoroSplit.cpp 1082 CallSite CS{Prev};
lib/Transforms/IPO/AlwaysInliner.cpp 45 SmallSetVector<CallSite, 16> Calls;
54 if (auto CS = CallSite(U))
58 for (CallSite CS : Calls)
118 InlineCost getInlineCost(CallSite CS) override;
153 InlineCost AlwaysInlinerLegacyPass::getInlineCost(CallSite CS) {
lib/Transforms/IPO/ArgumentPromotion.cpp 107 Optional<function_ref<void(CallSite OldCS, CallSite NewCS)>>
107 Optional<function_ref<void(CallSite OldCS, CallSite NewCS)>>
243 CallSite CS(F->user_back());
251 CallSite::arg_iterator AI = CS.arg_begin();
327 CallSite NewCS;
494 CallSite CS(U);
851 CallSite CS(U.getUser());
868 Optional<function_ref<void(CallSite OldCS, CallSite NewCS)>>
868 Optional<function_ref<void(CallSite OldCS, CallSite NewCS)>>
907 CallSite CS(U.getUser());
944 CallSite CS(U.getUser());
lib/Transforms/IPO/Attributor.cpp 194 CallSite CS(V);
3083 CallSite CS(UInst);
3108 void addPotentialCopy(CallSite CS) {
4806 CallSite CS(&I);
lib/Transforms/IPO/CalledValuePropagation.cpp 256 void visitCallSite(CallSite CS,
390 CallSite CS(C);
lib/Transforms/IPO/DeadArgumentElimination.cpp 177 CallSite CS(*I++);
198 CallSite NewCS;
306 CallSite CS(U.getUser());
878 CallSite CS(F->user_back());
892 CallSite::arg_iterator I = CS.arg_begin();
917 for (CallSite::arg_iterator E = CS.arg_end(); I != E; ++I, ++i) {
936 CallSite NewCS;
lib/Transforms/IPO/FunctionAttrs.cpp 162 for (CallSite::arg_iterator CI = Call->arg_begin(), CE = Call->arg_end();
364 CallSite CS(U->getUser());
492 CallSite CS(I);
640 if (auto CS = CallSite(&I)) {
906 CallSite CS(RVI);
1015 CallSite CS(RVI);
1225 const CallSite CS(&I);
1249 CallSite CS(&I);
1370 if (auto CS = CallSite(&I)) {
1441 if (auto CS = CallSite(&I))
1577 CallSite CS(I);
lib/Transforms/IPO/GlobalOpt.cpp 696 CallSite CS(I);
2107 CallSite CS(cast<Instruction>(U));
2125 CallSite CS(cast<Instruction>(U));
2165 static bool isColdCallSite(CallSite CS, BlockFrequencyInfo &CallerBFI) {
2190 CallSite CS(cast<Instruction>(U));
2206 CallSite CS(cast<Instruction>(U));
2220 CallSite CS(cast<Instruction>(CI));
lib/Transforms/IPO/HotColdSplitting.cpp 111 if (auto CS = CallSite(&I))
321 CallSite CS(CI);
lib/Transforms/IPO/IPConstantPropagation.cpp 224 CallSite CS(U.getUser());
lib/Transforms/IPO/InlineSimple.cpp 54 InlineCost getInlineCost(CallSite CS) override {
lib/Transforms/IPO/Inliner.cpp 275 CallSite CS, InlineFunctionInfo &IFI,
307 shouldBeDeferred(Function *Caller, CallSite CS, InlineCost IC,
309 function_ref<InlineCost(CallSite CS)> GetInlineCost) {
348 CallSite CS2(U);
419 shouldInline(CallSite CS, function_ref<InlineCost(CallSite CS)> GetInlineCost,
419 shouldInline(CallSite CS, function_ref<InlineCost(CallSite CS)> GetInlineCost,
519 static void setInlineRemark(CallSite &CS, StringRef message) {
533 function_ref<InlineCost(CallSite CS)> GetInlineCost,
548 SmallVector<std::pair<CallSite, int>, 16> CallSites;
564 CallSite CS(cast<Value>(&I));
619 CallSite CS = CallSites[CSi].first;
915 SmallVector<std::pair<CallSite, int>, 16> Calls;
931 if (auto CS = CallSite(&I))
1027 CallSite CS;
1099 for (CallSite &CS : reverse(IFI.InlinedCallSites))
lib/Transforms/IPO/LowerTypeTests.cpp 1705 CallSite CS(Usr);
lib/Transforms/IPO/MergeFunctions.cpp 450 CallSite CS(U->getUser());
lib/Transforms/IPO/PartialInlining.cpp 286 bool shouldPartialInline(CallSite CS, FunctionCloner &Cloner,
305 static CallSite getCallSite(User *U) {
306 CallSite CS;
316 static CallSite getOneCallSiteTo(Function *F) {
322 CallSite CS = getOneCallSiteTo(F);
761 CallSite CS, FunctionCloner &Cloner,
948 CallSite CS = getCallSite(User);
1157 CallSite OCS = PartialInlinerImpl::getOneCallSiteTo(OutlinedFunc);
1393 CallSite CS = getCallSite(User);
lib/Transforms/IPO/SampleProfile.cpp 855 CallSite CS(I);
1427 CallSite CS(&I);
lib/Transforms/IPO/SyntheticCountsPropagation.cpp 114 CallSite CS(cast<Instruction>(Edge.first));
lib/Transforms/IPO/WholeProgramDevirt.cpp 310 CallSite CS;
415 void addCallSite(Value *VTable, CallSite CS, unsigned *NumUnsafeUses);
418 CallSiteInfo &findCallSiteInfo(CallSite CS);
421 CallSiteInfo &VTableSlotInfo::findCallSiteInfo(CallSite CS) {
435 void VTableSlotInfo::addCallSite(Value *VTable, CallSite CS,
1094 CallSite CS = VCallSite.CS;
1123 CallSite NewCS;
1558 DenseSet<CallSite> SeenCallSites;
lib/Transforms/Instrumentation/AddressSanitizer.cpp 1078 void visitCallSite(CallSite CS) {
2684 CallSite CS(&Inst);
lib/Transforms/Instrumentation/CGProfile.cpp 52 CallSite CS(&I);
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 448 void visitCallSite(CallSite CS);
1535 void DFSanVisitor::visitCallSite(CallSite CS) {
1591 CallSite::arg_iterator i = CS.arg_begin();
1713 CallSite::arg_iterator i = CS.arg_begin(), e = CS.arg_end();
1736 CallSite NewCS;
lib/Transforms/Instrumentation/MemorySanitizer.cpp 984 virtual void visitCallSite(CallSite &CS, IRBuilder<> &IRB) = 0;
3253 void visitCallSite(CallSite CS) {
3294 for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end();
3788 void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
3793 for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end();
4017 void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
4020 for (CallSite::arg_iterator ArgIt = CS.arg_begin() +
4166 void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
4172 for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end();
4393 void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
4412 for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end();
4563 void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {}
lib/Transforms/Instrumentation/SanitizerCoverage.cpp 609 CallSite CS(&Inst);
732 CallSite CS(I);
lib/Transforms/Scalar/CallSiteSplitting.cpp 86 static void addNonNullAttribute(CallSite CS, Value *Op) {
95 static void setConstantInArgument(CallSite CS, Value *Op,
109 static bool isCondRelevantToAnyCallArgument(ICmpInst *Cmp, CallSite CS) {
113 for (CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); I != E;
130 static void recordCondition(CallSite CS, BasicBlock *From, BasicBlock *To,
153 static void recordConditions(CallSite CS, BasicBlock *Pred,
166 static void addConditions(CallSite CS, const ConditionsTy &Conditions) {
185 static bool canSplitCallSite(CallSite CS, TargetTransformInfo &TTI) {
305 CallSite CS,
337 CallSite NewCS(NewCI);
419 static bool isPredicatedOnPHI(CallSite CS) {
492 static bool tryToSplitCallSite(CallSite CS, TargetTransformInfo &TTI,
523 CallSite CS(cast<Value>(I));
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp 537 static bool processCallSite(CallSite CS, LazyValueInfo *LVI) {
lib/Transforms/Scalar/DeadStoreElimination.cpp 170 if (auto CS = CallSite(I)) {
212 if (auto CS = CallSite(Inst))
262 if (auto CS = CallSite(I))
lib/Transforms/Scalar/LoopUnswitch.cpp 684 auto CS = CallSite(&I);
lib/Transforms/Scalar/MemCpyOptimizer.cpp 746 CallSite CS(C);
1258 bool MemCpyOptPass::processByValArgument(CallSite CS, unsigned ArgNo) {
1361 else if (auto CS = CallSite(I)) {
lib/Transforms/Scalar/SCCP.cpp 649 void visitCallSite (CallSite CS);
1198 void SCCPSolver::visitCallSite(CallSite CS) {
1274 for (CallSite::arg_iterator AI = CS.arg_begin(), E = CS.arg_end();
1313 CallSite::arg_iterator CAI = CS.arg_begin();
1448 if (CallSite CS = CallSite(&I))
1477 if (CallSite CS = CallSite(&I)) {
1781 CallSite CS(CI);
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp 2642 if (auto CS = CallSite(&I))
lib/Transforms/Scalar/TailRecursionElimination.cpp 128 CallSite CS(I);
170 void callUsesLocalStack(CallSite CS, bool IsNocapture) {
486 CallSite::arg_iterator I = CallSite(CI).arg_begin(),
lib/Transforms/Utils/CallPromotionUtils.cpp 161 static void createRetBitCast(CallSite CS, Type *RetTy, CastInst **RetBitCast) {
256 static Instruction *versionCallSite(CallSite CS, Value *Callee,
319 bool llvm::isLegalToPromote(CallSite CS, Function *Callee,
365 Instruction *llvm::promoteCall(CallSite CS, Function *Callee,
449 Instruction *llvm::promoteCallWithIfThenElse(CallSite CS, Function *Callee,
lib/Transforms/Utils/CloneFunction.cpp 622 CallSite CS = CallSite(I);
lib/Transforms/Utils/Evaluator.cpp 269 Evaluator::getCalleeWithFormalArgs(CallSite &CS,
284 bool Evaluator::getFormalParams(CallSite &CS, Function *F,
479 CallSite CS(&*CurInst);
lib/Transforms/Utils/FunctionComparator.cpp 572 if (auto CSL = CallSite(const_cast<Instruction *>(L))) {
573 auto CSR = CallSite(const_cast<Instruction *>(R));
lib/Transforms/Utils/InlineFunction.cpp 770 static void PropagateParallelLoopAccessMetadata(CallSite CS,
813 static void CloneAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap) {
919 static void AddAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap,
1141 static void AddAlignmentAssumptions(CallSite CS, InlineFunctionInfo &IFI) {
1179 static void UpdateCallGraphAfterInlining(CallSite CS,
1537 llvm::InlineResult llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
1684 CallSite::arg_iterator AI = CS.arg_begin();
1743 CallSite ICS(I);
2058 CallSite CS(I);
2217 if (auto CS = CallSite(&I))
lib/Transforms/Utils/SimplifyCFG.cpp 6008 if (auto CS = CallSite(Use))
lib/Transforms/Utils/ValueMapper.cpp 891 if (auto CS = CallSite(I)) {
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp 161 llvm::CallSite call_site(call_inst);
tools/llvm-diff/DifferenceEngine.cpp 225 bool diffCallSites(CallSite L, CallSite R, bool Complain) {
225 bool diffCallSites(CallSite L, CallSite R, bool Complain) {
tools/opt/AnalysisWrappers.cpp 43 CallSite CS(cast<Value>(UI));
46 for (CallSite::arg_iterator AI = CS.arg_begin(),
unittests/Analysis/ProfileSummaryInfoTest.cpp 123 CallSite CS1(BB1->getFirstNonPHI());
190 CallSite CS1(BB1->getFirstNonPHI());
192 CallSite CS2(CI2);
237 CallSite CS1(BB1->getFirstNonPHI());
244 CallSite CS2(CI2);
unittests/Analysis/SparsePropagation.cpp 161 void visitCallSite(CallSite CS,
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
73 forward(typename std::remove_reference<_Tp>::type& __t) noexcept
83 constexpr _Tp&&
84 forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
98 move(_Tp&& __t) noexcept
198 _Tp __tmp = _GLIBCXX_MOVE(__a);
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 123 typedef _Tp value_type;
181 typedef _Tp value_type;
183 typedef _Tp* pointer;
184 typedef _Tp& reference;
usr/include/c++/7.4.0/bits/stl_pair.h 100 return __and_<is_constructible<_T1, const _U1&>,
100 return __and_<is_constructible<_T1, const _U1&>,
107 return __and_<is_convertible<const _U1&, _T1>,
107 return __and_<is_convertible<const _U1&, _T1>,
114 return __and_<is_constructible<_T1, _U1&&>,
114 return __and_<is_constructible<_T1, _U1&&>,
121 return __and_<is_convertible<_U1&&, _T1>,
121 return __and_<is_convertible<_U1&&, _T1>,
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
133 return __and_<is_constructible<_T1, const _U1&>,
133 return __and_<is_constructible<_T1, const _U1&>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
147 return __and_<is_constructible<_T1, _U1&&>,
147 return __and_<is_constructible<_T1, _U1&&>,
209 : private __pair_base<_T1, _T2>
211 typedef _T1 first_type; /// @c first_type is the first bound type
214 _T1 first; /// @c first is a copy of the first object
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
311 constexpr pair(_U1&& __x, const _T2& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
332 explicit pair(const _T1& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
379 __and_<is_copy_assignable<_T1>,
390 __and_<is_move_assignable<_T1>,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
405 operator=(const pair<_U1, _U2>& __p)
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
416 operator=(pair<_U1, _U2>&& __p)
495 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
495 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
522 constexpr pair<typename __decay_and_strip<_T1>::__type,
524 make_pair(_T1&& __x, _T2&& __y)
526 typedef typename __decay_and_strip<_T1>::__type __ds_type1;
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
usr/include/c++/7.4.0/tuple 125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
159 static constexpr _Head&
162 static constexpr const _Head&
194 static constexpr _Head&
197 static constexpr const _Head&
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
248 const _Head& __head, const _Tail&... __tail)
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
947 constexpr tuple(const _T1& __a1, const _T2& __a2)
956 explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
971 constexpr tuple(_U1&& __a1, _U2&& __a2)
1078 const _T1& __a1, const _T2& __a2)
1090 const _T1& __a1, const _T2& __a2)
1241 operator=(const pair<_U1, _U2>& __in)
1250 operator=(pair<_U1, _U2>&& __in)
1588 constexpr tuple<_Elements&...>
1589 tie(_Elements&... __args) noexcept
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
762 typename add_rvalue_reference<_Tp>::type declval() noexcept;
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
889 typedef decltype(__test<_Tp>(0)) type;
894 : public __and_<__not_<is_void<_Tp>>,
895 __is_default_constructible_impl<_Tp>>
915 : public __is_default_constructible_atom<_Tp>::type
921 : public __is_default_constructible_safe<_Tp>::type
984 typedef decltype(__test<_Tp, _Arg>(0)) type;
989 : public __and_<is_destructible<_Tp>,
990 __is_direct_constructible_impl<_Tp, _Arg>>
1072 __is_direct_constructible_ref_cast<_Tp, _Arg>,
1073 __is_direct_constructible_new_safe<_Tp, _Arg>
1079 : public __is_direct_constructible_new<_Tp, _Arg>::type
1119 : public __is_direct_constructible<_Tp, _Arg>
1130 : public __is_constructible_impl<_Tp, _Args...>::type
1142 : public is_constructible<_Tp, const _Tp&>
1142 : public is_constructible<_Tp, const _Tp&>
1148 : public __is_copy_constructible_impl<_Tp>
1160 : public is_constructible<_Tp, _Tp&&>
1160 : public is_constructible<_Tp, _Tp&&>
1166 : public __is_move_constructible_impl<_Tp>
1215 : public __and_<is_constructible<_Tp, _Args...>,
1216 __is_nt_constructible_impl<_Tp, _Args...>>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1252 : public __is_nothrow_move_constructible_impl<_Tp>
1286 : public is_assignable<_Tp&, const _Tp&>
1286 : public is_assignable<_Tp&, const _Tp&>
1292 : public __is_copy_assignable_impl<_Tp>
1304 : public is_assignable<_Tp&, _Tp&&>
1304 : public is_assignable<_Tp&, _Tp&&>
1310 : public __is_move_assignable_impl<_Tp>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1358 : public __is_nt_move_assignable_impl<_Tp>
1377 static void __helper(const _Tp&);
1380 static true_type __test(const _Tp&,
1381 decltype(__helper<const _Tp&>({}))* = 0);
1390 typedef decltype(__test(declval<_Tp>())) type;
1395 : public __is_implicitly_default_constructible_impl<_Tp>::type
1400 : public __and_<is_default_constructible<_Tp>,
1401 __is_implicitly_default_constructible_safe<_Tp>>
1526 static void __test_aux(_To1);
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1629 { typedef _Tp type; };
1633 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1664 : public __add_rvalue_reference_helper<_Tp>
1955 { typedef _Tp type; };
2104 { typedef typename remove_cv<_Up>::type __type; };
2118 typedef typename remove_reference<_Tp>::type __remove_type;
2131 typedef _Tp __type;
2144 typename decay<_Tp>::type>::__type __type;
2574 typename remove_reference<_Tp>::type>::type>::type
2579 typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
2580 is_move_constructible<_Tp>,
2581 is_move_assignable<_Tp>>::value>::type
2582 swap(_Tp&, _Tp&)
2582 swap(_Tp&, _Tp&)
2609 noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2609 noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2629 typedef decltype(__test<_Tp>(0)) type;
2639 : public __is_nothrow_swappable_impl<_Tp>::type