reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/Analysis/CallGraph.h
   64 class CallGraphNode;
include/llvm/Analysis/CallGraphSCCPass.h
   30 class CallGraphNode;

References

include/llvm/ADT/ArrayRef.h
  108         const ArrayRef<U *> &A,
  110            std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  118       const SmallVectorTemplateCommon<U *, DummyT> &Vec,
  120           std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  127     ArrayRef(const std::vector<U *, A> &Vec,
  129                  std::is_convertible<U *const *, T const *>::value>::type* = 0)
include/llvm/ADT/DenseMapInfo.h
   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/Analysis/CallGraph.h
   77       std::map<const Function *, std::unique_ptr<CallGraphNode>>;
   84   CallGraphNode *ExternalCallingNode;
   88   std::unique_ptr<CallGraphNode> CallsExternalNode;
  121   inline const CallGraphNode *operator[](const Function *F) const {
  128   inline CallGraphNode *operator[](const Function *F) {
  136   CallGraphNode *getExternalCallingNode() const { return ExternalCallingNode; }
  138   CallGraphNode *getCallsExternalNode() const {
  153   Function *removeFunctionFromModule(CallGraphNode *CGN);
  157   CallGraphNode *getOrInsertFunction(const Function *F);
  168   using CallRecord = std::pair<WeakTrackingVH, CallGraphNode *>;
  176   CallGraphNode(const CallGraphNode &) = delete;
  177   CallGraphNode &operator=(const CallGraphNode &) = delete;
  177   CallGraphNode &operator=(const CallGraphNode &) = delete;
  201   CallGraphNode *operator[](unsigned i) const {
  225   void stealCalledFunctionsFrom(CallGraphNode *N) {
  232   void addCalledFunction(CallBase *Call, CallGraphNode *M) {
  256   void removeAnyCallEdgeTo(CallGraphNode *Callee);
  260   void removeOneAbstractEdgeTo(CallGraphNode *Callee);
  267                        CallGraphNode *NewNode);
  350   inline const CallGraphNode *operator[](const Function *F) const {
  355   inline CallGraphNode *operator[](const Function *F) { return (*G)[F]; }
  359   CallGraphNode *getExternalCallingNode() const {
  363   CallGraphNode *getCallsExternalNode() const {
  378   Function *removeFunctionFromModule(CallGraphNode *CGN) {
  384   CallGraphNode *getOrInsertFunction(const Function *F) {
  408   using NodeRef = CallGraphNode *;
  409   using CGNPairTy = CallGraphNode::CallRecord;
  411   static NodeRef getEntryNode(CallGraphNode *CGN) { return CGN; }
  412   static CallGraphNode *CGNGetValue(CGNPairTy P) { return P.second; }
  415       mapped_iterator<CallGraphNode::iterator, decltype(&CGNGetValue)>;
  427   using NodeRef = const CallGraphNode *;
  428   using CGNPairTy = CallGraphNode::CallRecord;
  429   using EdgeRef = const CallGraphNode::CallRecord &;
  431   static NodeRef getEntryNode(const CallGraphNode *CGN) { return CGN; }
  432   static const CallGraphNode *CGNGetValue(CGNPairTy P) { return P.second; }
  435       mapped_iterator<CallGraphNode::const_iterator, decltype(&CGNGetValue)>;
  436   using ChildEdgeIteratorType = CallGraphNode::const_iterator;
  455 struct GraphTraits<CallGraph *> : public GraphTraits<CallGraphNode *> {
  457       std::pair<const Function *const, std::unique_ptr<CallGraphNode>>;
  463   static CallGraphNode *CGGetValuePtr(const PairTy &P) {
  482                                             const CallGraphNode *> {
  484       std::pair<const Function *const, std::unique_ptr<CallGraphNode>>;
  490   static const CallGraphNode *CGGetValuePtr(const PairTy &P) {
include/llvm/Analysis/CallGraphSCCPass.h
   90   std::vector<CallGraphNode *> Nodes;
   95   void initialize(ArrayRef<CallGraphNode *> NewNodes) {
  104   void ReplaceNode(CallGraphNode *Old, CallGraphNode *New);
  104   void ReplaceNode(CallGraphNode *Old, CallGraphNode *New);
  106   using iterator = std::vector<CallGraphNode *>::const_iterator;
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) {
include/llvm/Transforms/IPO/Attributor.h
  608       for (CallGraphNode *Node : *I)
lib/Analysis/CallGraph.cpp
   32       CallsExternalNode(std::make_unique<CallGraphNode>(nullptr)) {
   60   CallGraphNode *Node = getOrInsertFunction(F);
   92   SmallVector<CallGraphNode *, 16> Nodes;
  106   for (CallGraphNode *CN : Nodes)
  120 Function *CallGraph::removeFunctionFromModule(CallGraphNode *CGN) {
  147 CallGraphNode *CallGraph::getOrInsertFunction(const Function *F) {
  153   CGN = std::make_unique<CallGraphNode>(const_cast<Function *>(F));
  201 void CallGraphNode::removeAnyCallEdgeTo(CallGraphNode *Callee) {
  213 void CallGraphNode::removeOneAbstractEdgeTo(CallGraphNode *Callee) {
  230                                     CallGraphNode *NewNode) {
lib/Analysis/CallGraphSCCPass.cpp
  171   for (CallGraphNode *CGN : CurSCC) {
  203   DenseMap<Value *, CallGraphNode *> Calls;
  217     CallGraphNode *CGN = *SCCIdx;
  229     for (CallGraphNode::iterator I = CGN->begin(), E = CGN->end(); I != E; ) {
  297         DenseMap<Value *, CallGraphNode *>::iterator ExistingIt =
  300           CallGraphNode *ExistingNode = ExistingIt->second;
  323           CallGraphNode *CalleeNode;
  347         CallGraphNode *CalleeNode;
  474     const std::vector<CallGraphNode *> &NodeVec = *CGI;
  547 void CallGraphSCC::ReplaceNode(CallGraphNode *Old, CallGraphNode *New) {
  547 void CallGraphSCC::ReplaceNode(CallGraphNode *Old, CallGraphNode *New) {
  650       for (CallGraphNode *CGN : SCC) {
  687   for (CallGraphNode *CGN : SCC) {
lib/Analysis/CallPrinter.cpp
   29   std::string getNodeLabel(CallGraphNode *Node, CallGraph *Graph) {
lib/Analysis/GlobalsModRef.cpp
  472     const std::vector<CallGraphNode *> &SCC = *I;
  475     for (auto *CGN : SCC)
  490     const std::vector<CallGraphNode *> &SCC = *I;
  499       for (auto *Node : SCC)
  536       for (CallGraphNode::iterator CI = SCC[i]->begin(), E = SCC[i]->end();
  545             CallGraphNode *CalleeNode = CG[Callee];
  557       for (auto *Node : SCC)
  563     for (auto *Node : SCC) {
lib/Target/AMDGPU/AMDGPUAnnotateKernelFeatures.cpp
   48   SmallVector<CallGraphNode*, 8> NodeList;
  217   for (auto *Node : reverse(NodeList)) {
  346   for (CallGraphNode *I : SCC) {
lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp
  375   for (CallGraphNode *I : SCC) {
lib/Transforms/Coroutines/CoroSplit.cpp
 1428   auto *Node = CG.getOrInsertFunction(DevirtFn);
 1430   SmallVector<CallGraphNode *, 8> Nodes(SCC.begin(), SCC.end());
 1441   CallGraphNode *PrepareUserNode = nullptr, *FnNode = nullptr;
 1545     for (CallGraphNode *CGN : SCC)
lib/Transforms/Coroutines/Coroutines.cpp
  188 static void buildCGN(CallGraph &CG, CallGraphNode *Node) {
  210   auto *ParentNode = CG[&ParentFunc];
  214   SmallVector<CallGraphNode *, 8> Nodes(SCC.begin(), SCC.end());
  217     CallGraphNode *Callee = CG.getOrInsertFunction(F);
lib/Transforms/IPO/ArgumentPromotion.cpp
 1132     for (CallGraphNode *OldNode : SCC) {
 1139         CallGraphNode *NewCalleeNode =
 1141         CallGraphNode *CallerNode = CG[Caller];
 1154         CallGraphNode *NewNode = CG.getOrInsertFunction(NewF);
lib/Transforms/IPO/FunctionAttrs.cpp
 1500   for (CallGraphNode *I : SCC) {
lib/Transforms/IPO/Inliner.cpp
  538   for (CallGraphNode *Node : SCC) {
  556   for (CallGraphNode *Node : SCC) {
  728         CallGraphNode *CalleeNode = CG[Callee];
  786   SmallVector<CallGraphNode *, 16> FunctionsToRemove;
  805     CallGraphNode *CGN = I.second.get();
  858   for (CallGraphNode *CGN : FunctionsToRemove) {
lib/Transforms/IPO/Internalize.cpp
  151   CallGraphNode *ExternalNode = CG ? CG->getExternalCallingNode() : nullptr;
lib/Transforms/IPO/PruneEH.cpp
   63   SmallPtrSet<CallGraphNode *, 8> SCCNodes;
   68   for (CallGraphNode *I : SCC)
   73   for (CallGraphNode *I : SCC)
  127                 CallGraphNode *CalleeNode = CG[Callee];
  151     for (CallGraphNode *I : SCC) {
  165   for (CallGraphNode *I : SCC) {
  236   CallGraphNode *CGN = CG[BB->getParent()];
lib/Transforms/Utils/InlineFunction.cpp
 1186   CallGraphNode *CalleeNode = CG[Callee];
 1187   CallGraphNode *CallerNode = CG[Caller];
 1191   CallGraphNode::iterator I = CalleeNode->begin(), E = CalleeNode->end();
 1194   CallGraphNode::CalledFunctionsVector CallCache;
tools/opt/PrintSCC.cpp
   98     const std::vector<CallGraphNode*> &nextSCC = *SCCI;
  100     for (std::vector<CallGraphNode*>::const_iterator I = nextSCC.begin(),
usr/include/c++/7.4.0/bits/unique_ptr.h
   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;
  252 	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
  297           __safe_conversion_up<_Up, _Ep>,
  301 	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
  811     { typedef unique_ptr<_Tp> __single_object; };
  823     inline typename _MakeUniq<_Tp>::__single_object
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/type_traits
  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_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
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>
 1983     { typedef _Up     type; };