NFC: Change PointerLikeTypeTraits::NumLowBitsAvailable from enum to static member. This allows GDB pretty printer to find the value.

[csigg]

Summary

NFC: PointerLikeTypeTraits::NumLowBitsAvailable enum > static int

[merge_guards_bot]

Unit tests: pass. 61776 tests passed, 0 failed and 780 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[dblaikie]

Could you provide a small example of the problem here? LLVM does emit debug info for used enums (granted, if it's used as a template parameter it looks like LLVM does not emit them - but if it's used in a runtime evaluated expression it does/should & it looks like NumLowBitsAvailable is used in that way pretty regularly)

Does the debug info have the enum/enumerator/constant, but GDB provide no way to look it up?

[csigg]

I was not able to get to NumLowBitsAvailable through Python GDB if it's an enumeration inside an anonymous struct.

• If it's in a named struct, I could use gdb.lookup_type(enum_name).fields() and parse the Field.name and get the Field.enumvalue.
• If it's a static member, I can do gdb.parse_and_evel(enumeration_name) or gdb.lookup_symbol(enumeration_name)[0].value().

I'm not sure anymore if I tried a named struct with the latter, but possibly it would work.
The current status is a mix of anonymous enums and 'static const', so maybe unifying it is the easiest way to make it work.

[dblaikie]

I've committed a generalization of this (applying the same logic to all instances of NumLowBitsAvailable) in 65eb74e94b414fcde6bfa810d1c30c7fcb136b77 - so this review can be closed or abandoned.

[dblaikie]

In D72590#1825399, @dblaikie wrote:

I've committed a generalization of this (applying the same logic to all instances of NumLowBitsAvailable) in 65eb74e94b414fcde6bfa810d1c30c7fcb136b77 - so this review can be closed or abandoned.

Ah, if I'm reading the other review correctly, this change was/is no longer needed - ah well, it's committed now & not harmful (a little questionable given the lack of storage... but I think it might as well stay that way in hopes of the C++17 future state of things).

[csigg]

Thanks a lot for your help. Sorry I've not been keeping up.

llvm/include/llvm/Support/PointerLikeTypeTraits.h

 };
 } // namespace detail
 
 // Provide PointerLikeTypeTraits for non-cvr pointers.
 template <typename T> struct PointerLikeTypeTraits<T *> {
   static inline void *getAsVoidPointer(T *P) { return P; }
   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
 
-  enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
+  static constexpr int NumLowBitsAvailable =
+      detail::ConstantLog2<alignof(T)>::value;
 };
 
 template <> struct PointerLikeTypeTraits<void *> {
   static inline void *getAsVoidPointer(void *P) { return P; }
   static inline void *getFromVoidPointer(void *P) { return P; }
 
   /// Note, we assume here that void* is related to raw malloc'ed memory and
   /// that malloc returns objects at least 4-byte aligned. However, this may be
   /// wrong, or pointers may be from something other than malloc. In this case,
   /// you should specify a real typed pointer or avoid this template.
   ///
   /// All clients should use assertions to do a run-time check to ensure that
   /// this is actually true.
-  enum { NumLowBitsAvailable = 2 };
+  static constexpr int NumLowBitsAvailable = 2;
 };
 
 // Provide PointerLikeTypeTraits for const things.
 template <typename T> struct PointerLikeTypeTraits<const T> {
   typedef PointerLikeTypeTraits<T> NonConst;
 
   static inline const void *getAsVoidPointer(const T P) {
     return NonConst::getAsVoidPointer(P);
   }
   static inline const T getFromVoidPointer(const void *P) {
     return NonConst::getFromVoidPointer(const_cast<void *>(P));
   }
-  enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
+  static constexpr int NumLowBitsAvailable = NonConst::NumLowBitsAvailable;
 };
 
 // Provide PointerLikeTypeTraits for const pointers.
 template <typename T> struct PointerLikeTypeTraits<const T *> {
   typedef PointerLikeTypeTraits<T *> NonConst;
 
   static inline const void *getAsVoidPointer(const T *P) {
     return NonConst::getAsVoidPointer(const_cast<T *>(P));
   }
   static inline const T *getFromVoidPointer(const void *P) {
     return NonConst::getFromVoidPointer(const_cast<void *>(P));
   }
-  enum { NumLowBitsAvailable = NonConst::NumLowBitsAvailable };
+  static constexpr int NumLowBitsAvailable = NonConst::NumLowBitsAvailable;
 };
 
 // Provide PointerLikeTypeTraits for uintptr_t.
 template <> struct PointerLikeTypeTraits<uintptr_t> {
   static inline void *getAsVoidPointer(uintptr_t P) {
     return reinterpret_cast<void *>(P);
   }
   static inline uintptr_t getFromVoidPointer(void *P) {
     return reinterpret_cast<uintptr_t>(P);
   }
   // No bits are available!
-  enum { NumLowBitsAvailable = 0 };
+  static constexpr int NumLowBitsAvailable = 0;
 };
 
 /// Provide suitable custom traits struct for function pointers.
 ///
 /// Function pointers can't be directly given these traits as functions can't
 /// have their alignment computed with `alignof` and we need different casting.
 ///
 /// To rely on higher alignment for a specialized use, you can provide a
 /// customized form of this template explicitly with higher alignment, and
 /// potentially use alignment attributes on functions to satisfy that.
 template <int Alignment, typename FunctionPointerT>
 struct FunctionPointerLikeTypeTraits {
-  enum { NumLowBitsAvailable = detail::ConstantLog2<Alignment>::value };
+  static constexpr int NumLowBitsAvailable =
+      detail::ConstantLog2<Alignment>::value;
   static inline void *getAsVoidPointer(FunctionPointerT P) {
     assert((reinterpret_cast<uintptr_t>(P) &
             ~((uintptr_t)-1 << NumLowBitsAvailable)) == 0 &&
            "Alignment not satisfied for an actual function pointer!");
     return reinterpret_cast<void *>(P);
   }
   static inline FunctionPointerT getFromVoidPointer(void *P) {
     return reinterpret_cast<FunctionPointerT>(P);