fix more reinterpret_cast edge cases

fix wglGetProcAddress can sentinel value edge case

Author: mbaetgen-wup

src/libprojectM/Renderer/PlatformGLContextCheck.cpp

@@ -23,17 +23,17 @@ enum : std::uint16_t
     PM_GL_CONTEXT_PROFILE_MASK = 0x9126
 };
 
-enum : std::uint8_t
+enum : std::uint32_t
 {
-    PM_GL_CONTEXT_CORE_PROFILE_BIT          = 0x00000001,
-    PM_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002
+    PM_GL_CONTEXT_CORE_PROFILE_BIT          = 0x00000001u,
+    PM_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002u
 };
 
-enum : std::uint8_t
+enum : std::uint32_t
 {
-    PM_GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001,
-    PM_GL_CONTEXT_FLAG_DEBUG_BIT              = 0x00000002,
-    PM_GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT      = 0x00000004
+    PM_GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001u,
+    PM_GL_CONTEXT_FLAG_DEBUG_BIT              = 0x00000002u,
+    PM_GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT      = 0x00000004u
 };
 
 auto SafeStr(const unsigned char* str) -> const char*

src/libprojectM/Renderer/PlatformGLResolver.cpp

@@ -313,7 +313,7 @@ void GLResolver::ResolveProviderFunctions()
         }
         if (sym != nullptr)
         {
-            m_eglGetProcAddress = reinterpret_cast<EglGetProcAddressFn>(sym);
+            m_eglGetProcAddress = SymbolToFunction<EglGetProcAddressFn>(sym);
         }
     }
 
@@ -328,7 +328,7 @@ void GLResolver::ResolveProviderFunctions()
         }
         if (sym != nullptr)
         {
-            m_wglGetProcAddress = reinterpret_cast<WglGetProcAddressFn>(sym);
+            m_wglGetProcAddress = SymbolToFunction<WglGetProcAddressFn>(sym);
         }
     }
 #else
@@ -353,7 +353,7 @@ void GLResolver::ResolveProviderFunctions()
         }
         if (sym != nullptr)
         {
-            m_glxGetProcAddress = reinterpret_cast<GlxGetProcAddressFn>(sym);
+            m_glxGetProcAddress = SymbolToFunction<GlxGetProcAddressFn>(sym);
         }
     }
 #endif
@@ -437,7 +437,7 @@ namespace {
  */
 auto gladBridgeResolverThunk(const char* name) -> GLADapiproc
 {
-    return reinterpret_cast<GLADapiproc>(GLResolver::GladResolverThunk(name));
+    return SymbolToFunction<GLADapiproc>(GLResolver::GladResolverThunk(name));
 }
 
 } // namespace
@@ -509,7 +509,7 @@ auto GLResolver::ResolveUnlocked(const char* name,
         EglProc proc = eglGetProcAddressFn(name);
         if (proc != nullptr)
         {
-            return reinterpret_cast<void*>(proc);
+            return FunctionToSymbol(proc);
         }
     }
 
@@ -519,7 +519,7 @@ auto GLResolver::ResolveUnlocked(const char* name,
         auto proc = glxGetProcAddressFn(reinterpret_cast<const unsigned char*>(name));
         if (proc != nullptr)
         {
-            return reinterpret_cast<void*>(proc);
+            return FunctionToSymbol(proc);
         }
     }
 #else
@@ -528,7 +528,13 @@ auto GLResolver::ResolveUnlocked(const char* name,
         PROC proc = wglGetProcAddressFn(name);
         if (proc != nullptr)
         {
-            return reinterpret_cast<void*>(proc);
+            // wglGetProcAddress can return special sentinel values (1,2,3,-1) for core symbols.
+            // Treat those as invalid and allow fallback to GetProcAddress/dlsym paths.
+            const std::uintptr_t raw = FunctionToInteger(proc);
+            if (raw != 1u && raw != 2u && raw != 3u && raw != static_cast<std::uintptr_t>(~0u))
+            {
+                return FunctionToSymbol(proc);
+            }
         }
     }
 #endif

src/libprojectM/Renderer/PlatformLoader.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstddef>
+#include <cstdint>
 #include <cstring>
 #include <string>
 
@@ -363,6 +364,58 @@ auto SymbolToFunction(void* symbol) -> Fn
     return func;
 }
 
+/**
+ * @brief Converts a function pointer into a symbol pointer representation without UB.
+ *
+ * The inverse of SymbolToFunction(). This is used at API boundaries where legacy
+ * interfaces represent procedure addresses as void*.
+ *
+ * @tparam Fn Function pointer type.
+ * @param func Function pointer.
+ * @return Symbol pointer as void* or nullptr if not representable.
+ */
+template <typename Fn>
+auto FunctionToSymbol(Fn func) -> void*
+{
+    if (func == nullptr)
+    {
+        return nullptr;
+    }
+
+    if (sizeof(Fn) != sizeof(void*))
+    {
+        return nullptr;
+    }
+
+    void* symbol = nullptr;
+    std::memcpy(&symbol, &func, sizeof(void*));
+    return symbol;
+}
+
+/**
+ * @brief Converts a function pointer into an integer representation (best-effort).
+ *
+ * Useful for validating platform-specific sentinel values (e.g. Windows WGL).
+ * Returns 0 if the conversion is not representable.
+ */
+template <typename Fn>
+auto FunctionToInteger(Fn func) -> std::uintptr_t
+{
+    if (func == nullptr)
+    {
+        return 0;
+    }
+
+    if (sizeof(Fn) != sizeof(void*))
+    {
+        return 0;
+    }
+
+    std::uintptr_t value = 0;
+    std::memcpy(&value, &func, sizeof(std::uintptr_t));
+    return value;
+}
+
 inline auto IsCurrentEgl(const DynamicLibrary& eglLib) -> bool
 {
     if (!eglLib.IsOpen())