[clang] Introduce a union inside ProgramPoint.

[simon_tatham]

Summary

This is part of a patch series working towards the ability to make
SourceLocation into a 64-bit type to handle larger translation units.

The void *Data1 field in ProgramPoint is sometimes used to store a
SourceLocation in pointer encoding, and sometimes used to store other
pointer data. If SourceLocation becomes 64-bit when clang is compiled
for a 32-bit platform, then this won't fit any more. Hence, we change
the type of Data1 to a union storing either an actual SourceLocation
or a pointer.

Patch originally by Mikhail Maltsev.

[lenary]

This change looks fine to me (though clang-format wants a reasonable change). I'm not familiar with the clang static analyzer, so I'm not sure I can +2 this, but hopefully this message will act as a ping for the existing reviewers?

[lebedev.ri]

This review may be stuck/dead, consider abandoning if no longer relevant.
Removing myself as reviewer in attempt to clean dashboard.

clang/include/clang/Analysis/ProgramPoint.h

 
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/AlignOf.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataTypes.h"
 #include <cassert>
 #include <string>
 #include <utility>
 
 namespace clang {
 
enum Kind { BlockEdgeKind,
               CallExitEndKind,
               FunctionExitKind,
               PreImplicitCallKind,
               PostImplicitCallKind,
               MinImplicitCallKind = PreImplicitCallKind,
               MaxImplicitCallKind = PostImplicitCallKind,
               LoopExitKind,
               EpsilonKind};
-
 private:
-  const void *Data1;
+  union PtrOrSLoc {
+    PtrOrSLoc() {}
+    PtrOrSLoc(const void *P) {
+      memset(Raw.buffer, 0, sizeof(Raw.buffer));
+      Ptr = P;
+    }
+    PtrOrSLoc(SourceLocation L) {
+      memset(Raw.buffer, 0, sizeof(Raw.buffer));
+      new (&SLoc) SourceLocation(L);
+    }
+    bool operator==(const PtrOrSLoc &RHS) const {
+      return memcmp(this, &RHS, sizeof(PtrOrSLoc)) == 0;
+    }
+    bool operator!=(const PtrOrSLoc &RHS) const { return !(*this == RHS); }
+    StringRef AsBuffer() const {
+      const char *c = (const char *)this;
+      return StringRef(c, sizeof(PtrOrSLoc));
+    }
+    const void *Ptr;
+    SourceLocation SLoc;
+    llvm::AlignedCharArrayUnion<void *, SourceLocation> Raw;
+  };
+
+  PtrOrSLoc Data1;
   llvm::PointerIntPair<const void *, 2, unsigned> Data2;
 
   // The LocationContext could be NULL to allow ProgramPoint to be used in
   // context insensitive analysis.
   llvm::PointerIntPair<const LocationContext *, 2, unsigned> L;
 
   llvm::PointerIntPair<const ProgramPointTag *, 2, unsigned> Tag;
 
 protected:
   ProgramPoint() = default;
   ProgramPoint(const void *P,
                Kind k,
                const LocationContext *l,
                const ProgramPointTag *tag = nullptr)
     : Data1(P),
       Data2(nullptr, (((unsigned) k) >> 0) & 0x3),
       L(l, (((unsigned) k) >> 2) & 0x3),
       Tag(tag, (((unsigned) k) >> 4) & 0x3) {
         assert(getKind() == k);
         assert(getLocationContext() == l);
-        assert(getData1() == P);
+        assert(getData1Ptr() == P);
       }
 
-  ProgramPoint(const void *P1,
-               const void *P2,
-               Kind k,
+      ProgramPoint(PtrOrSLoc D1, const void *P2, Kind k,
                    const LocationContext *l,
                    const ProgramPointTag *tag = nullptr)
-    : Data1(P1),
-      Data2(P2, (((unsigned) k) >> 0) & 0x3),
-      L(l, (((unsigned) k) >> 2) & 0x3),
-      Tag(tag, (((unsigned) k) >> 4) & 0x3) {}
+          : Data1(D1), Data2(P2, (((unsigned)k) >> 0) & 0x3),
+            L(l, (((unsigned)k) >> 2) & 0x3),
+            Tag(tag, (((unsigned)k) >> 4) & 0x3) {}
 
+      ProgramPoint(const void *P1, const void *P2, Kind k,
+                   const LocationContext *l,
+                   const ProgramPointTag *tag = nullptr)
+          : ProgramPoint(PtrOrSLoc(P1), P2, k, l, tag) {}
+
+      ProgramPoint(SourceLocation Loc, const void *P2, Kind k,
+                   const LocationContext *l,
+                   const ProgramPointTag *tag = nullptr)
+          : ProgramPoint(PtrOrSLoc(Loc), P2, k, l, tag) {}
+
     protected:
-  const void *getData1() const { return Data1; }
+      const PtrOrSLoc &getData1() const { return Data1; }
+      const void *getData1Ptr() const { return Data1.Ptr; }
       const void *getData2() const { return Data2.getPointer(); }
       void setData2(const void *d) { Data2.setPointer(d); }
 
     public:
       /// Create a new ProgramPoint object that is the same as the original
       /// except for using the specified tag value.
       ProgramPoint withTag(const ProgramPointTag *tag) const {
         return ProgramPoint(getData1(), getData2(), getKind(),
                             getLocationContext(), tag);
   }
 
   /// Convert to the specified ProgramPoint type, asserting that this
   /// ProgramPoint is of the desired type.
   template<typename T>
   T castAs() const {
     assert(T::isKind(*this));
     T t;
     ProgramPoint& PP = t;
bool operator!=(const ProgramPoint &RHS) const {
     return Data1 != RHS.Data1 ||
            Data2 != RHS.Data2 ||
            L != RHS.L ||
            Tag != RHS.Tag;
   }
 
   void Profile(llvm::FoldingSetNodeID& ID) const {
     ID.AddInteger((unsigned) getKind());
-    ID.AddPointer(getData1());
+    ID.AddString(getData1().AsBuffer());
     ID.AddPointer(getData2());
     ID.AddPointer(getLocationContext());
     ID.AddPointer(getTag());
   }
 
   void printJson(llvm::raw_ostream &Out, const char *NL = "\n") const;
 
   LLVM_DUMP_METHOD void dump() const;
 
   static ProgramPoint getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
                                       const LocationContext *LC,
                                       const ProgramPointTag *tag);
 };
 
 class BlockEntrance : public ProgramPoint {
 public:
   BlockEntrance(const CFGBlock *B, const LocationContext *L,
                 const ProgramPointTag *tag = nullptr)
     : ProgramPoint(B, BlockEntranceKind, L, tag) {
     assert(B && "BlockEntrance requires non-null block");
   }
 
   const CFGBlock *getBlock() const {
-    return reinterpret_cast<const CFGBlock*>(getData1());
+    return reinterpret_cast<const CFGBlock *>(getData1Ptr());
   }
 
   Optional<CFGElement> getFirstElement() const {
     const CFGBlock *B = getBlock();
     return B->empty() ? Optional<CFGElement>() : B->front();
   }
 
 private:
   friend class ProgramPoint;
   BlockEntrance() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == BlockEntranceKind;
   }
 };
 
 class BlockExit : public ProgramPoint {
 public:
   BlockExit(const CFGBlock *B, const LocationContext *L)
     : ProgramPoint(B, BlockExitKind, L) {}
 
   const CFGBlock *getBlock() const {
-    return reinterpret_cast<const CFGBlock*>(getData1());
+    return reinterpret_cast<const CFGBlock *>(getData1Ptr());
   }
 
   const Stmt *getTerminator() const {
     return getBlock()->getTerminatorStmt();
   }
 
 private:
   friend class ProgramPoint;
   BlockExit() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == BlockExitKind;
   }
 };
 
 class StmtPoint : public ProgramPoint {
 public:
   StmtPoint(const Stmt *S, const void *p2, Kind k, const LocationContext *L,
             const ProgramPointTag *tag)
     : ProgramPoint(S, p2, k, L, tag) {
     assert(S);
   }
 
-  const Stmt *getStmt() const { return (const Stmt*) getData1(); }
+  const Stmt *getStmt() const { return (const Stmt *)getData1Ptr(); }
 
   template <typename T>
   const T* getStmtAs() const { return dyn_cast<T>(getStmt()); }
 
 protected:
   StmtPoint() = default;
 private:
   friend class ProgramPoint;
explicit FunctionExitPoint(const ReturnStmt *S,
                              const ProgramPointTag *tag = nullptr)
       : ProgramPoint(S, FunctionExitKind, LC, tag) {}
 
   const CFGBlock *getBlock() const {
     return &getLocationContext()->getCFG()->getExit();
   }
 
   const ReturnStmt *getStmt() const {
-    return reinterpret_cast<const ReturnStmt *>(getData1());
+    return reinterpret_cast<const ReturnStmt *>(getData1Ptr());
   }
 
 private:
   friend class ProgramPoint;
   FunctionExitPoint() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == FunctionExitKind;
   }

 public:
   BlockEdge(const CFGBlock *B1, const CFGBlock *B2, const LocationContext *L)
     : ProgramPoint(B1, B2, BlockEdgeKind, L) {
     assert(B1 && "BlockEdge: source block must be non-null");
     assert(B2 && "BlockEdge: destination block must be non-null");
   }
 
   const CFGBlock *getSrc() const {
-    return static_cast<const CFGBlock*>(getData1());
+    return static_cast<const CFGBlock *>(getData1Ptr());
   }
 
   const CFGBlock *getDst() const {
     return static_cast<const CFGBlock*>(getData2());
   }
 
 private:
   friend class ProgramPoint;
public:
   /// \param I The initializer.
   /// \param Loc The location of the field being initialized.
   PostInitializer(const CXXCtorInitializer *I,
                   const void *Loc,
                   const LocationContext *L)
     : ProgramPoint(I, Loc, PostInitializerKind, L) {}
 
   const CXXCtorInitializer *getInitializer() const {
-    return static_cast<const CXXCtorInitializer *>(getData1());
+    return static_cast<const CXXCtorInitializer *>(getData1Ptr());
   }
 
   /// Returns the location of the field.
   const void *getLocationValue() const {
     return getData2();
   }
 
 private:
   friend class ProgramPoint;
   PostInitializer() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PostInitializerKind;
   }
 };
 
 /// Represents an implicit call event.
 ///
 /// The nearest statement is provided for diagnostic purposes.
 class ImplicitCallPoint : public ProgramPoint {
 public:
   ImplicitCallPoint(const Decl *D, SourceLocation Loc, Kind K,
                     const LocationContext *L, const ProgramPointTag *Tag)
-    : ProgramPoint(Loc.getPtrEncoding(), D, K, L, Tag) {}
+      : ProgramPoint(Loc, D, K, L, Tag) {}
 
   const Decl *getDecl() const { return static_cast<const Decl *>(getData2()); }
-  SourceLocation getLocation() const {
-    return SourceLocation::getFromPtrEncoding(getData1());
-  }
+  SourceLocation getLocation() const { return getData1().SLoc; }
 
 protected:
   ImplicitCallPoint() = default;
 private:
   friend class ProgramPoint;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() >= MinImplicitCallKind &&
            Location.getKind() <= MaxImplicitCallKind;

 /// CallEnter uses the caller's location context.
 class CallEnter : public ProgramPoint {
 public:
   CallEnter(const Stmt *stmt, const StackFrameContext *calleeCtx,
             const LocationContext *callerCtx)
     : ProgramPoint(stmt, calleeCtx, CallEnterKind, callerCtx, nullptr) {}
 
   const Stmt *getCallExpr() const {
-    return static_cast<const Stmt *>(getData1());
+    return static_cast<const Stmt *>(getData1Ptr());
   }
 
   const StackFrameContext *getCalleeContext() const {
     return static_cast<const StackFrameContext *>(getData2());
   }
 
   /// Returns the entry block in the CFG for the entered function.
   const CFGBlock *getEntry() const {

 /// - CallExitEnd
 class CallExitBegin : public ProgramPoint {
 public:
   // CallExitBegin uses the callee's location context.
   CallExitBegin(const StackFrameContext *L, const ReturnStmt *RS)
     : ProgramPoint(RS, CallExitBeginKind, L, nullptr) { }
 
   const ReturnStmt *getReturnStmt() const {
-    return static_cast<const ReturnStmt *>(getData1());
+    return static_cast<const ReturnStmt *>(getData1Ptr());
   }
 
 private:
   friend class ProgramPoint;
   CallExitBegin() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == CallExitBeginKind;
   }
 };
 
 /// Represents a point when we finish the call exit sequence (for inlined call).
 /// \sa CallExitBegin
 class CallExitEnd : public ProgramPoint {
 public:
   // CallExitEnd uses the caller's location context.
   CallExitEnd(const StackFrameContext *CalleeCtx,
               const LocationContext *CallerCtx)
     : ProgramPoint(CalleeCtx, CallExitEndKind, CallerCtx, nullptr) {}
 
   const StackFrameContext *getCalleeContext() const {
-    return static_cast<const StackFrameContext *>(getData1());
+    return static_cast<const StackFrameContext *>(getData1Ptr());
   }
 
 private:
   friend class ProgramPoint;
   CallExitEnd() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == CallExitEndKind;
   }
 };
 
 /// Represents a point when we exit a loop.
 /// When this ProgramPoint is encountered we can be sure that the symbolic
 /// execution of the corresponding LoopStmt is finished on the given path.
 /// Note: It is possible to encounter a LoopExit element when we haven't even
 /// encountered the loop itself. At the current state not all loop exits will
 /// result in a LoopExit program point.
 class LoopExit : public ProgramPoint {
 public:
     LoopExit(const Stmt *LoopStmt, const LocationContext *LC)
             : ProgramPoint(LoopStmt, nullptr, LoopExitKind, LC) {}
 
     const Stmt *getLoopStmt() const {
-      return static_cast<const Stmt *>(getData1());
+      return static_cast<const Stmt *>(getData1Ptr());
     }
 
 private:
     friend class ProgramPoint;
     LoopExit() = default;
     static bool isKind(const ProgramPoint &Location) {
       return Location.getKind() == LoopExitKind;
     }
 };
 
 /// This is a meta program point, which should be skipped by all the diagnostic
 /// reasoning etc.
 class EpsilonPoint : public ProgramPoint {
 public:
   EpsilonPoint(const LocationContext *L, const void *Data1,
                const void *Data2 = nullptr,
                const ProgramPointTag *tag = nullptr)
     : ProgramPoint(Data1, Data2, EpsilonKind, L, tag) {}
 
-  const void *getData() const { return getData1(); }
+  const void *getData() const { return getData1Ptr(); }
 
 private:
   friend class ProgramPoint;
   EpsilonPoint() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == EpsilonKind;
   }
 };