[analyzer] Generate and use stable identifiers for LocationContext

[george.karpenkov]

Summary

Those are not created in the allocator.
Since they are created fairly rarely, a counter overhead should not affect the memory consumption.

[NoQ]

clang/include/clang/Analysis/AnalysisDeclContext.h

234

This means that for every new analysis the counter will continue rather than reset to 0.

Maybe store the counter in the manager as a non-static field?

[george.karpenkov]

clang/include/clang/Analysis/AnalysisDeclContext.h

234

OK

[NoQ]

Yay!

clang/include/clang/Analysis/AnalysisDeclContext.h

 private:
   ContextKind Kind;
 
   // AnalysisDeclContext can't be const since some methods may modify its
   // member.
   AnalysisDeclContext *Ctx;
 
   const LocationContext *Parent;
+  int64_t ID;
 
 protected:
   LocationContext(ContextKind k, AnalysisDeclContext *ctx,
-                  const LocationContext *parent)
-      : Kind(k), Ctx(ctx), Parent(parent) {}
+                  const LocationContext *parent,
+                  int64_t ID)
+      : Kind(k), Ctx(ctx), Parent(parent), ID(ID) {}
 
 public:
   virtual ~LocationContext();
 
   ContextKind getKind() const { return Kind; }
 
+  int64_t getID() const {
+    return ID;
+  }
+
   AnalysisDeclContext *getAnalysisDeclContext() const { return Ctx; }
 
   const LocationContext *getParent() const { return Parent; }
 
   bool isParentOf(const LocationContext *LC) const;
 
   const Decl *getDecl() const { return getAnalysisDeclContext()->getDecl(); }
 
class StackFrameContext : public LocationContext {
   // The parent block of the callsite.
   const CFGBlock *Block;
 
   // The index of the callsite in the CFGBlock.
   unsigned Index;
 
   StackFrameContext(AnalysisDeclContext *ctx, const LocationContext *parent,
                     const Stmt *s, const CFGBlock *blk,
-                    unsigned idx)
-      : LocationContext(StackFrame, ctx, parent), CallSite(s),
+                    unsigned idx,
+                    int64_t ID)
+      : LocationContext(StackFrame, ctx, parent, ID), CallSite(s),
         Block(blk), Index(idx) {}
 
 public:
   ~StackFrameContext() override = default;
 
   const Stmt *getCallSite() const { return CallSite; }
 
   const CFGBlock *getCallSiteBlock() const { return Block; }

 };
 
 class ScopeContext : public LocationContext {
   friend class LocationContextManager;
 
   const Stmt *Enter;
 
   ScopeContext(AnalysisDeclContext *ctx, const LocationContext *parent,
-               const Stmt *s)
-      : LocationContext(Scope, ctx, parent), Enter(s) {}
+               const Stmt *s, int64_t ID)
+      : LocationContext(Scope, ctx, parent, ID), Enter(s) {}
 
 public:
   ~ScopeContext() override = default;
 
   void Profile(llvm::FoldingSetNodeID &ID) override;
 
   static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx,
                       const LocationContext *parent, const Stmt *s) {
class BlockInvocationContext : public LocationContext {
   friend class LocationContextManager;
 
   const BlockDecl *BD;
 
   // FIXME: Come up with a more type-safe way to model context-sensitivity.
   const void *ContextData;
 
   BlockInvocationContext(AnalysisDeclContext *ctx,
-                         const LocationContext *parent,
-                         const BlockDecl *bd, const void *contextData)
-      : LocationContext(Block, ctx, parent), BD(bd), ContextData(contextData) {}
+                         const LocationContext *parent, const BlockDecl *bd,
+                         const void *contextData, int64_t ID)
+      : LocationContext(Block, ctx, parent, ID), BD(bd),
+        ContextData(contextData) {}
 
 public:
   ~BlockInvocationContext() override = default;
 
   const BlockDecl *getBlockDecl() const { return BD; }
 
   const void *getContextData() const { return ContextData; }
 
public:
   static bool classof(const LocationContext *Ctx) {
     return Ctx->getKind() == Block;
   }
 };
 
 class LocationContextManager {
   llvm::FoldingSet<LocationContext> Contexts;
 
+  /// ID used for generating a new location context.
+  int64_t NewID = 0;
+
 public:
   ~LocationContextManager();
 
   const StackFrameContext *getStackFrame(AnalysisDeclContext *ctx,
                                          const LocationContext *parent,
                                          const Stmt *s,
                                          const CFGBlock *blk, unsigned idx);
 

clang/lib/Analysis/AnalysisDeclContext.cpp

LocationContextManager::getLocationContext(AnalysisDeclContext *ctx,
                                            const DATA *d) {
   llvm::FoldingSetNodeID ID;
   LOC::Profile(ID, ctx, parent, d);
   void *InsertPos;
 
   LOC *L = cast_or_null<LOC>(Contexts.FindNodeOrInsertPos(ID, InsertPos));
 
   if (!L) {
-    L = new LOC(ctx, parent, d);
+    L = new LOC(ctx, parent, d, ++NewID);
     Contexts.InsertNode(L, InsertPos);
   }
   return L;
 }
 
 const StackFrameContext*
 LocationContextManager::getStackFrame(AnalysisDeclContext *ctx,
                                       const LocationContext *parent,
                                       const Stmt *s,
                                       const CFGBlock *blk, unsigned idx) {
   llvm::FoldingSetNodeID ID;
   StackFrameContext::Profile(ID, ctx, parent, s, blk, idx);
   void *InsertPos;
   auto *L =
    cast_or_null<StackFrameContext>(Contexts.FindNodeOrInsertPos(ID, InsertPos));
   if (!L) {
-    L = new StackFrameContext(ctx, parent, s, blk, idx);
+    L = new StackFrameContext(ctx, parent, s, blk, idx, ++NewID);
     Contexts.InsertNode(L, InsertPos);
   }
   return L;
 }
 
 const ScopeContext *
 LocationContextManager::getScope(AnalysisDeclContext *ctx,
                                  const LocationContext *parent,
                                  const Stmt *s) {
   return getLocationContext<ScopeContext, Stmt>(ctx, parent, s);
 }
 
 const BlockInvocationContext *
 LocationContextManager::getBlockInvocationContext(AnalysisDeclContext *ctx,
                                                   const LocationContext *parent,
                                                   const BlockDecl *BD,
                                                   const void *ContextData) {
   llvm::FoldingSetNodeID ID;
   BlockInvocationContext::Profile(ID, ctx, parent, BD, ContextData);
   void *InsertPos;
   auto *L =
     cast_or_null<BlockInvocationContext>(Contexts.FindNodeOrInsertPos(ID,
                                                                     InsertPos));
   if (!L) {
-    L = new BlockInvocationContext(ctx, parent, BD, ContextData);
+    L = new BlockInvocationContext(ctx, parent, BD, ContextData, ++NewID);
     Contexts.InsertNode(L, InsertPos);
   }
   return L;
 }
 
 //===----------------------------------------------------------------------===//
 // LocationContext methods.
 //===----------------------------------------------------------------------===//

clang/lib/StaticAnalyzer/Core/Environment.cpp

void Environment::print(raw_ostream &Out, const char *NL,
   WithLC->dumpStack(Out, "", NL, Sep, [&](const LocationContext *LC) {
     for (auto I : ExprBindings) {
       if (I.first.getLocationContext() != LC)
         continue;
 
       const Stmt *S = I.first.getStmt();
       assert(S != nullptr && "Expected non-null Stmt");
 
-      Out << "(LC" << (const void *)LC << ", S" << S->getID(Context) << " <"
-          << (const void *)S << "> ) ";
+      Out << "(LC " << LC->getID() << " <" << (const void *)LC << ">, S "
+          << S->getID(Context) << " <" << (const void *)S << ">) ";
       S->printPretty(Out, /*Helper=*/nullptr, PP);
       Out << " : " << I.second << NL;
     }
   });
 }