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

Derived Classes

tools/clang/include/clang/Analysis/ProgramPoint.h

  225 class BlockEntrance : public ProgramPoint {
  250 class BlockExit : public ProgramPoint {
  271 class StmtPoint : public ProgramPoint {
  335 class FunctionExitPoint : public ProgramPoint {
  503 class BlockEdge : public ProgramPoint {
  527 class PostInitializer : public ProgramPoint {
  559 class ImplicitCallPoint : public ProgramPoint {
  630 class CallEnter : public ProgramPoint {
  668 class CallExitBegin : public ProgramPoint {
  688 class CallExitEnd : public ProgramPoint {
  713 class LoopExit : public ProgramPoint {
  732 class EpsilonPoint : public ProgramPoint {

Declarations

tools/clang/include/clang/Analysis/PathDiagnostic.h

   50 class ProgramPoint;

tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

   52 class ProgramPoint;

References

include/llvm/ADT/FoldingSet.h

  221   static void Profile(const T &X, FoldingSetNodeID &ID) {
  224   static void Profile(T &X, FoldingSetNodeID &ID) {
  232   static inline bool Equals(T &X, const FoldingSetNodeID &ID, unsigned IDHash,
  240   static inline unsigned ComputeHash(T &X, FoldingSetNodeID &TempID);
  250   : public DefaultFoldingSetTrait<T> {};
  329   inline void Add(const T &x) { FoldingSetTrait<T>::Profile(x, *this); }
  329   inline void Add(const T &x) { FoldingSetTrait<T>::Profile(x, *this); }

tools/clang/include/clang/Analysis/PathDiagnostic.h

  275   static PathDiagnosticLocation create(const ProgramPoint &P,

tools/clang/include/clang/Analysis/ProgramPoint.h

  132   ProgramPoint withTag(const ProgramPointTag *tag) const {
  143     ProgramPoint& PP = t;
  155     ProgramPoint& PP = t;
  194   bool operator==(const ProgramPoint & RHS) const {
  201   bool operator!=(const ProgramPoint &RHS) const {
  220   static ProgramPoint getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
  220   static ProgramPoint getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
  225 class BlockEntrance : public ProgramPoint {
  245   static bool isKind(const ProgramPoint &Location) {
  250 class BlockExit : public ProgramPoint {
  266   static bool isKind(const ProgramPoint &Location) {
  271 class StmtPoint : public ProgramPoint {
  288   static bool isKind(const ProgramPoint &Location) {
  306   static bool isKind(const ProgramPoint &Location) {
  329   static bool isKind(const ProgramPoint &Location) {
  335 class FunctionExitPoint : public ProgramPoint {
  353   static bool isKind(const ProgramPoint &Location) {
  368   static bool isKind(const ProgramPoint &Location) {
  377                 ProgramPoint::Kind K, const ProgramPointTag *tag)
  382   static bool isKind(const ProgramPoint &location) {
  397   static bool isKind(const ProgramPoint &location) {
  411   static bool isKind(const ProgramPoint &location) {
  425   static bool isKind(const ProgramPoint &Location) {
  452   static bool isKind(const ProgramPoint &Location) {
  466   static bool isKind(const ProgramPoint &Location) {
  482   static bool isKind(const ProgramPoint &Location) {
  498   static bool isKind(const ProgramPoint &Location) {
  503 class BlockEdge : public ProgramPoint {
  522   static bool isKind(const ProgramPoint &Location) {
  527 class PostInitializer : public ProgramPoint {
  551   static bool isKind(const ProgramPoint &Location) {
  559 class ImplicitCallPoint : public ProgramPoint {
  574   static bool isKind(const ProgramPoint &Location) {
  592   static bool isKind(const ProgramPoint &Location) {
  609   static bool isKind(const ProgramPoint &Location) {
  623   static bool isKind(const ProgramPoint &Location) {
  630 class CallEnter : public ProgramPoint {
  654   static bool isKind(const ProgramPoint &Location) {
  668 class CallExitBegin : public ProgramPoint {
  681   static bool isKind(const ProgramPoint &Location) {
  688 class CallExitEnd : public ProgramPoint {
  702   static bool isKind(const ProgramPoint &Location) {
  713 class LoopExit : public ProgramPoint {
  725     static bool isKind(const ProgramPoint &Location) {
  732 class EpsilonPoint : public ProgramPoint {
  744   static bool isKind(const ProgramPoint &Location) {
  756 static inline clang::ProgramPoint getEmptyKey() {
  762 static inline clang::ProgramPoint getTombstoneKey() {
  768 static unsigned getHashValue(const clang::ProgramPoint &Loc) {
  772 static bool isEqual(const clang::ProgramPoint &L,
  773                     const clang::ProgramPoint &R) {

tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h

  300                           const ProgramPoint &PP);
  348                                  ProgramPoint::Kind K);

tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

  340   ProgramPoint getProgramPoint(bool IsPreVisit = false,

tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h

   32   const ProgramPoint Location;
   43                  const ProgramPoint &loc,
  137     ProgramPoint L = N->getLocation();
  344     const ProgramPoint &LocalLoc = (Tag ? Location.withTag(Tag) : Location);

tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h

  103   void generateNode(const ProgramPoint &Loc,
  155   void dispatchWorkItem(ExplodedNode* Pred, ProgramPoint Loc,
  267   ExplodedNode *generateNodeImpl(const ProgramPoint &PP,
  289   ExplodedNode *generateNode(const ProgramPoint &PP,
  300   ExplodedNode *generateSink(const ProgramPoint &PP,
  346   ProgramPoint &Location;
  350                        const NodeBuilderContext &Ctx, ProgramPoint &L)
  356     const ProgramPoint &LocalLoc = (Tag ? Location.withTag(Tag) : Location);
  362     const ProgramPoint &LocalLoc = (Tag ? Location.withTag(Tag) : Location);
  411                              ProgramPoint::Kind K = ProgramPoint::PostStmtKind){
  411                              ProgramPoint::Kind K = ProgramPoint::PostStmtKind){
  412     const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
  412     const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
  421                              ProgramPoint::Kind K = ProgramPoint::PostStmtKind){
  421                              ProgramPoint::Kind K = ProgramPoint::PostStmtKind){
  422     const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
  422     const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,

tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h

  123   const ProgramPoint Location;
  137   explicit ExplodedNode(const ProgramPoint &loc, ProgramStateRef state,
  144   ProgramPoint getLocation() const { return Location; }
  182                       const ProgramPoint &Loc,
  353   ExplodedNode *getNode(const ProgramPoint &L, ProgramStateRef State,
  361   ExplodedNode *createUncachedNode(const ProgramPoint &L,

tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h

  268             ProgramPoint::Kind K = ProgramPoint::PreStmtPurgeDeadSymbolsKind);
  268             ProgramPoint::Kind K = ProgramPoint::PreStmtPurgeDeadSymbolsKind);
  613                 const ProgramPoint *PP = nullptr);

tools/clang/lib/Analysis/PathDiagnostic.cpp

  649 PathDiagnosticLocation::create(const ProgramPoint& P,

tools/clang/lib/Analysis/ProgramPoint.cpp

   21 ProgramPoint ProgramPoint::getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
   21 ProgramPoint ProgramPoint::getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
   27     case ProgramPoint::PreStmtKind:
   29     case ProgramPoint::PostStmtKind:
   31     case ProgramPoint::PreLoadKind:
   33     case ProgramPoint::PostLoadKind:
   35     case ProgramPoint::PreStoreKind:
   37     case ProgramPoint::PostLValueKind:
   39     case ProgramPoint::PostStmtPurgeDeadSymbolsKind:
   41     case ProgramPoint::PreStmtPurgeDeadSymbolsKind:
   59   case ProgramPoint::BlockEntranceKind:
   65   case ProgramPoint::FunctionExitKind: {
   79   case ProgramPoint::BlockExitKind:
   82   case ProgramPoint::CallEnterKind:
   85   case ProgramPoint::CallExitBeginKind:
   88   case ProgramPoint::CallExitEndKind:
   91   case ProgramPoint::EpsilonKind:
   95   case ProgramPoint::LoopExitKind:
  100   case ProgramPoint::PreImplicitCallKind: {
  109   case ProgramPoint::PostImplicitCallKind: {
  118   case ProgramPoint::PostInitializerKind: {
  133   case ProgramPoint::BlockEdgeKind: {

tools/clang/lib/StaticAnalyzer/Checkers/AnalyzerStatsChecker.cpp

   56     const ProgramPoint &P = I->getLocation();

tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp

  961   ProgramPoint P = N->getLocation();

tools/clang/lib/StaticAnalyzer/Checkers/MPI-Checker/MPIBugReporter.cpp

  105     ProgramPoint P = N->getFirstPred()->getLocation();

tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp

 3240           if (N->getLocation().getKind() == ProgramPoint::PostImplicitCallKind) {

tools/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp

  265     ProgramPoint P = Succ->getLocation();

tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp

  696     const ProgramPoint AllocPP = AllocationNode->getLocation();

tools/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp

  120     ProgramPoint P = Succ->getLocation();

tools/clang/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp

   88       ProgramPoint P = PrevN->getLocation();

tools/clang/lib/StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp

   63     const ProgramPoint &P = I->getLocation();

tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp

  284   ProgramPoint P = N->getLocation();
 1121   ProgramPoint P = C.getCurrentNode()->getLocation();
 2313   ProgramPoint ProgP = ErrorNode->getLocation();
 2341     ProgramPoint P = ErrorNode->getLocation();

tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

 1508   ProgramPoint P = StoreSite->getLocation();
 1584     ProgramPoint P = N->getLocation();
 1664     ProgramPoint CurPoint = Succ->getLocation();
 1880       ProgramPoint ProgPoint = NI->getLocation();
 2155   ProgramPoint ProgPoint = N->getLocation();
 2766   ProgramPoint ProgLoc = N->getLocation();
 2894   ProgramPoint PP = N->getLocation();

tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp

  340 ProgramPoint CallEvent::getProgramPoint(bool IsPreVisit,

tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp

  172       ProgramPoint::Kind K =  IsPreVisit ? ProgramPoint::PreStmtKind :
  172       ProgramPoint::Kind K =  IsPreVisit ? ProgramPoint::PreStmtKind :
  173                                            ProgramPoint::PostStmtKind;
  174       const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
  174       const ProgramPoint &L = ProgramPoint::getProgramPoint(S, K,
  230       const ProgramPoint &L = Msg.getProgramPoint(IsPreVisit,checkFn.Checker);
  288       const ProgramPoint &L = Call.getProgramPoint(IsPreVisit,checkFn.Checker);
  335       ProgramPoint::Kind K =  IsLoad ? ProgramPoint::PreLoadKind :
  335       ProgramPoint::Kind K =  IsLoad ? ProgramPoint::PreLoadKind :
  336                                        ProgramPoint::PreStoreKind;
  337       const ProgramPoint &L =
  338         ProgramPoint::getProgramPoint(NodeEx, K,
  371     const ProgramPoint &PP;
  375                      const ProgramPoint &pp)
  383       const ProgramPoint &L = PP.withTag(checkFn.Checker);
  397                                         const ProgramPoint &PP) {
  416   const ProgramPoint &PP;
  419                             const ProgramPoint &PP)
  427     const ProgramPoint &L = PP.withTag(checkFn.Checker);
  459     const ProgramPoint &L =
  484       ProgramPoint L = PostCondition(Condition, Pred->getLocationContext(),
  525       ProgramPoint L = PostAllocatorCall(NE, Pred->getLocationContext());
  558     ProgramPoint::Kind ProgarmPointKind;
  562                             ProgramPoint::Kind K)
  570       const ProgramPoint &L = ProgramPoint::getProgramPoint(S, ProgarmPointKind,
  570       const ProgramPoint &L = ProgramPoint::getProgramPoint(S, ProgarmPointKind,
  589                                                ProgramPoint::Kind K) {
  664       ProgramPoint L = ProgramPoint::getProgramPoint(
  664       ProgramPoint L = ProgramPoint::getProgramPoint(
  666           ProgramPoint::PostStmtKind,

tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp

  154 void CoreEngine::dispatchWorkItem(ExplodedNode* Pred, ProgramPoint Loc,
  158     case ProgramPoint::BlockEdgeKind:
  162     case ProgramPoint::BlockEntranceKind:
  166     case ProgramPoint::BlockExitKind:
  170     case ProgramPoint::CallEnterKind:
  174     case ProgramPoint::CallExitBeginKind:
  178     case ProgramPoint::EpsilonKind: {
  223     ProgramPoint P = L.withTag(getNoteTags().makeNoteTag(
  496 void CoreEngine::generateNode(const ProgramPoint &Loc,
  605 ExplodedNode* NodeBuilder::generateNodeImpl(const ProgramPoint &Loc,
  641   ProgramPoint Loc = BlockEdge(C.Block, branch ? DstT:DstF,

tools/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp

  103   ProgramPoint progPoint = node->getLocation();
  143   const ProgramPoint SuccLoc = succ->getLocation();
  293   ProgramPoint P = getLocation();
  334   ProgramPoint P = getLocation();
  395 ExplodedNode *ExplodedGraph::getNode(const ProgramPoint &L,
  433 ExplodedNode *ExplodedGraph::createUncachedNode(const ProgramPoint &L,

tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

  693                             ProgramPoint::Kind K) {
 1576                                      ProgramPoint::PreStmtKind);
 1855     ProgramPoint L = N->getLocation();
 1883   ProgramPoint NewNodeLoc =
 2472                       ProgramPoint::PostLValueKind);
 2484                       ProgramPoint::PostLValueKind);
 2497                       ProgramPoint::PostLValueKind);
 2547           ProgramPoint::PostLValueKind);
 2629                           ProgramPoint::PostLValueKind);
 2672                       ProgramPoint::PostStmtKind);
 2762                           bool atDeclInit, const ProgramPoint *PP) {
 2778     const ProgramPoint L = PostStore(StoreE, LC, /*Loc*/nullptr,
 2803     const ProgramPoint L = PostStore(StoreE, LC, LocReg, nullptr);
 2873                       ProgramPoint::PostLoadKind);
 2932     ProgramPoint P = Pred->getLocation();

tools/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp

  253                     nullptr, ProgramPoint::PostLValueKind);
  673     ProgramPoint P = N->getLocation();
  796     ProgramPoint PP = N->getLocation();

tools/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

  490     BldrPrepare.generateNode(CE, Pred, State, &T, ProgramPoint::PreStmtKind);
  529                         ProgramPoint::PreStmtKind);
  935                     nullptr, ProgramPoint::PostLValueKind);

tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp

   81     const ProgramPoint &PP = Node->getLocation();
  181              ProgramPoint::PostStmtPurgeDeadSymbolsKind);
  295                ProgramPoint::PostStmtPurgeDeadSymbolsKind);

tools/clang/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp

  203                                  ProgramPoint::PreStmtKind);

tools/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp

  237     ProgramPoint P = N->getLocation();