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

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)

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 */

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);
 		}

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;

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);
 }
 

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)
 	{

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 */
 	}

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;