[clang] [clang] LazyOffsetPtr: Use native pointer width (PR #111995)

[Jessica Clarke via cfe-commits]

================
@@ -326,25 +326,25 @@ struct LazyOffsetPtr {
   ///
   /// If the low bit is clear, a pointer to the AST node. If the low
   /// bit is set, the upper 63 bits are the offset.
-  mutable uint64_t Ptr = 0;
+  mutable uintptr_t Ptr = 0;
 
 public:
   LazyOffsetPtr() = default;
-  explicit LazyOffsetPtr(T *Ptr) : Ptr(reinterpret_cast<uint64_t>(Ptr)) {}
+  explicit LazyOffsetPtr(T *Ptr) : Ptr(reinterpret_cast<uintptr_t>(Ptr)) {}
 
-  explicit LazyOffsetPtr(uint64_t Offset) : Ptr((Offset << 1) | 0x01) {
-    assert((Offset << 1 >> 1) == Offset && "Offsets must require < 63 bits");
+  explicit LazyOffsetPtr(uintptr_t Offset) : Ptr((Offset << 1) | 0x01) {
+    assert((Offset << 1 >> 1) == Offset && "Offsets must fit in addressable bits");
     if (Offset == 0)
       Ptr = 0;
   }
 
   LazyOffsetPtr &operator=(T *Ptr) {
-    this->Ptr = reinterpret_cast<uint64_t>(Ptr);
+    this->Ptr = reinterpret_cast<uintptr_t>(Ptr);
     return *this;
   }
 
-  LazyOffsetPtr &operator=(uint64_t Offset) {
-    assert((Offset << 1 >> 1) == Offset && "Offsets must require < 63 bits");
+  LazyOffsetPtr &operator=(uintptr_t Offset) {
----------------
jrtc27 wrote:

> I think the right solution is to store a `uint64_t` and just do an intermediate cast to `uintptr_t` when going from `uint64_t` to a pointer type and vice-versa. I'd like to not hard-code the assumption that AST file sizes can't be out of the range of `uintptr_t` here. I believe you're right that we do `mmap` the entire AST file right now, but there are other implementation approaches that would support AST files larger than the address space.

That doesn't work for getAddressOfPointer (and doesn't work for CHERI either, but there are many instances of that idiom in Clang to fix...).

https://github.com/llvm/llvm-project/pull/111995