database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-12-09 02:08:45 +03:00
Code Activity

Don't rely on pointer arithmetic with Pointer type

Browse Source 
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
This commit is contained in:
Peter Eisentraut
2025-12-03 09:54:15 +01:00
parent 8c6bbd674e
commit 756a436893
8 changed files with 49 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
contrib/bloom/bloom.h
View File

@@ -72,7 +72,7 @@ typedef BloomPageOpaqueData *BloomPageOpaque;
((BloomTuple *)(PageGetContents(page) \ ((BloomTuple *)(PageGetContents(page) \
+ (state)->sizeOfBloomTuple * ((offset) - 1))) + (state)->sizeOfBloomTuple * ((offset) - 1)))
#define BloomPageGetNextTuple(state, tuple) \ #define BloomPageGetNextTuple(state, tuple) \
((BloomTuple *)((Pointer)(tuple) + (state)->sizeOfBloomTuple)) ((BloomTuple *)((char *)(tuple) + (state)->sizeOfBloomTuple))
/* Preserved page numbers */ /* Preserved page numbers */
#define BLOOM_METAPAGE_BLKNO (0) #define BLOOM_METAPAGE_BLKNO (0)

4
contrib/bloom/blutils.c
View File

@@ -324,7 +324,7 @@ BloomPageAddItem(BloomState *state, Page page, BloomTuple *tuple)
{ {
BloomTuple *itup; BloomTuple *itup;
BloomPageOpaque opaque; BloomPageOpaque opaque;
Pointer ptr; char *ptr;
/* We shouldn't be pointed to an invalid page */ /* We shouldn't be pointed to an invalid page */
Assert(!PageIsNew(page) && !BloomPageIsDeleted(page)); Assert(!PageIsNew(page) && !BloomPageIsDeleted(page));
@@ -340,7 +340,7 @@ BloomPageAddItem(BloomState *state, Page page, BloomTuple *tuple)
/* Adjust maxoff and pd_lower */ /* Adjust maxoff and pd_lower */
opaque->maxoff++; opaque->maxoff++;
ptr = (Pointer) BloomPageGetTuple(state, page, opaque->maxoff + 1); ptr = (char *) BloomPageGetTuple(state, page, opaque->maxoff + 1);
((PageHeader) page)->pd_lower = ptr - page; ((PageHeader) page)->pd_lower = ptr - page;
/* Assert we didn't overrun available space */ /* Assert we didn't overrun available space */

2
contrib/bloom/blvacuum.c
View File

@@ -121,7 +121,7 @@ blbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
if (BloomPageGetMaxOffset(page) == 0) if (BloomPageGetMaxOffset(page) == 0)
BloomPageSetDeleted(page); BloomPageSetDeleted(page);
/* Adjust pd_lower */ /* Adjust pd_lower */
((PageHeader) page)->pd_lower = (Pointer) itupPtr - page; ((PageHeader) page)->pd_lower = (char *) itupPtr - page;
/* Finish WAL-logging */ /* Finish WAL-logging */
GenericXLogFinish(gxlogState); GenericXLogFinish(gxlogState);
} }

18
src/backend/access/gin/gindatapage.c
View File

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

20
src/backend/access/gin/ginxlog.c
View File

@@ -119,12 +119,12 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
int actionno; int actionno;
int segno; int segno;
GinPostingList *oldseg; GinPostingList *oldseg;
Pointer segmentend; char *segmentend;
char *walbuf; char *walbuf;
int totalsize; int totalsize;
Pointer tailCopy = NULL; void *tailCopy = NULL;
Pointer writePtr; char *writePtr;
Pointer segptr; char *segptr;
/* /*
* If the page is in pre-9.4 format, convert to new format first. * 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); oldseg = GinDataLeafPageGetPostingList(page);
writePtr = (Pointer) oldseg; writePtr = (char *) oldseg;
segmentend = (Pointer) oldseg + GinDataLeafPageGetPostingListSize(page); segmentend = (char *) oldseg + GinDataLeafPageGetPostingListSize(page);
segno = 0; segno = 0;
walbuf = ((char *) data) + sizeof(ginxlogRecompressDataLeaf); walbuf = ((char *) data) + sizeof(ginxlogRecompressDataLeaf);
@@ -243,7 +243,7 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
a_action = GIN_SEGMENT_REPLACE; a_action = GIN_SEGMENT_REPLACE;
} }
segptr = (Pointer) oldseg; segptr = (char *) oldseg;
if (segptr != segmentend) if (segptr != segmentend)
segsize = SizeOfGinPostingList(oldseg); segsize = SizeOfGinPostingList(oldseg);
else else
@@ -264,7 +264,7 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
{ {
int tailSize = segmentend - segptr; int tailSize = segmentend - segptr;
tailCopy = (Pointer) palloc(tailSize); tailCopy = palloc(tailSize);
memcpy(tailCopy, segptr, tailSize); memcpy(tailCopy, segptr, tailSize);
segptr = tailCopy; segptr = tailCopy;
oldseg = (GinPostingList *) segptr; oldseg = (GinPostingList *) segptr;
@@ -301,7 +301,7 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
} }
/* Copy the rest of unmodified segments if any. */ /* Copy the rest of unmodified segments if any. */
segptr = (Pointer) oldseg; segptr = (char *) oldseg;
if (segptr != segmentend && tailCopy) if (segptr != segmentend && tailCopy)
{ {
int restSize = segmentend - segptr; int restSize = segmentend - segptr;
@@ -311,7 +311,7 @@ ginRedoRecompress(Page page, ginxlogRecompressDataLeaf *data)
writePtr += restSize; writePtr += restSize;
} }
totalsize = writePtr - (Pointer) GinDataLeafPageGetPostingList(page); totalsize = writePtr - (char *) GinDataLeafPageGetPostingList(page);
GinDataPageSetDataSize(page, totalsize); GinDataPageSetDataSize(page, totalsize);
} }

4
src/backend/access/rmgrdesc/genericdesc.c
View File

@@ -23,8 +23,8 @@
void void
generic_desc(StringInfo buf, XLogReaderState *record) generic_desc(StringInfo buf, XLogReaderState *record)
{ {
Pointer ptr = XLogRecGetData(record), const char *ptr = XLogRecGetData(record);
end = ptr + XLogRecGetDataLen(record); const char *end = ptr + XLogRecGetDataLen(record);
while (ptr < end) while (ptr < end)
{ {

32
src/backend/utils/adt/multirangetypes.c
View File

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

14
src/backend/utils/adt/rangetypes.c
View File

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