Don't rely on pointer arithmetic with Pointer type

The comment for the Pointer type says 'XXX Pointer arithmetic is done
with this, so it can't be void * under "true" ANSI compilers.'.  This
fixes that.  Change from Pointer to use char * explicitly where
pointer arithmetic is needed.  This makes the meaning of the code
clearer locally and removes a dependency on the actual definition of
the Pointer type.  (The definition of the Pointer type is not changed
in this commit.)

Reviewed-by: Chao Li <[email protected]>
Reviewed-by: Bertrand Drouvot <[email protected]>
Discussion: https://www.postgresql.org/message-id/4154950a-47ae-4223-bd01-1235cc50e933%40eisentraut.org

diff --git a/contrib/bloom/bloom.h b/contrib/bloom/bloom.h
index 648167045f4e81bc50ef0142a8ea4b6481be2c8c..b2966d37077fa0f5f24f0cf39d3f7fae90d33aac 100644 (file)
--- a/contrib/bloom/bloom.h
+++ b/contrib/bloom/bloom.h
@@ -72,7 +72,7 @@ typedef BloomPageOpaqueData *BloomPageOpaque;
        ((BloomTuple *)(PageGetContents(page) \
                + (state)->sizeOfBloomTuple * ((offset) - 1)))
 #define BloomPageGetNextTuple(state, tuple) \
-       ((BloomTuple *)((Pointer)(tuple) + (state)->sizeOfBloomTuple))
+       ((BloomTuple *)((char *)(tuple) + (state)->sizeOfBloomTuple))
 
 /* Preserved page numbers */
 #define BLOOM_METAPAGE_BLKNO   (0)

diff --git a/contrib/bloom/blutils.c b/contrib/bloom/blutils.c
index bf50037a71ae566d2eee1af6fa85799262ecf6d8..bbeefc3a75b333038ce5771c3572d9770b706f2a 100644 (file)
--- a/contrib/bloom/blutils.c
+++ b/contrib/bloom/blutils.c
@@ -324,7 +324,7 @@ BloomPageAddItem(BloomState *state, Page page, BloomTuple *tuple)
 {
        BloomTuple *itup;
        BloomPageOpaque opaque;
-       Pointer         ptr;
+       char       *ptr;
 
        /* We shouldn't be pointed to an invalid page */
        Assert(!PageIsNew(page) && !BloomPageIsDeleted(page));
@@ -340,7 +340,7 @@ BloomPageAddItem(BloomState *state, Page page, BloomTuple *tuple)
 
        /* Adjust maxoff and pd_lower */
        opaque->maxoff++;
-       ptr = (Pointer) BloomPageGetTuple(state, page, opaque->maxoff + 1);
+       ptr = (char *) BloomPageGetTuple(state, page, opaque->maxoff + 1);
        ((PageHeader) page)->pd_lower = ptr - page;
 
        /* Assert we didn't overrun available space */

diff --git a/contrib/bloom/blvacuum.c b/contrib/bloom/blvacuum.c
index 920884ca245b1303755dba4f706ec507f01d824d..1485a6a703fd6e68f0f3430e1d4123a7bc00adc8 100644 (file)
--- a/contrib/bloom/blvacuum.c
+++ b/contrib/bloom/blvacuum.c
@@ -121,7 +121,7 @@ blbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
                        if (BloomPageGetMaxOffset(page) == 0)
                                BloomPageSetDeleted(page);
                        /* Adjust pd_lower */
-                       ((PageHeader) page)->pd_lower = (Pointer) itupPtr - page;
+                       ((PageHeader) page)->pd_lower = (char *) itupPtr - page;
                        /* Finish WAL-logging */
                        GenericXLogFinish(gxlogState);
                }

diff --git a/src/backend/access/gin/gindatapage.c b/src/backend/access/gin/gindatapage.c
index ab19a854cd7bef2a817ac8a13ec91bceed507542..8d9e3727c518d70d588df11f31624299f1a01b27 100644 (file)
--- a/src/backend/access/gin/gindatapage.c
+++ b/src/backend/access/gin/gindatapage.c
@@ -140,20 +140,20 @@ GinDataLeafPageGetItems(Page page, int *nitems, ItemPointerData advancePast)
        {
                GinPostingList *seg = GinDataLeafPageGetPostingList(page);
                Size            len = GinDataLeafPageGetPostingListSize(page);
-               Pointer         endptr = ((Pointer) seg) + len;
+               char       *endptr = (char *) seg + len;
                GinPostingList *next;
 
                /* Skip to the segment containing advancePast+1 */
                if (ItemPointerIsValid(&advancePast))
                {
                        next = GinNextPostingListSegment(seg);
-                       while ((Pointer) next < endptr &&
+                       while ((char *) next < endptr &&
                                   ginCompareItemPointers(&next->first, &advancePast) <= 0)
                        {
                                seg = next;
                                next = GinNextPostingListSegment(seg);
                        }
-                       len = endptr - (Pointer) seg;
+                       len = endptr - (char *) seg;
                }
 
                if (len > 0)
@@ -1371,8 +1371,8 @@ disassembleLeaf(Page page)
 {
        disassembledLeaf *leaf;
        GinPostingList *seg;
-       Pointer         segbegin;
-       Pointer         segend;
+       char       *segbegin;
+       char       *segend;
 
        leaf = palloc0(sizeof(disassembledLeaf));
        dlist_init(&leaf->segments);
@@ -1383,9 +1383,9 @@ disassembleLeaf(Page page)
                 * Create a leafSegmentInfo entry for each segment.
                 */
                seg = GinDataLeafPageGetPostingList(page);
-               segbegin = (Pointer) seg;
+               segbegin = (char *) seg;
                segend = segbegin + GinDataLeafPageGetPostingListSize(page);
-               while ((Pointer) seg < segend)
+               while ((char *) seg < segend)
                {
                        leafSegmentInfo *seginfo = palloc(sizeof(leafSegmentInfo));
 
@@ -1779,7 +1779,7 @@ createPostingTree(Relation index, ItemPointerData *items, uint32 nitems,
        Buffer          buffer;
        Page            tmppage;
        Page            page;
-       Pointer         ptr;
+       char       *ptr;
        int                     nrootitems;
        int                     rootsize;
        bool            is_build = (buildStats != NULL);
@@ -1795,7 +1795,7 @@ createPostingTree(Relation index, ItemPointerData *items, uint32 nitems,
         */
        nrootitems = 0;
        rootsize = 0;
-       ptr = (Pointer) GinDataLeafPageGetPostingList(tmppage);
+       ptr = (char *) GinDataLeafPageGetPostingList(tmppage);
        while (nrootitems < nitems)
        {
                GinPostingList *segment;

diff --git a/src/backend/access/gin/ginxlog.c b/src/backend/access/gin/ginxlog.c
index 606741fa396cc209cbe8c0d3f214672cd12f5ef9..34c01a01165c34644f07e89c707a4acf1e422d93 100644 (file)
--- a/src/backend/access/gin/ginxlog.c
+++ b/src/backend/access/gin/ginxlog.c
@@ -119,12 +119,12 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
        int                     actionno;
        int                     segno;
        GinPostingList *oldseg;
-       Pointer         segmentend;
+       char       *segmentend;
        char       *walbuf;
        int                     totalsize;
-       Pointer         tailCopy = NULL;
-       Pointer         writePtr;
-       Pointer         segptr;
+       void       *tailCopy = NULL;
+       char       *writePtr;
+       char       *segptr;
 
        /*
         * If the page is in pre-9.4 format, convert to new format first.
@@ -164,8 +164,8 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
        }
 
        oldseg = GinDataLeafPageGetPostingList(page);
-       writePtr = (Pointer) oldseg;
-       segmentend = (Pointer) oldseg + GinDataLeafPageGetPostingListSize(page);
+       writePtr = (char *) oldseg;
+       segmentend = (char *) oldseg + GinDataLeafPageGetPostingListSize(page);
        segno = 0;
 
        walbuf = ((char *) data) + sizeof(ginxlogRecompressDataLeaf);
@@ -243,7 +243,7 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
                        a_action = GIN_SEGMENT_REPLACE;
                }
 
-               segptr = (Pointer) oldseg;
+               segptr = (char *) oldseg;
                if (segptr != segmentend)
                        segsize = SizeOfGinPostingList(oldseg);
                else
@@ -264,7 +264,7 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
                {
                        int                     tailSize = segmentend - segptr;
 
-                       tailCopy = (Pointer) palloc(tailSize);
+                       tailCopy = palloc(tailSize);
                        memcpy(tailCopy, segptr, tailSize);
                        segptr = tailCopy;
                        oldseg = (GinPostingList *) segptr;
@@ -301,7 +301,7 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
        }
 
        /* Copy the rest of unmodified segments if any. */
-       segptr = (Pointer) oldseg;
+       segptr = (char *) oldseg;
        if (segptr != segmentend && tailCopy)
        {
                int                     restSize = segmentend - segptr;
@@ -311,7 +311,7 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
                writePtr += restSize;
        }
 
-       totalsize = writePtr - (Pointer) GinDataLeafPageGetPostingList(page);
+       totalsize = writePtr - (char *) GinDataLeafPageGetPostingList(page);
        GinDataPageSetDataSize(page, totalsize);
 }
 

diff --git a/src/backend/access/rmgrdesc/genericdesc.c b/src/backend/access/rmgrdesc/genericdesc.c
index 75dc4108b9aa2d51a914535df70f6df1c00f9aa5..29a4c9e894bf5c4802aaa93eeda714d3106b731e 100644 (file)
--- a/src/backend/access/rmgrdesc/genericdesc.c
+++ b/src/backend/access/rmgrdesc/genericdesc.c
@@ -23,8 +23,8 @@
 void
 generic_desc(StringInfo buf, XLogReaderState *record)
 {
-       Pointer         ptr = XLogRecGetData(record),
-                               end = ptr + XLogRecGetDataLen(record);
+       const char *ptr = XLogRecGetData(record);
+       const char *end = ptr + XLogRecGetDataLen(record);
 
        while (ptr < end)
        {

diff --git a/src/backend/utils/adt/multirangetypes.c b/src/backend/utils/adt/multirangetypes.c
index 55e0b4fdc318d5299d79e60a2c5c420e762d6794..e259644c6ca15ebb4df12ba958671d499b1b2a70 100644 (file)
--- a/src/backend/utils/adt/multirangetypes.c
+++ b/src/backend/utils/adt/multirangetypes.c
@@ -68,11 +68,11 @@ typedef enum
  * Macros for accessing past MultirangeType parts of multirange: items, flags
  * and boundaries.
  */
-#define MultirangeGetItemsPtr(mr) ((uint32 *) ((Pointer) (mr) + \
+#define MultirangeGetItemsPtr(mr) ((uint32 *) ((char *) (mr) + \
        sizeof(MultirangeType)))
-#define MultirangeGetFlagsPtr(mr) ((uint8 *) ((Pointer) (mr) + \
+#define MultirangeGetFlagsPtr(mr) ((uint8 *) ((char *) (mr) + \
        sizeof(MultirangeType) + ((mr)->rangeCount - 1) * sizeof(uint32)))
-#define MultirangeGetBoundariesPtr(mr, align) ((Pointer) (mr) + \
+#define MultirangeGetBoundariesPtr(mr, align) ((char *) (mr) + \
        att_align_nominal(sizeof(MultirangeType) + \
                ((mr)->rangeCount - 1) * sizeof(uint32) + \
                (mr)->rangeCount * sizeof(uint8), (align)))
@@ -602,13 +602,13 @@ write_multirange_data(MultirangeType *multirange, TypeCacheEntry *rangetyp,
        uint32          prev_offset = 0;
        uint8      *flags;
        int32           i;
-       Pointer         begin,
-                               ptr;
+       const char *begin;
+       char       *ptr;
        char            elemalign = rangetyp->rngelemtype->typalign;
 
        items = MultirangeGetItemsPtr(multirange);
        flags = MultirangeGetFlagsPtr(multirange);
-       ptr = begin = MultirangeGetBoundariesPtr(multirange, elemalign);
+       begin = ptr = MultirangeGetBoundariesPtr(multirange, elemalign);
        for (i = 0; i < range_count; i++)
        {
                uint32          len;
@@ -627,7 +627,7 @@ write_multirange_data(MultirangeType *multirange, TypeCacheEntry *rangetyp,
                                items[i - 1] |= MULTIRANGE_ITEM_OFF_BIT;
                        prev_offset = ptr - begin;
                }
-               flags[i] = *((Pointer) ranges[i] + VARSIZE(ranges[i]) - sizeof(char));
+               flags[i] = *((char *) ranges[i] + VARSIZE(ranges[i]) - sizeof(char));
                len = VARSIZE(ranges[i]) - sizeof(RangeType) - sizeof(char);
                memcpy(ptr, ranges[i] + 1, len);
                ptr += att_align_nominal(len, elemalign);
@@ -699,8 +699,8 @@ multirange_get_range(TypeCacheEntry *rangetyp,
 {
        uint32          offset;
        uint8           flags;
-       Pointer         begin,
-                               ptr;
+       const char *begin;
+       char       *ptr;
        int16           typlen = rangetyp->rngelemtype->typlen;
        char            typalign = rangetyp->rngelemtype->typalign;
        uint32          len;
@@ -710,7 +710,7 @@ multirange_get_range(TypeCacheEntry *rangetyp,
 
        offset = multirange_get_bounds_offset(multirange, i);
        flags = MultirangeGetFlagsPtr(multirange)[i];
-       ptr = begin = MultirangeGetBoundariesPtr(multirange, typalign) + offset;
+       begin = ptr = MultirangeGetBoundariesPtr(multirange, typalign) + offset;
 
        /*
         * Calculate the size of bound values.  In principle, we could get offset
@@ -719,11 +719,11 @@ multirange_get_range(TypeCacheEntry *rangetyp,
         * exact size.
         */
        if (RANGE_HAS_LBOUND(flags))
-               ptr = (Pointer) att_addlength_pointer(ptr, typlen, ptr);
+               ptr = (char *) att_addlength_pointer(ptr, typlen, ptr);
        if (RANGE_HAS_UBOUND(flags))
        {
-               ptr = (Pointer) att_align_pointer(ptr, typalign, typlen, ptr);
-               ptr = (Pointer) att_addlength_pointer(ptr, typlen, ptr);
+               ptr = (char *) att_align_pointer(ptr, typalign, typlen, ptr);
+               ptr = (char *) att_addlength_pointer(ptr, typlen, ptr);
        }
        len = (ptr - begin) + sizeof(RangeType) + sizeof(uint8);
 
@@ -749,7 +749,7 @@ multirange_get_bounds(TypeCacheEntry *rangetyp,
 {
        uint32          offset;
        uint8           flags;
-       Pointer         ptr;
+       const char *ptr;
        int16           typlen = rangetyp->rngelemtype->typlen;
        char            typalign = rangetyp->rngelemtype->typalign;
        bool            typbyval = rangetyp->rngelemtype->typbyval;
@@ -770,7 +770,7 @@ multirange_get_bounds(TypeCacheEntry *rangetyp,
        {
                /* att_align_pointer cannot be necessary here */
                lbound = fetch_att(ptr, typbyval, typlen);
-               ptr = (Pointer) att_addlength_pointer(ptr, typlen, ptr);
+               ptr = (char *) att_addlength_pointer(ptr, typlen, ptr);
        }
        else
                lbound = (Datum) 0;
@@ -778,7 +778,7 @@ multirange_get_bounds(TypeCacheEntry *rangetyp,
        /* fetch upper bound, if any */
        if (RANGE_HAS_UBOUND(flags))
        {
-               ptr = (Pointer) att_align_pointer(ptr, typalign, typlen, ptr);
+               ptr = (char *) att_align_pointer(ptr, typalign, typlen, ptr);
                ubound = fetch_att(ptr, typbyval, typlen);
                /* no need for att_addlength_pointer */
        }

diff --git a/src/backend/utils/adt/rangetypes.c b/src/backend/utils/adt/rangetypes.c
index 065a8000cf2992f81549e9df68d516f9f5880b8d..b7e9f6dc0a8ebf1a25e3358be5dbec5a758161f5 100644 (file)
--- a/src/backend/utils/adt/rangetypes.c
+++ b/src/backend/utils/adt/rangetypes.c
@@ -72,8 +72,8 @@ static char *range_deparse(char flags, const char *lbound_str,
 static char *range_bound_escape(const char *value);
 static Size datum_compute_size(Size data_length, Datum val, bool typbyval,
                                                           char typalign, int16 typlen, char typstorage);
-static Pointer datum_write(Pointer ptr, Datum datum, bool typbyval,
-                                                  char typalign, int16 typlen, char typstorage);
+static char *datum_write(char *ptr, Datum datum, bool typbyval,
+                                                char typalign, int16 typlen, char typstorage);
 static Node *find_simplified_clause(PlannerInfo *root,
                                                                        Expr *rangeExpr, Expr *elemExpr);
 static Expr *build_bound_expr(Expr *elemExpr, Datum val,
@@ -2092,7 +2092,7 @@ range_deserialize(TypeCacheEntry *typcache, const RangeType *range,
        int16           typlen;
        bool            typbyval;
        char            typalign;
-       Pointer         ptr;
+       const char *ptr;
        Datum           lbound;
        Datum           ubound;
 
@@ -2108,14 +2108,14 @@ range_deserialize(TypeCacheEntry *typcache, const RangeType *range,
        typalign = typcache->rngelemtype->typalign;
 
        /* initialize data pointer just after the range OID */
-       ptr = (Pointer) (range + 1);
+       ptr = (char *) (range + 1);
 
        /* fetch lower bound, if any */
        if (RANGE_HAS_LBOUND(flags))
        {
                /* att_align_pointer cannot be necessary here */
                lbound = fetch_att(ptr, typbyval, typlen);
-               ptr = (Pointer) att_addlength_pointer(ptr, typlen, ptr);
+               ptr = (char *) att_addlength_pointer(ptr, typlen, ptr);
        }
        else
                lbound = (Datum) 0;
@@ -2123,7 +2123,7 @@ range_deserialize(TypeCacheEntry *typcache, const RangeType *range,
        /* fetch upper bound, if any */
        if (RANGE_HAS_UBOUND(flags))
        {
-               ptr = (Pointer) att_align_pointer(ptr, typalign, typlen, ptr);
+               ptr = (char *) att_align_pointer(ptr, typalign, typlen, ptr);
                ubound = fetch_att(ptr, typbyval, typlen);
                /* no need for att_addlength_pointer */
        }
@@ -2937,8 +2937,8 @@ datum_compute_size(Size data_length, Datum val, bool typbyval, char typalign,
  * Write the given datum beginning at ptr (after advancing to correct
  * alignment, if needed).  Return the pointer incremented by space used.
  */
-static Pointer
-datum_write(Pointer ptr, Datum datum, bool typbyval, char typalign,
+static char *
+datum_write(char *ptr, Datum datum, bool typbyval, char typalign,
                        int16 typlen, char typstorage)
 {
        Size            data_length;