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 <li.evan.chao@gmail.com>
Reviewed-by: Bertrand Drouvot <bertranddrouvot.pg@gmail.com>
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;