Do not rely on volatile for double/float decoding

I believe volatile was used to ensure that the compile does not optimize
the code in ways that break the bit manipulation. Switching to memcpy
and using the built-in bswap implementations when available seems
like a better way to solve the issue.

This also fixes the following warning:

```
/home/greg/MaxMind/MaxMindDBSwift/Sources/CLibMaxMindDB/libmaxminddb-1.12.2/src/maxminddb.c:1781:12: warning: passing 'volatile uint8_t *' (aka 'volatile unsigned char *') to parameter of type 'void *' discards qualifiers [-Wincompatible-pointer-types-discards-qualifiers]
 1781 |     memcpy(q, p, 4);
      |            ^
/usr/include/string.h:43:39: note: passing argument to parameter '__dest' here
   43 | extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
      |                                       ^
/home/greg/MaxMind/MaxMindDBSwift/Sources/CLibMaxMindDB/libmaxminddb-1.12.2/src/maxminddb.c:1799:12: warning: passing 'volatile uint8_t *' (aka 'volatile unsigned char *') to parameter of type 'void *' discards qualifiers [-Wincompatible-pointer-types-discards-qualifiers]
 1799 |     memcpy(q, p, 8);
      |            ^
/usr/include/string.h:43:39: note: passing argument to parameter '__dest' here
   43 | extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
      |                                       ^
2 warnings generated.
```

Author: oschwald

Changes.md

@@ -1,3 +1,8 @@
+## 1.13.0
+
+* The handling of float and double types was rewritten to fix compiler errors
+  and to eliminate the use of volatile.
+
 ## 1.12.2 - 2025-01-10
 
 * `MMDB_get_entry_data_list()` now always sets the passed `entry_data_list`

src/maxminddb.c

@@ -1767,38 +1767,65 @@ static int get_entry_data_list(const MMDB_s *const mmdb,
     return MMDB_SUCCESS;
 }
 
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+static inline uint32_t bswap32(uint32_t x) {
+#if defined(_MSC_VER)
+    return _byteswap_ulong(x);
+#elif __has_builtin(__builtin_bswap32)
+    return __builtin_bswap32(x);
+#else
+    x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0x00FF00FF);
+    return (x << 16) | (x >> 16);
+#endif
+}
+
+static inline uint64_t bswap64(uint64_t x) {
+#if defined(_MSC_VER)
+    return _byteswap_uint64(x);
+#elif __has_builtin(__builtin_bswap64)
+    return __builtin_bswap64(x);
+#else
+    x = ((x & 0x00000000FFFFFFFFULL) << 32) |
+        ((x & 0xFFFFFFFF00000000ULL) >> 32);
+    x = ((x & 0x0000FFFF0000FFFFULL) << 16) |
+        ((x & 0xFFFF0000FFFF0000ULL) >> 16);
+    return ((x & 0x00FF00FF00FF00FFULL) << 8) |
+           ((x & 0xFF00FF00FF00FF00ULL) >> 8);
+#endif
+}
+
 static float get_ieee754_float(const uint8_t *restrict p) {
-    volatile float f;
-    volatile uint8_t *q = (volatile void *)&f;
+    float f;
+    uint32_t i;
+
+    memcpy(&i, p, sizeof(uint32_t));
+
 /* Windows builds don't use autoconf but we can assume they're all
  * little-endian. */
 #if MMDB_LITTLE_ENDIAN || _WIN32
-    q[3] = p[0];
-    q[2] = p[1];
-    q[1] = p[2];
-    q[0] = p[3];
-#else
-    memcpy(q, p, 4);
+    i = bswap32(i);
 #endif
+
+    memcpy(&f, &i, sizeof(float));
+
     return f;
 }
 
 static double get_ieee754_double(const uint8_t *restrict p) {
-    volatile double d;
-    volatile uint8_t *q = (volatile void *)&d;
+    double d;
+    uint64_t i;
+
+    memcpy(&i, p, sizeof(uint64_t));
+
 #if MMDB_LITTLE_ENDIAN || _WIN32
-    q[7] = p[0];
-    q[6] = p[1];
-    q[5] = p[2];
-    q[4] = p[3];
-    q[3] = p[4];
-    q[2] = p[5];
-    q[1] = p[6];
-    q[0] = p[7];
-#else
-    memcpy(q, p, 8);
+    i = bswap64(i);
 #endif
 
+    memcpy(&d, &i, sizeof(double));
+
     return d;
 }