Adjust MemSet macro to use size_t rather than long

Likewise for MemSetAligned.

"long" wasn't the most suitable type for these macros as with MSVC in
64-bit builds, sizeof(long) == 4, which is narrower than the processor's
word size, therefore these macros had to perform twice as many loops as
they otherwise might.

Author: David Rowley <dgrowleyml@gmail.com>
Reviewed-by: Heikki Linnakangas <hlinnaka@iki.fi>
Reviewed-by: Peter Eisentraut <peter@eisentraut.org>
Discussion: https://postgr.es/m/CAApHDvoGFjSA3aNyVQ3ivbyc4ST=CC5L-_VjEUQ92HbE2Cxovg@mail.gmail.com

diff --git a/src/include/c.h b/src/include/c.h
index 757dfff47825d2a043b72147960ab2cd34e18aad..cb8a38669bedbaba00956026f56e9c42e7f2fbf0 100644 (file)
--- a/src/include/c.h
+++ b/src/include/c.h
@@ -1007,29 +1007,29 @@ pg_noreturn extern void ExceptionalCondition(const char *conditionName,
 #define Min(x, y)              ((x) < (y) ? (x) : (y))
 
 
-/* Get a bit mask of the bits set in non-long aligned addresses */
-#define LONG_ALIGN_MASK (sizeof(long) - 1)
+/* Get a bit mask of the bits set in non-size_t aligned addresses */
+#define SIZE_T_ALIGN_MASK (sizeof(size_t) - 1)
 
 /*
  * MemSet
  *     Exactly the same as standard library function memset(), but considerably
- *     faster for zeroing small word-aligned structures (such as parsetree nodes).
- *     This has to be a macro because the main point is to avoid function-call
- *     overhead.   However, we have also found that the loop is faster than
- *     native libc memset() on some platforms, even those with assembler
- *     memset() functions.  More research needs to be done, perhaps with
- *     MEMSET_LOOP_LIMIT tests in configure.
+ *     faster for zeroing small size_t-aligned structures (such as parsetree
+ *     nodes).  This has to be a macro because the main point is to avoid
+ *     function-call overhead.  However, we have also found that the loop is
+ *     faster than native libc memset() on some platforms, even those with
+ *     assembler memset() functions.  More research needs to be done, perhaps
+ *     with MEMSET_LOOP_LIMIT tests in configure.
  */
 #define MemSet(start, val, len) \
        do \
        { \
-               /* must be void* because we don't know if it is integer aligned yet */ \
+               /* must be void* because we don't know if it is size_t aligned yet */ \
                void   *_vstart = (void *) (start); \
                int             _val = (val); \
                Size    _len = (len); \
 \
-               if ((((uintptr_t) _vstart) & LONG_ALIGN_MASK) == 0 && \
-                       (_len & LONG_ALIGN_MASK) == 0 && \
+               if ((((uintptr_t) _vstart) & SIZE_T_ALIGN_MASK) == 0 && \
+                       (_len & SIZE_T_ALIGN_MASK) == 0 && \
                        _val == 0 && \
                        _len <= MEMSET_LOOP_LIMIT && \
                        /* \
@@ -1038,8 +1038,8 @@ pg_noreturn extern void ExceptionalCondition(const char *conditionName,
                         */ \
                        MEMSET_LOOP_LIMIT != 0) \
                { \
-                       long *_start = (long *) _vstart; \
-                       long *_stop = (long *) ((char *) _start + _len); \
+                       size_t *_start = (size_t *) _vstart; \
+                       size_t *_stop = (size_t *) ((char *) _start + _len); \
                        while (_start < _stop) \
                                *_start++ = 0; \
                } \
@@ -1049,23 +1049,23 @@ pg_noreturn extern void ExceptionalCondition(const char *conditionName,
 
 /*
  * MemSetAligned is the same as MemSet except it omits the test to see if
- * "start" is word-aligned.  This is okay to use if the caller knows a-priori
- * that the pointer is suitably aligned (typically, because he just got it
- * from palloc(), which always delivers a max-aligned pointer).
+ * "start" is size_t-aligned.  This is okay to use if the caller knows
+ * a-priori that the pointer is suitably aligned (typically, because he just
+ * got it from palloc(), which always delivers a max-aligned pointer).
  */
 #define MemSetAligned(start, val, len) \
        do \
        { \
-               long   *_start = (long *) (start); \
+               size_t *_start = (size_t *) (start); \
                int             _val = (val); \
                Size    _len = (len); \
 \
-               if ((_len & LONG_ALIGN_MASK) == 0 && \
+               if ((_len & SIZE_T_ALIGN_MASK) == 0 && \
                        _val == 0 && \
                        _len <= MEMSET_LOOP_LIMIT && \
                        MEMSET_LOOP_LIMIT != 0) \
                { \
-                       long *_stop = (long *) ((char *) _start + _len); \
+                       size_t *_stop = (size_t *) ((char *) _start + _len); \
                        while (_start < _stop) \
                                *_start++ = 0; \
                } \