Remove useless casts to (char *)

From 70d7fe7de4a504ece6c8289960a2014d960d7450 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dagfinn=20Ilmari=20Manns=C3=A5ker?= <ilmari@ilmari.org>
Date: Thu, 6 Feb 2025 11:46:08 +0000
Subject: [PATCH] Make TLS write functions' buffe arguments pointers to const

---
 src/backend/libpq/be-secure-openssl.c | 2 +-
 src/backend/libpq/be-secure.c         | 2 +-
 src/backend/libpq/pqcomm.c            | 2 +-
 src/include/libpq/libpq-be.h          | 2 +-
 src/include/libpq/libpq.h             | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/backend/libpq/be-secure-openssl.c b/src/backend/libpq/be-secure-openssl.c
index abf67bb1b27..64ff3ce3d6a 100644
--- a/src/backend/libpq/be-secure-openssl.c
+++ b/src/backend/libpq/be-secure-openssl.c
@@ -821,7 +821,7 @@ be_tls_read(Port *port, void *ptr, size_t len, int *waitfor)
 }
 
 ssize_t
-be_tls_write(Port *port, void *ptr, size_t len, int *waitfor)
+be_tls_write(Port *port, const void *ptr, size_t len, int *waitfor)
 {
 	ssize_t		n;
 	int			err;
diff --git a/src/backend/libpq/be-secure.c b/src/backend/libpq/be-secure.c
index 3b4f80146be..91576f94285 100644
--- a/src/backend/libpq/be-secure.c
+++ b/src/backend/libpq/be-secure.c
@@ -302,7 +302,7 @@ secure_raw_read(Port *port, void *ptr, size_t len)
  *	Write data to a secure connection.
  */
 ssize_t
-secure_write(Port *port, void *ptr, size_t len)
+secure_write(Port *port, const void *ptr, size_t len)
 {
 	ssize_t		n;
 	int			waitfor;
diff --git a/src/backend/libpq/pqcomm.c b/src/backend/libpq/pqcomm.c
index 1bf27d93cfa..bddd6465de2 100644
--- a/src/backend/libpq/pqcomm.c
+++ b/src/backend/libpq/pqcomm.c
@@ -1368,7 +1368,7 @@ internal_flush_buffer(const char *buf, size_t *start, size_t *end)
 	{
 		int			r;
 
-		r = secure_write(MyProcPort, (char *) bufptr, bufend - bufptr);
+		r = secure_write(MyProcPort, bufptr, bufend - bufptr);
 
 		if (r <= 0)
 		{
diff --git a/src/include/libpq/libpq-be.h b/src/include/libpq/libpq-be.h
index 2f6c29200ba..3247088676a 100644
--- a/src/include/libpq/libpq-be.h
+++ b/src/include/libpq/libpq-be.h
@@ -312,7 +312,7 @@ extern ssize_t be_tls_read(Port *port, void *ptr, size_t len, int *waitfor);
 /*
  * Write data to a secure connection.
  */
-extern ssize_t be_tls_write(Port *port, void *ptr, size_t len, int *waitfor);
+extern ssize_t be_tls_write(Port *port, const void *ptr, size_t len, int *waitfor);
 
 /*
  * Return information about the SSL connection.
diff --git a/src/include/libpq/libpq.h b/src/include/libpq/libpq.h
index 13d8143a893..8defcb6de19 100644
--- a/src/include/libpq/libpq.h
+++ b/src/include/libpq/libpq.h
@@ -92,7 +92,7 @@ extern void secure_destroy(void);
 extern int	secure_open_server(Port *port);
 extern void secure_close(Port *port);
 extern ssize_t secure_read(Port *port, void *ptr, size_t len);
-extern ssize_t secure_write(Port *port, void *ptr, size_t len);
+extern ssize_t secure_write(Port *port, const void *ptr, size_t len);
 extern ssize_t secure_raw_read(Port *port, void *ptr, size_t len);
 extern ssize_t secure_raw_write(Port *port, const void *ptr, size_t len);
 
-- 
2.48.1

From 3a1a7ad7e04c4c8460d5a5aea1a235527d2dc453 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Tue, 24 Sep 2024 12:03:13 +0200
Subject: [PATCH v2 01/10] Remove unnecessary (char *) casts [string]

Remove (char *) casts around string functions where the arguments or
result already have the right type and the cast is useless (or worse,
potentially casts away a qualifier, but this doesn't appear to be the
case here).
---
 contrib/fuzzystrmatch/dmetaphone.c          |  8 ++++----
 doc/src/sgml/gist.sgml                      |  2 +-
 src/backend/replication/walreceiver.c       | 14 +++++++-------
 src/backend/replication/walreceiverfuncs.c  |  4 ++--
 src/backend/utils/activity/backend_status.c |  6 +++---
 src/interfaces/ecpg/pgtypeslib/common.c     |  2 +-
 6 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/contrib/fuzzystrmatch/dmetaphone.c b/contrib/fuzzystrmatch/dmetaphone.c
index f8f2c2b447d..6627b2b8943 100644
--- a/contrib/fuzzystrmatch/dmetaphone.c
+++ b/contrib/fuzzystrmatch/dmetaphone.c
@@ -308,13 +308,13 @@ IsVowel(metastring *s, int pos)
 static int
 SlavoGermanic(metastring *s)
 {
-	if ((char *) strstr(s->str, "W"))
+	if (strstr(s->str, "W"))
 		return 1;
-	else if ((char *) strstr(s->str, "K"))
+	else if (strstr(s->str, "K"))
 		return 1;
-	else if ((char *) strstr(s->str, "CZ"))
+	else if (strstr(s->str, "CZ"))
 		return 1;
-	else if ((char *) strstr(s->str, "WITZ"))
+	else if (strstr(s->str, "WITZ"))
 		return 1;
 	else
 		return 0;
diff --git a/doc/src/sgml/gist.sgml b/doc/src/sgml/gist.sgml
index 99098ab2522..df4afaa2e77 100644
--- a/doc/src/sgml/gist.sgml
+++ b/doc/src/sgml/gist.sgml
@@ -1027,7 +1027,7 @@ <title>Extensibility</title>
     int     len = strlen(tmp);
 
     if (ptr)
-        strcpy((char *) ptr, tmp);
+        strcpy(ptr, tmp);
 
     pfree(tmp);
     return len + 1;
diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
index 716092f717c..bd09262e27d 100644
--- a/src/backend/replication/walreceiver.c
+++ b/src/backend/replication/walreceiver.c
@@ -249,8 +249,8 @@ WalReceiverMain(char *startup_data, size_t startup_data_len)
 
 	/* Fetch information required to start streaming */
 	walrcv->ready_to_display = false;
-	strlcpy(conninfo, (char *) walrcv->conninfo, MAXCONNINFO);
-	strlcpy(slotname, (char *) walrcv->slotname, NAMEDATALEN);
+	strlcpy(conninfo, walrcv->conninfo, MAXCONNINFO);
+	strlcpy(slotname, walrcv->slotname, NAMEDATALEN);
 	is_temp_slot = walrcv->is_temp_slot;
 	startpoint = walrcv->receiveStart;
 	startpointTLI = walrcv->receiveStartTLI;
@@ -317,11 +317,11 @@ WalReceiverMain(char *startup_data, size_t startup_data_len)
 	SpinLockAcquire(&walrcv->mutex);
 	memset(walrcv->conninfo, 0, MAXCONNINFO);
 	if (tmp_conninfo)
-		strlcpy((char *) walrcv->conninfo, tmp_conninfo, MAXCONNINFO);
+		strlcpy(walrcv->conninfo, tmp_conninfo, MAXCONNINFO);
 
 	memset(walrcv->sender_host, 0, NI_MAXHOST);
 	if (sender_host)
-		strlcpy((char *) walrcv->sender_host, sender_host, NI_MAXHOST);
+		strlcpy(walrcv->sender_host, sender_host, NI_MAXHOST);
 
 	walrcv->sender_port = sender_port;
 	walrcv->ready_to_display = true;
@@ -1434,10 +1434,10 @@ pg_stat_get_wal_receiver(PG_FUNCTION_ARGS)
 	last_receipt_time = WalRcv->lastMsgReceiptTime;
 	latest_end_lsn = WalRcv->latestWalEnd;
 	latest_end_time = WalRcv->latestWalEndTime;
-	strlcpy(slotname, (char *) WalRcv->slotname, sizeof(slotname));
-	strlcpy(sender_host, (char *) WalRcv->sender_host, sizeof(sender_host));
+	strlcpy(slotname, WalRcv->slotname, sizeof(slotname));
+	strlcpy(sender_host, WalRcv->sender_host, sizeof(sender_host));
 	sender_port = WalRcv->sender_port;
-	strlcpy(conninfo, (char *) WalRcv->conninfo, sizeof(conninfo));
+	strlcpy(conninfo, WalRcv->conninfo, sizeof(conninfo));
 	SpinLockRelease(&WalRcv->mutex);
 
 	/*
diff --git a/src/backend/replication/walreceiverfuncs.c b/src/backend/replication/walreceiverfuncs.c
index e7eb3ac12a4..8de2886ff0b 100644
--- a/src/backend/replication/walreceiverfuncs.c
+++ b/src/backend/replication/walreceiverfuncs.c
@@ -267,7 +267,7 @@ RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr, const char *conninfo,
 		   walrcv->walRcvState == WALRCV_WAITING);
 
 	if (conninfo != NULL)
-		strlcpy((char *) walrcv->conninfo, conninfo, MAXCONNINFO);
+		strlcpy(walrcv->conninfo, conninfo, MAXCONNINFO);
 	else
 		walrcv->conninfo[0] = '\0';
 
@@ -279,7 +279,7 @@ RequestXLogStreaming(TimeLineID tli, XLogRecPtr recptr, const char *conninfo,
 	 */
 	if (slotname != NULL && slotname[0] != '\0')
 	{
-		strlcpy((char *) walrcv->slotname, slotname, NAMEDATALEN);
+		strlcpy(walrcv->slotname, slotname, NAMEDATALEN);
 		walrcv->is_temp_slot = false;
 	}
 	else
diff --git a/src/backend/utils/activity/backend_status.c b/src/backend/utils/activity/backend_status.c
index 731342799a6..ae8e54c7442 100644
--- a/src/backend/utils/activity/backend_status.c
+++ b/src/backend/utils/activity/backend_status.c
@@ -795,11 +795,11 @@ pgstat_read_current_status(void)
 				 * strcpy is safe even if the string is modified concurrently,
 				 * because there's always a \0 at the end of the buffer.
 				 */
-				strcpy(localappname, (char *) beentry->st_appname);
+				strcpy(localappname, beentry->st_appname);
 				localentry->backendStatus.st_appname = localappname;
-				strcpy(localclienthostname, (char *) beentry->st_clienthostname);
+				strcpy(localclienthostname, beentry->st_clienthostname);
 				localentry->backendStatus.st_clienthostname = localclienthostname;
-				strcpy(localactivity, (char *) beentry->st_activity_raw);
+				strcpy(localactivity, beentry->st_activity_raw);
 				localentry->backendStatus.st_activity_raw = localactivity;
 #ifdef USE_SSL
 				if (beentry->st_ssl)
diff --git a/src/interfaces/ecpg/pgtypeslib/common.c b/src/interfaces/ecpg/pgtypeslib/common.c
index 8972229ca2f..c9e9a55c6a7 100644
--- a/src/interfaces/ecpg/pgtypeslib/common.c
+++ b/src/interfaces/ecpg/pgtypeslib/common.c
@@ -19,7 +19,7 @@ pgtypes_alloc(long size)
 char *
 pgtypes_strdup(const char *str)
 {
-	char	   *new = (char *) strdup(str);
+	char	   *new = strdup(str);
 
 	if (!new)
 		errno = ENOMEM;

base-commit: a9258629edabd461f998ec7d06cdf554e8a6a6ec
-- 
2.48.1

From 7757101a4f339739ea1d3f59fc154e887960c915 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Sun, 29 Sep 2024 00:08:48 +0200
Subject: [PATCH v2 02/10] Remove unnecessary (char *) casts [mem]

Remove (char *) casts around memory functions such as memcmp(),
memcpy(), or memset() where the cast is useless.  Since these
functions don't take (char *) arguments anyway, these casts are at
best complicated casts to (void *), about which see commit
7f798aca1d5.
---
 contrib/pg_trgm/trgm_gist.c                 |  6 +++---
 contrib/xml2/xpath.c                        |  4 ++--
 src/backend/access/common/heaptuple.c       |  6 +++---
 src/backend/access/heap/heapam_xlog.c       | 12 ++++++------
 src/backend/access/table/toast_helper.c     |  2 +-
 src/backend/access/transam/xlog.c           |  2 +-
 src/backend/access/transam/xlogreader.c     |  2 +-
 src/backend/bootstrap/bootstrap.c           |  4 ++--
 src/backend/libpq/be-secure-gssapi.c        |  2 +-
 src/backend/replication/logical/decode.c    |  8 ++------
 src/backend/storage/buffer/bufmgr.c         |  2 +-
 src/backend/storage/buffer/localbuf.c       |  2 +-
 src/backend/storage/file/fd.c               |  4 ++--
 src/backend/storage/page/bufpage.c          |  8 ++++----
 src/backend/tcop/postgres.c                 |  4 ++--
 src/backend/utils/activity/backend_status.c |  4 ++--
 src/interfaces/ecpg/compatlib/informix.c    |  2 +-
 src/interfaces/ecpg/ecpglib/misc.c          | 14 +++++++-------
 src/interfaces/libpq/fe-lobj.c              |  2 +-
 src/interfaces/libpq/fe-secure-gssapi.c     |  2 +-
 20 files changed, 44 insertions(+), 48 deletions(-)

diff --git a/contrib/pg_trgm/trgm_gist.c b/contrib/pg_trgm/trgm_gist.c
index 7f482f958fd..14285a919ad 100644
--- a/contrib/pg_trgm/trgm_gist.c
+++ b/contrib/pg_trgm/trgm_gist.c
@@ -228,7 +228,7 @@ gtrgm_consistent(PG_FUNCTION_ARGS)
 	if (cache == NULL ||
 		cache->strategy != strategy ||
 		VARSIZE(cache->query) != querysize ||
-		memcmp((char *) cache->query, (char *) query, querysize) != 0)
+		memcmp(cache->query, query, querysize) != 0)
 	{
 		gtrgm_consistent_cache *newcache;
 		TrgmPackedGraph *graph = NULL;
@@ -284,12 +284,12 @@ gtrgm_consistent(PG_FUNCTION_ARGS)
 		newcache->strategy = strategy;
 		newcache->query = (text *)
 			((char *) newcache + MAXALIGN(sizeof(gtrgm_consistent_cache)));
-		memcpy((char *) newcache->query, (char *) query, querysize);
+		memcpy(newcache->query, query, querysize);
 		if (qtrg)
 		{
 			newcache->trigrams = (TRGM *)
 				((char *) newcache->query + MAXALIGN(querysize));
-			memcpy((char *) newcache->trigrams, (char *) qtrg, qtrgsize);
+			memcpy((char *) newcache->trigrams, qtrg, qtrgsize);
 			/* release qtrg in case it was made in fn_mcxt */
 			pfree(qtrg);
 		}
diff --git a/contrib/xml2/xpath.c b/contrib/xml2/xpath.c
index f7e3f485fe1..19180b9a6c2 100644
--- a/contrib/xml2/xpath.c
+++ b/contrib/xml2/xpath.c
@@ -278,8 +278,8 @@ xpath_string(PG_FUNCTION_ARGS)
 	/* We could try casting to string using the libxml function? */
 
 	xpath = (xmlChar *) palloc(pathsize + 9);
-	memcpy((char *) xpath, "string(", 7);
-	memcpy((char *) (xpath + 7), VARDATA_ANY(xpathsupp), pathsize);
+	memcpy(xpath, "string(", 7);
+	memcpy(xpath + 7, VARDATA_ANY(xpathsupp), pathsize);
 	xpath[pathsize + 7] = ')';
 	xpath[pathsize + 8] = '\0';
 
diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c
index b43cb9ccff4..acd5da4ccf8 100644
--- a/src/backend/access/common/heaptuple.c
+++ b/src/backend/access/common/heaptuple.c
@@ -787,7 +787,7 @@ heap_copytuple(HeapTuple tuple)
 	newTuple->t_self = tuple->t_self;
 	newTuple->t_tableOid = tuple->t_tableOid;
 	newTuple->t_data = (HeapTupleHeader) ((char *) newTuple + HEAPTUPLESIZE);
-	memcpy((char *) newTuple->t_data, (char *) tuple->t_data, tuple->t_len);
+	memcpy(newTuple->t_data, tuple->t_data, tuple->t_len);
 	return newTuple;
 }
 
@@ -813,7 +813,7 @@ heap_copytuple_with_tuple(HeapTuple src, HeapTuple dest)
 	dest->t_self = src->t_self;
 	dest->t_tableOid = src->t_tableOid;
 	dest->t_data = (HeapTupleHeader) palloc(src->t_len);
-	memcpy((char *) dest->t_data, (char *) src->t_data, src->t_len);
+	memcpy(dest->t_data, src->t_data, src->t_len);
 }
 
 /*
@@ -1097,7 +1097,7 @@ heap_copy_tuple_as_datum(HeapTuple tuple, TupleDesc tupleDesc)
 	 * the given tuple came from disk, rather than from heap_form_tuple).
 	 */
 	td = (HeapTupleHeader) palloc(tuple->t_len);
-	memcpy((char *) td, (char *) tuple->t_data, tuple->t_len);
+	memcpy(td, tuple->t_data, tuple->t_len);
 
 	HeapTupleHeaderSetDatumLength(td, tuple->t_len);
 	HeapTupleHeaderSetTypeId(td, tupleDesc->tdtypeid);
diff --git a/src/backend/access/heap/heapam_xlog.c b/src/backend/access/heap/heapam_xlog.c
index 469d11d5912..30f4c2d3c67 100644
--- a/src/backend/access/heap/heapam_xlog.c
+++ b/src/backend/access/heap/heapam_xlog.c
@@ -480,11 +480,11 @@ heap_xlog_insert(XLogReaderState *record)
 
 		newlen = datalen - SizeOfHeapHeader;
 		Assert(datalen > SizeOfHeapHeader && newlen <= MaxHeapTupleSize);
-		memcpy((char *) &xlhdr, data, SizeOfHeapHeader);
+		memcpy(&xlhdr, data, SizeOfHeapHeader);
 		data += SizeOfHeapHeader;
 
 		htup = &tbuf.hdr;
-		MemSet((char *) htup, 0, SizeofHeapTupleHeader);
+		MemSet(htup, 0, SizeofHeapTupleHeader);
 		/* PG73FORMAT: get bitmap [+ padding] [+ oid] + data */
 		memcpy((char *) htup + SizeofHeapTupleHeader,
 			   data,
@@ -625,10 +625,10 @@ heap_xlog_multi_insert(XLogReaderState *record)
 			newlen = xlhdr->datalen;
 			Assert(newlen <= MaxHeapTupleSize);
 			htup = &tbuf.hdr;
-			MemSet((char *) htup, 0, SizeofHeapTupleHeader);
+			MemSet(htup, 0, SizeofHeapTupleHeader);
 			/* PG73FORMAT: get bitmap [+ padding] [+ oid] + data */
 			memcpy((char *) htup + SizeofHeapTupleHeader,
-				   (char *) tupdata,
+				   tupdata,
 				   newlen);
 			tupdata += newlen;
 
@@ -854,14 +854,14 @@ heap_xlog_update(XLogReaderState *record, bool hot_update)
 			recdata += sizeof(uint16);
 		}
 
-		memcpy((char *) &xlhdr, recdata, SizeOfHeapHeader);
+		memcpy(&xlhdr, recdata, SizeOfHeapHeader);
 		recdata += SizeOfHeapHeader;
 
 		tuplen = recdata_end - recdata;
 		Assert(tuplen <= MaxHeapTupleSize);
 
 		htup = &tbuf.hdr;
-		MemSet((char *) htup, 0, SizeofHeapTupleHeader);
+		MemSet(htup, 0, SizeofHeapTupleHeader);
 
 		/*
 		 * Reconstruct the new tuple using the prefix and/or suffix from the
diff --git a/src/backend/access/table/toast_helper.c b/src/backend/access/table/toast_helper.c
index c63052f96eb..b60fab0a4d2 100644
--- a/src/backend/access/table/toast_helper.c
+++ b/src/backend/access/table/toast_helper.c
@@ -75,7 +75,7 @@ toast_tuple_init(ToastTupleContext *ttc)
 			{
 				if (ttc->ttc_isnull[i] ||
 					!VARATT_IS_EXTERNAL_ONDISK(new_value) ||
-					memcmp((char *) old_value, (char *) new_value,
+					memcmp(old_value, new_value,
 						   VARSIZE_EXTERNAL(old_value)) != 0)
 				{
 					/*
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 9c270e7d466..fd389565123 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -2089,7 +2089,7 @@ AdvanceXLInsertBuffer(XLogRecPtr upto, TimeLineID tli, bool opportunistic)
 		 * Be sure to re-zero the buffer so that bytes beyond what we've
 		 * written will look like zeroes and not valid XLOG records...
 		 */
-		MemSet((char *) NewPage, 0, XLOG_BLCKSZ);
+		MemSet(NewPage, 0, XLOG_BLCKSZ);
 
 		/*
 		 * Fill the new page's header
diff --git a/src/backend/access/transam/xlogreader.c b/src/backend/access/transam/xlogreader.c
index 6cf5ef90be0..31bffc6f501 100644
--- a/src/backend/access/transam/xlogreader.c
+++ b/src/backend/access/transam/xlogreader.c
@@ -794,7 +794,7 @@ XLogDecodeNextRecord(XLogReaderState *state, bool nonblocking)
 				readOff = ReadPageInternal(state, targetPagePtr,
 										   pageHeaderSize + len);
 
-			memcpy(buffer, (char *) contdata, len);
+			memcpy(buffer, contdata, len);
 			buffer += len;
 			gotlen += len;
 
diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c
index 359f58a8f95..6db864892d0 100644
--- a/src/backend/bootstrap/bootstrap.c
+++ b/src/backend/bootstrap/bootstrap.c
@@ -463,8 +463,8 @@ boot_openrel(char *relname)
 	{
 		if (attrtypes[i] == NULL)
 			attrtypes[i] = AllocateAttribute();
-		memmove((char *) attrtypes[i],
-				(char *) TupleDescAttr(boot_reldesc->rd_att, i),
+		memmove(attrtypes[i],
+				TupleDescAttr(boot_reldesc->rd_att, i),
 				ATTRIBUTE_FIXED_PART_SIZE);
 
 		{
diff --git a/src/backend/libpq/be-secure-gssapi.c b/src/backend/libpq/be-secure-gssapi.c
index fc5a8d82a9d..a3d610b1373 100644
--- a/src/backend/libpq/be-secure-gssapi.c
+++ b/src/backend/libpq/be-secure-gssapi.c
@@ -641,7 +641,7 @@ secure_open_gssapi(Port *port)
 				return -1;
 			}
 
-			memcpy(PqGSSSendBuffer, (char *) &netlen, sizeof(uint32));
+			memcpy(PqGSSSendBuffer, &netlen, sizeof(uint32));
 			PqGSSSendLength += sizeof(uint32);
 
 			memcpy(PqGSSSendBuffer + PqGSSSendLength, output.value, output.length);
diff --git a/src/backend/replication/logical/decode.c b/src/backend/replication/logical/decode.c
index 0bff0f10652..24d88f368d8 100644
--- a/src/backend/replication/logical/decode.c
+++ b/src/backend/replication/logical/decode.c
@@ -1177,9 +1177,7 @@ DecodeMultiInsert(LogicalDecodingContext *ctx, XLogRecordBuffer *buf)
 
 		memset(header, 0, SizeofHeapTupleHeader);
 
-		memcpy((char *) tuple->t_data + SizeofHeapTupleHeader,
-			   (char *) data,
-			   datalen);
+		memcpy((char *) tuple->t_data + SizeofHeapTupleHeader, data, datalen);
 		header->t_infomask = xlhdr->t_infomask;
 		header->t_infomask2 = xlhdr->t_infomask2;
 		header->t_hoff = xlhdr->t_hoff;
@@ -1265,9 +1263,7 @@ DecodeXLogTuple(char *data, Size len, HeapTuple tuple)
 	tuple->t_tableOid = InvalidOid;
 
 	/* data is not stored aligned, copy to aligned storage */
-	memcpy((char *) &xlhdr,
-		   data,
-		   SizeOfHeapHeader);
+	memcpy(&xlhdr, data, SizeOfHeapHeader);
 
 	memset(header, 0, SizeofHeapTupleHeader);
 
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index ee83669992b..b5938f1b473 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -2221,7 +2221,7 @@ ExtendBufferedRelShared(BufferManagerRelation bmr,
 		buf_block = BufHdrGetBlock(GetBufferDescriptor(buffers[i] - 1));
 
 		/* new buffers are zero-filled */
-		MemSet((char *) buf_block, 0, BLCKSZ);
+		MemSet(buf_block, 0, BLCKSZ);
 	}
 
 	/*
diff --git a/src/backend/storage/buffer/localbuf.c b/src/backend/storage/buffer/localbuf.c
index 8f81428970b..64931efaa75 100644
--- a/src/backend/storage/buffer/localbuf.c
+++ b/src/backend/storage/buffer/localbuf.c
@@ -338,7 +338,7 @@ ExtendBufferedRelLocal(BufferManagerRelation bmr,
 		buf_block = LocalBufHdrGetBlock(buf_hdr);
 
 		/* new buffers are zero-filled */
-		MemSet((char *) buf_block, 0, BLCKSZ);
+		MemSet(buf_block, 0, BLCKSZ);
 	}
 
 	first_block = smgrnblocks(bmr.smgr, fork);
diff --git a/src/backend/storage/file/fd.c b/src/backend/storage/file/fd.c
index 843d1021cf9..e454db4c020 100644
--- a/src/backend/storage/file/fd.c
+++ b/src/backend/storage/file/fd.c
@@ -910,7 +910,7 @@ InitFileAccess(void)
 				(errcode(ERRCODE_OUT_OF_MEMORY),
 				 errmsg("out of memory")));
 
-	MemSet((char *) &(VfdCache[0]), 0, sizeof(Vfd));
+	MemSet(&(VfdCache[0]), 0, sizeof(Vfd));
 	VfdCache->fd = VFD_CLOSED;
 
 	SizeVfdCache = 1;
@@ -1447,7 +1447,7 @@ AllocateVfd(void)
 		 */
 		for (i = SizeVfdCache; i < newCacheSize; i++)
 		{
-			MemSet((char *) &(VfdCache[i]), 0, sizeof(Vfd));
+			MemSet(&(VfdCache[i]), 0, sizeof(Vfd));
 			VfdCache[i].nextFree = i + 1;
 			VfdCache[i].fd = VFD_CLOSED;
 		}
diff --git a/src/backend/storage/page/bufpage.c b/src/backend/storage/page/bufpage.c
index a931cdba151..424dd3f4bfb 100644
--- a/src/backend/storage/page/bufpage.c
+++ b/src/backend/storage/page/bufpage.c
@@ -415,7 +415,7 @@ PageRestoreTempPage(Page tempPage, Page oldPage)
 	Size		pageSize;
 
 	pageSize = PageGetPageSize(tempPage);
-	memcpy((char *) oldPage, (char *) tempPage, pageSize);
+	memcpy(oldPage, tempPage, pageSize);
 
 	pfree(tempPage);
 }
@@ -1094,8 +1094,8 @@ PageIndexTupleDelete(Page page, OffsetNumber offnum)
 		((char *) &phdr->pd_linp[offidx + 1] - (char *) phdr);
 
 	if (nbytes > 0)
-		memmove((char *) &(phdr->pd_linp[offidx]),
-				(char *) &(phdr->pd_linp[offidx + 1]),
+		memmove(&(phdr->pd_linp[offidx]),
+				&(phdr->pd_linp[offidx + 1]),
 				nbytes);
 
 	/*
@@ -1516,7 +1516,7 @@ PageSetChecksumCopy(Page page, BlockNumber blkno)
 											 PG_IO_ALIGN_SIZE,
 											 0);
 
-	memcpy(pageCopy, (char *) page, BLCKSZ);
+	memcpy(pageCopy, page, BLCKSZ);
 	((PageHeader) pageCopy)->pd_checksum = pg_checksum_page(pageCopy, blkno);
 	return pageCopy;
 }
diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c
index 5655348a2e2..1149d89d7a1 100644
--- a/src/backend/tcop/postgres.c
+++ b/src/backend/tcop/postgres.c
@@ -4991,8 +4991,8 @@ ShowUsage(const char *title)
 
 	getrusage(RUSAGE_SELF, &r);
 	gettimeofday(&elapse_t, NULL);
-	memcpy((char *) &user, (char *) &r.ru_utime, sizeof(user));
-	memcpy((char *) &sys, (char *) &r.ru_stime, sizeof(sys));
+	memcpy(&user, &r.ru_utime, sizeof(user));
+	memcpy(&sys, &r.ru_stime, sizeof(sys));
 	if (elapse_t.tv_usec < Save_t.tv_usec)
 	{
 		elapse_t.tv_sec--;
diff --git a/src/backend/utils/activity/backend_status.c b/src/backend/utils/activity/backend_status.c
index ae8e54c7442..5f68ef26adc 100644
--- a/src/backend/utils/activity/backend_status.c
+++ b/src/backend/utils/activity/backend_status.c
@@ -597,7 +597,7 @@ pgstat_report_activity(BackendState state, const char *cmd_str)
 
 	if (cmd_str != NULL)
 	{
-		memcpy((char *) beentry->st_activity_raw, cmd_str, len);
+		memcpy(beentry->st_activity_raw, cmd_str, len);
 		beentry->st_activity_raw[len] = '\0';
 		beentry->st_activity_start_timestamp = start_timestamp;
 	}
@@ -670,7 +670,7 @@ pgstat_report_appname(const char *appname)
 	 */
 	PGSTAT_BEGIN_WRITE_ACTIVITY(beentry);
 
-	memcpy((char *) beentry->st_appname, appname, len);
+	memcpy(beentry->st_appname, appname, len);
 	beentry->st_appname[len] = '\0';
 
 	PGSTAT_END_WRITE_ACTIVITY(beentry);
diff --git a/src/interfaces/ecpg/compatlib/informix.c b/src/interfaces/ecpg/compatlib/informix.c
index 65a0b2e46c4..e829d722f22 100644
--- a/src/interfaces/ecpg/compatlib/informix.c
+++ b/src/interfaces/ecpg/compatlib/informix.c
@@ -1035,7 +1035,7 @@ ECPG_informix_reset_sqlca(void)
 	if (sqlca == NULL)
 		return;
 
-	memcpy((char *) sqlca, (char *) &sqlca_init, sizeof(struct sqlca_t));
+	memcpy(sqlca, &sqlca_init, sizeof(struct sqlca_t));
 }
 
 int
diff --git a/src/interfaces/ecpg/ecpglib/misc.c b/src/interfaces/ecpg/ecpglib/misc.c
index 8b38c3eccfd..1885732a652 100644
--- a/src/interfaces/ecpg/ecpglib/misc.c
+++ b/src/interfaces/ecpg/ecpglib/misc.c
@@ -66,7 +66,7 @@ static FILE *debugstream = NULL;
 void
 ecpg_init_sqlca(struct sqlca_t *sqlca)
 {
-	memcpy((char *) sqlca, (char *) &sqlca_init, sizeof(struct sqlca_t));
+	memcpy(sqlca, &sqlca_init, sizeof(struct sqlca_t));
 }
 
 bool
@@ -316,10 +316,10 @@ ECPGset_noind_null(enum ECPGttype type, void *ptr)
 			*((long long *) ptr) = LONG_LONG_MIN;
 			break;
 		case ECPGt_float:
-			memset((char *) ptr, 0xff, sizeof(float));
+			memset(ptr, 0xff, sizeof(float));
 			break;
 		case ECPGt_double:
-			memset((char *) ptr, 0xff, sizeof(double));
+			memset(ptr, 0xff, sizeof(double));
 			break;
 		case ECPGt_varchar:
 			*(((struct ECPGgeneric_varchar *) ptr)->arr) = 0x00;
@@ -329,18 +329,18 @@ ECPGset_noind_null(enum ECPGttype type, void *ptr)
 			((struct ECPGgeneric_bytea *) ptr)->len = 0;
 			break;
 		case ECPGt_decimal:
-			memset((char *) ptr, 0, sizeof(decimal));
+			memset(ptr, 0, sizeof(decimal));
 			((decimal *) ptr)->sign = NUMERIC_NULL;
 			break;
 		case ECPGt_numeric:
-			memset((char *) ptr, 0, sizeof(numeric));
+			memset(ptr, 0, sizeof(numeric));
 			((numeric *) ptr)->sign = NUMERIC_NULL;
 			break;
 		case ECPGt_interval:
-			memset((char *) ptr, 0xff, sizeof(interval));
+			memset(ptr, 0xff, sizeof(interval));
 			break;
 		case ECPGt_timestamp:
-			memset((char *) ptr, 0xff, sizeof(timestamp));
+			memset(ptr, 0xff, sizeof(timestamp));
 			break;
 		default:
 			break;
diff --git a/src/interfaces/libpq/fe-lobj.c b/src/interfaces/libpq/fe-lobj.c
index 45edbae6717..04b3aef8854 100644
--- a/src/interfaces/libpq/fe-lobj.c
+++ b/src/interfaces/libpq/fe-lobj.c
@@ -870,7 +870,7 @@ lo_initialize(PGconn *conn)
 		libpq_append_conn_error(conn, "out of memory");
 		return -1;
 	}
-	MemSet((char *) lobjfuncs, 0, sizeof(PGlobjfuncs));
+	MemSet(lobjfuncs, 0, sizeof(PGlobjfuncs));
 
 	/*
 	 * Execute the query to get all the functions at once.  (Not all of them
diff --git a/src/interfaces/libpq/fe-secure-gssapi.c b/src/interfaces/libpq/fe-secure-gssapi.c
index 190a8894ff0..ce183bc04b4 100644
--- a/src/interfaces/libpq/fe-secure-gssapi.c
+++ b/src/interfaces/libpq/fe-secure-gssapi.c
@@ -698,7 +698,7 @@ pqsecure_open_gss(PGconn *conn)
 	/* Queue the token for writing */
 	netlen = pg_hton32(output.length);
 
-	memcpy(PqGSSSendBuffer, (char *) &netlen, sizeof(uint32));
+	memcpy(PqGSSSendBuffer, &netlen, sizeof(uint32));
 	PqGSSSendLength += sizeof(uint32);
 
 	memcpy(PqGSSSendBuffer + PqGSSSendLength, output.value, output.length);
-- 
2.48.1

From c8074f6b0c4275cb1be4ecc490b0ef977162a0f5 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Tue, 24 Sep 2024 12:20:38 +0200
Subject: [PATCH v2 03/10] Remove unnecessary (char *) casts [checksum]

Remove some (char *) casts related to uses of the pg_checksum_page()
function.  These casts are useless, because everything involved
already has the right type.  Moreover, these casts actually silently
discarded a const qualifier.  The declaration of a higher-level
function needs to be adjusted to fix that.
---
 contrib/pageinspect/rawpage.c      | 2 +-
 src/backend/storage/page/bufpage.c | 6 +++---
 src/include/storage/bufpage.h      | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/contrib/pageinspect/rawpage.c b/contrib/pageinspect/rawpage.c
index 20a04438da5..617dff821a6 100644
--- a/contrib/pageinspect/rawpage.c
+++ b/contrib/pageinspect/rawpage.c
@@ -357,7 +357,7 @@ page_checksum_internal(PG_FUNCTION_ARGS, enum pageinspect_version ext_version)
 	if (PageIsNew(page))
 		PG_RETURN_NULL();
 
-	PG_RETURN_INT16(pg_checksum_page((char *) page, blkno));
+	PG_RETURN_INT16(pg_checksum_page(page, blkno));
 }
 
 Datum
diff --git a/src/backend/storage/page/bufpage.c b/src/backend/storage/page/bufpage.c
index 424dd3f4bfb..91da73dda8b 100644
--- a/src/backend/storage/page/bufpage.c
+++ b/src/backend/storage/page/bufpage.c
@@ -85,7 +85,7 @@ PageInit(Page page, Size pageSize, Size specialSize)
  * to pgstat.
  */
 bool
-PageIsVerifiedExtended(const PageData *page, BlockNumber blkno, int flags)
+PageIsVerifiedExtended(PageData *page, BlockNumber blkno, int flags)
 {
 	const PageHeaderData *p = (const PageHeaderData *) page;
 	size_t	   *pagebytes;
@@ -100,7 +100,7 @@ PageIsVerifiedExtended(const PageData *page, BlockNumber blkno, int flags)
 	{
 		if (DataChecksumsEnabled())
 		{
-			checksum = pg_checksum_page((char *) page, blkno);
+			checksum = pg_checksum_page(page, blkno);
 
 			if (checksum != p->pd_checksum)
 				checksum_failure = true;
@@ -1534,5 +1534,5 @@ PageSetChecksumInplace(Page page, BlockNumber blkno)
 	if (PageIsNew(page) || !DataChecksumsEnabled())
 		return;
 
-	((PageHeader) page)->pd_checksum = pg_checksum_page((char *) page, blkno);
+	((PageHeader) page)->pd_checksum = pg_checksum_page(page, blkno);
 }
diff --git a/src/include/storage/bufpage.h b/src/include/storage/bufpage.h
index d06208b7ce6..6646b6f6371 100644
--- a/src/include/storage/bufpage.h
+++ b/src/include/storage/bufpage.h
@@ -489,7 +489,7 @@ StaticAssertDecl(BLCKSZ == ((BLCKSZ / sizeof(size_t)) * sizeof(size_t)),
 				 "BLCKSZ has to be a multiple of sizeof(size_t)");
 
 extern void PageInit(Page page, Size pageSize, Size specialSize);
-extern bool PageIsVerifiedExtended(const PageData *page, BlockNumber blkno, int flags);
+extern bool PageIsVerifiedExtended(PageData *page, BlockNumber blkno, int flags);
 extern OffsetNumber PageAddItemExtended(Page page, Item item, Size size,
 										OffsetNumber offsetNumber, int flags);
 extern Page PageGetTempPage(const PageData *page);
-- 
2.48.1

From 094fedb6340f66ef30a0ee0128b9e41dfc0a5a38 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Thu, 19 Dec 2024 23:41:23 +0100
Subject: [PATCH v2 04/10] Remove various unnecessary (char *) casts

Remove a number of (char *) casts that are unnecessary.  Or in some
cases, rewrite the code to make the purpose of the cast clearer.
---
 contrib/ltree/ltxtquery_io.c             |  2 +-
 contrib/pg_trgm/trgm_gist.c              | 10 +++++-----
 contrib/postgres_fdw/postgres_fdw.c      |  8 ++++----
 src/backend/access/transam/xlog.c        |  4 ++--
 src/backend/libpq/auth.c                 |  8 +++++---
 src/backend/nodes/copyfuncs.c            |  2 +-
 src/backend/nodes/makefuncs.c            |  2 +-
 src/backend/storage/page/bufpage.c       |  2 +-
 src/backend/utils/cache/relmapper.c      |  4 ++--
 src/backend/utils/error/jsonlog.c        |  2 +-
 src/bin/pg_basebackup/pg_receivewal.c    |  2 +-
 src/bin/pg_dump/compress_gzip.c          |  2 +-
 src/bin/pg_rewind/pg_rewind.c            |  2 +-
 src/bin/psql/describe.c                  |  2 +-
 src/common/controldata_utils.c           |  4 ++--
 src/interfaces/ecpg/ecpglib/descriptor.c |  4 ++--
 src/interfaces/ecpg/ecpglib/execute.c    |  2 +-
 src/interfaces/ecpg/pgtypeslib/numeric.c |  4 ++--
 18 files changed, 34 insertions(+), 32 deletions(-)

diff --git a/contrib/ltree/ltxtquery_io.c b/contrib/ltree/ltxtquery_io.c
index 7b8fba17ff2..ec331607793 100644
--- a/contrib/ltree/ltxtquery_io.c
+++ b/contrib/ltree/ltxtquery_io.c
@@ -410,7 +410,7 @@ ltxtq_in(PG_FUNCTION_ARGS)
 {
 	ltxtquery  *res;
 
-	if ((res = queryin((char *) PG_GETARG_POINTER(0), fcinfo->context)) == NULL)
+	if ((res = queryin(PG_GETARG_POINTER(0), fcinfo->context)) == NULL)
 		PG_RETURN_NULL();
 	PG_RETURN_POINTER(res);
 }
diff --git a/contrib/pg_trgm/trgm_gist.c b/contrib/pg_trgm/trgm_gist.c
index 14285a919ad..5ba895217b0 100644
--- a/contrib/pg_trgm/trgm_gist.c
+++ b/contrib/pg_trgm/trgm_gist.c
@@ -106,7 +106,7 @@ makesign(BITVECP sign, TRGM *a, int siglen)
 	SETBIT(sign, SIGLENBIT(siglen));	/* set last unused bit */
 	for (k = 0; k < len; k++)
 	{
-		CPTRGM(((char *) &tmp), ptr + k);
+		CPTRGM(&tmp, ptr + k);
 		HASH(sign, tmp, siglen);
 	}
 }
@@ -186,7 +186,7 @@ cnt_sml_sign_common(TRGM *qtrg, BITVECP sign, int siglen)
 
 	for (k = 0; k < len; k++)
 	{
-		CPTRGM(((char *) &tmp), ptr + k);
+		CPTRGM(&tmp, ptr + k);
 		count += GETBIT(sign, HASHVAL(tmp, siglen));
 	}
 
@@ -373,7 +373,7 @@ gtrgm_consistent(PG_FUNCTION_ARGS)
 				res = true;
 				for (k = 0; k < len; k++)
 				{
-					CPTRGM(((char *) &tmp), ptr + k);
+					CPTRGM(&tmp, ptr + k);
 					if (!GETBIT(sign, HASHVAL(tmp, siglen)))
 					{
 						res = false;
@@ -426,7 +426,7 @@ gtrgm_consistent(PG_FUNCTION_ARGS)
 					check = (bool *) palloc(len * sizeof(bool));
 					for (k = 0; k < len; k++)
 					{
-						CPTRGM(((char *) &tmp), ptr + k);
+						CPTRGM(&tmp, ptr + k);
 						check[k] = GETBIT(sign, HASHVAL(tmp, siglen));
 					}
 					res = trigramsMatchGraph(cache->graph, check);
@@ -552,7 +552,7 @@ unionkey(BITVECP sbase, TRGM *add, int siglen)
 
 		for (i = 0; i < ARRNELEM(add); i++)
 		{
-			CPTRGM(((char *) &tmp), ptr + i);
+			CPTRGM(&tmp, ptr + i);
 			HASH(sbase, tmp, siglen);
 		}
 	}
diff --git a/contrib/postgres_fdw/postgres_fdw.c b/contrib/postgres_fdw/postgres_fdw.c
index b92e2a0fc9f..de43727a2a0 100644
--- a/contrib/postgres_fdw/postgres_fdw.c
+++ b/contrib/postgres_fdw/postgres_fdw.c
@@ -5660,13 +5660,13 @@ postgresImportForeignSchema(ImportForeignSchemaStmt *stmt, Oid serverOid)
 				attname = PQgetvalue(res, i, 1);
 				typename = PQgetvalue(res, i, 2);
 				attnotnull = PQgetvalue(res, i, 3);
-				attdefault = PQgetisnull(res, i, 4) ? (char *) NULL :
+				attdefault = PQgetisnull(res, i, 4) ? NULL :
 					PQgetvalue(res, i, 4);
-				attgenerated = PQgetisnull(res, i, 5) ? (char *) NULL :
+				attgenerated = PQgetisnull(res, i, 5) ? NULL :
 					PQgetvalue(res, i, 5);
-				collname = PQgetisnull(res, i, 6) ? (char *) NULL :
+				collname = PQgetisnull(res, i, 6) ? NULL :
 					PQgetvalue(res, i, 6);
-				collnamespace = PQgetisnull(res, i, 7) ? (char *) NULL :
+				collnamespace = PQgetisnull(res, i, 7) ? NULL :
 					PQgetvalue(res, i, 7);
 
 				if (first_item)
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index fd389565123..124676b460a 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -4287,7 +4287,7 @@ WriteControlFile(void)
 	/* Contents are protected with a CRC */
 	INIT_CRC32C(ControlFile->crc);
 	COMP_CRC32C(ControlFile->crc,
-				(char *) ControlFile,
+				ControlFile,
 				offsetof(ControlFileData, crc));
 	FIN_CRC32C(ControlFile->crc);
 
@@ -4405,7 +4405,7 @@ ReadControlFile(void)
 	/* Now check the CRC. */
 	INIT_CRC32C(crc);
 	COMP_CRC32C(crc,
-				(char *) ControlFile,
+				ControlFile,
 				offsetof(ControlFileData, crc));
 	FIN_CRC32C(crc);
 
diff --git a/src/backend/libpq/auth.c b/src/backend/libpq/auth.c
index d6ef32cc823..7884fb1df0c 100644
--- a/src/backend/libpq/auth.c
+++ b/src/backend/libpq/auth.c
@@ -2926,8 +2926,8 @@ PerformRadiusTransaction(const char *server, const char *secret, const char *por
 	radius_packet radius_recv_pack;
 	radius_packet *packet = &radius_send_pack;
 	radius_packet *receivepacket = &radius_recv_pack;
-	char	   *radius_buffer = (char *) &radius_send_pack;
-	char	   *receive_buffer = (char *) &radius_recv_pack;
+	void	   *radius_buffer = &radius_send_pack;
+	void	   *receive_buffer = &radius_recv_pack;
 	int32		service = pg_hton32(RADIUS_AUTHENTICATE_ONLY);
 	uint8	   *cryptvector;
 	int			encryptedpasswordlen;
@@ -3198,7 +3198,9 @@ PerformRadiusTransaction(const char *server, const char *secret, const char *por
 																		 * original packet */
 		if (packetlength > RADIUS_HEADER_LENGTH)	/* there may be no
 													 * attributes at all */
-			memcpy(cryptvector + RADIUS_HEADER_LENGTH, receive_buffer + RADIUS_HEADER_LENGTH, packetlength - RADIUS_HEADER_LENGTH);
+			memcpy(cryptvector + RADIUS_HEADER_LENGTH,
+				   (char *) receive_buffer + RADIUS_HEADER_LENGTH,
+				   packetlength - RADIUS_HEADER_LENGTH);
 		memcpy(cryptvector + packetlength, secret, strlen(secret));
 
 		if (!pg_md5_binary(cryptvector,
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 45915767825..475693b08bc 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -40,7 +40,7 @@
 
 /* Copy a field that is a pointer to a C string, or perhaps NULL */
 #define COPY_STRING_FIELD(fldname) \
-	(newnode->fldname = from->fldname ? pstrdup(from->fldname) : (char *) NULL)
+	(newnode->fldname = from->fldname ? pstrdup(from->fldname) : NULL)
 
 /* Copy a field that is an inline array */
 #define COPY_ARRAY_FIELD(fldname) \
diff --git a/src/backend/nodes/makefuncs.c b/src/backend/nodes/makefuncs.c
index 007612563ca..dbbc2f1e30d 100644
--- a/src/backend/nodes/makefuncs.c
+++ b/src/backend/nodes/makefuncs.c
@@ -51,7 +51,7 @@ makeSimpleA_Expr(A_Expr_Kind kind, char *name,
 	A_Expr	   *a = makeNode(A_Expr);
 
 	a->kind = kind;
-	a->name = list_make1(makeString((char *) name));
+	a->name = list_make1(makeString(name));
 	a->lexpr = lexpr;
 	a->rexpr = rexpr;
 	a->location = location;
diff --git a/src/backend/storage/page/bufpage.c b/src/backend/storage/page/bufpage.c
index 91da73dda8b..ecc81aacfc3 100644
--- a/src/backend/storage/page/bufpage.c
+++ b/src/backend/storage/page/bufpage.c
@@ -1502,7 +1502,7 @@ PageSetChecksumCopy(Page page, BlockNumber blkno)
 
 	/* If we don't need a checksum, just return the passed-in data */
 	if (PageIsNew(page) || !DataChecksumsEnabled())
-		return (char *) page;
+		return page;
 
 	/*
 	 * We allocate the copy space once and use it over on each subsequent
diff --git a/src/backend/utils/cache/relmapper.c b/src/backend/utils/cache/relmapper.c
index 1e72a2c7fd6..30f968cd9cf 100644
--- a/src/backend/utils/cache/relmapper.c
+++ b/src/backend/utils/cache/relmapper.c
@@ -854,7 +854,7 @@ read_relmap_file(RelMapFile *map, char *dbpath, bool lock_held, int elevel)
 
 	/* verify the CRC */
 	INIT_CRC32C(crc);
-	COMP_CRC32C(crc, (char *) map, offsetof(RelMapFile, crc));
+	COMP_CRC32C(crc, map, offsetof(RelMapFile, crc));
 	FIN_CRC32C(crc);
 
 	if (!EQ_CRC32C(crc, map->crc))
@@ -910,7 +910,7 @@ write_relmap_file(RelMapFile *newmap, bool write_wal, bool send_sinval,
 		elog(ERROR, "attempt to write bogus relation mapping");
 
 	INIT_CRC32C(newmap->crc);
-	COMP_CRC32C(newmap->crc, (char *) newmap, offsetof(RelMapFile, crc));
+	COMP_CRC32C(newmap->crc, newmap, offsetof(RelMapFile, crc));
 	FIN_CRC32C(newmap->crc);
 
 	/*
diff --git a/src/backend/utils/error/jsonlog.c b/src/backend/utils/error/jsonlog.c
index 6533f1d6888..549e0f48ee8 100644
--- a/src/backend/utils/error/jsonlog.c
+++ b/src/backend/utils/error/jsonlog.c
@@ -206,7 +206,7 @@ write_jsonlog(ErrorData *edata)
 	/* Error severity */
 	if (edata->elevel)
 		appendJSONKeyValue(&buf, "error_severity",
-						   (char *) error_severity(edata->elevel), true);
+						   error_severity(edata->elevel), true);
 
 	/* SQL state code */
 	if (edata->sqlerrcode)
diff --git a/src/bin/pg_basebackup/pg_receivewal.c b/src/bin/pg_basebackup/pg_receivewal.c
index 176c40facad..de3584018b0 100644
--- a/src/bin/pg_basebackup/pg_receivewal.c
+++ b/src/bin/pg_basebackup/pg_receivewal.c
@@ -342,7 +342,7 @@ FindStreamingStart(uint32 *tli)
 			if (lseek(fd, (off_t) (-4), SEEK_END) < 0)
 				pg_fatal("could not seek in compressed file \"%s\": %m",
 						 fullpath);
-			r = read(fd, (char *) buf, sizeof(buf));
+			r = read(fd, buf, sizeof(buf));
 			if (r != sizeof(buf))
 			{
 				if (r < 0)
diff --git a/src/bin/pg_dump/compress_gzip.c b/src/bin/pg_dump/compress_gzip.c
index f9e5f00aaa1..23f617209e6 100644
--- a/src/bin/pg_dump/compress_gzip.c
+++ b/src/bin/pg_dump/compress_gzip.c
@@ -129,7 +129,7 @@ DeflateCompressorCommon(ArchiveHandle *AH, CompressorState *cs, bool flush)
 				 */
 				size_t		len = gzipcs->outsize - zp->avail_out;
 
-				cs->writeF(AH, (char *) out, len);
+				cs->writeF(AH, out, len);
 			}
 			zp->next_out = out;
 			zp->avail_out = gzipcs->outsize;
diff --git a/src/bin/pg_rewind/pg_rewind.c b/src/bin/pg_rewind/pg_rewind.c
index cae81cd6cb1..2ce99d06d1d 100644
--- a/src/bin/pg_rewind/pg_rewind.c
+++ b/src/bin/pg_rewind/pg_rewind.c
@@ -1007,7 +1007,7 @@ checkControlFile(ControlFileData *ControlFile)
 
 	/* Calculate CRC */
 	INIT_CRC32C(crc);
-	COMP_CRC32C(crc, (char *) ControlFile, offsetof(ControlFileData, crc));
+	COMP_CRC32C(crc, ControlFile, offsetof(ControlFileData, crc));
 	FIN_CRC32C(crc);
 
 	/* And simply compare it */
diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c
index 3b7ba66fad0..e6cf468ac9e 100644
--- a/src/bin/psql/describe.c
+++ b/src/bin/psql/describe.c
@@ -1741,7 +1741,7 @@ describeOneTableDetails(const char *schemaname,
 		*(PQgetvalue(res, 0, 13)) : 'd';
 	if (pset.sversion >= 120000)
 		tableinfo.relam = PQgetisnull(res, 0, 14) ?
-			(char *) NULL : pg_strdup(PQgetvalue(res, 0, 14));
+			NULL : pg_strdup(PQgetvalue(res, 0, 14));
 	else
 		tableinfo.relam = NULL;
 	PQclear(res);
diff --git a/src/common/controldata_utils.c b/src/common/controldata_utils.c
index 27ce27d7647..34d8a3a4e31 100644
--- a/src/common/controldata_utils.c
+++ b/src/common/controldata_utils.c
@@ -135,7 +135,7 @@ get_controlfile_by_exact_path(const char *ControlFilePath, bool *crc_ok_p)
 	/* Check the CRC. */
 	INIT_CRC32C(crc);
 	COMP_CRC32C(crc,
-				(char *) ControlFile,
+				ControlFile,
 				offsetof(ControlFileData, crc));
 	FIN_CRC32C(crc);
 
@@ -199,7 +199,7 @@ update_controlfile(const char *DataDir,
 	/* Recalculate CRC of control file */
 	INIT_CRC32C(ControlFile->crc);
 	COMP_CRC32C(ControlFile->crc,
-				(char *) ControlFile,
+				ControlFile,
 				offsetof(ControlFileData, crc));
 	FIN_CRC32C(ControlFile->crc);
 
diff --git a/src/interfaces/ecpg/ecpglib/descriptor.c b/src/interfaces/ecpg/ecpglib/descriptor.c
index 8525a6812f2..651d5c8b2ed 100644
--- a/src/interfaces/ecpg/ecpglib/descriptor.c
+++ b/src/interfaces/ecpg/ecpglib/descriptor.c
@@ -198,7 +198,7 @@ get_char_item(int lineno, void *var, enum ECPGttype vartype, char *value, int va
 		case ECPGt_char:
 		case ECPGt_unsigned_char:
 		case ECPGt_string:
-			strncpy((char *) var, value, varcharsize);
+			strncpy(var, value, varcharsize);
 			break;
 		case ECPGt_varchar:
 			{
@@ -597,7 +597,7 @@ set_desc_attr(struct descriptor_item *desc_item, struct variable *var,
 	}
 
 	ecpg_free(desc_item->data); /* free() takes care of a potential NULL value */
-	desc_item->data = (char *) tobeinserted;
+	desc_item->data = tobeinserted;
 }
 
 
diff --git a/src/interfaces/ecpg/ecpglib/execute.c b/src/interfaces/ecpg/ecpglib/execute.c
index b5089eac787..f52da06de9a 100644
--- a/src/interfaces/ecpg/ecpglib/execute.c
+++ b/src/interfaces/ecpg/ecpglib/execute.c
@@ -278,7 +278,7 @@ ecpg_is_type_an_array(int type, const struct statement *stmt, const struct varia
 			isarray = ECPG_ARRAY_NONE;
 		else
 		{
-			isarray = (atoi((char *) PQgetvalue(query, 0, 0)) == -1) ? ECPG_ARRAY_ARRAY : ECPG_ARRAY_VECTOR;
+			isarray = (atoi(PQgetvalue(query, 0, 0)) == -1) ? ECPG_ARRAY_ARRAY : ECPG_ARRAY_VECTOR;
 			if (ecpg_dynamic_type(type) == SQL3_CHARACTER ||
 				ecpg_dynamic_type(type) == SQL3_CHARACTER_VARYING)
 			{
diff --git a/src/interfaces/ecpg/pgtypeslib/numeric.c b/src/interfaces/ecpg/pgtypeslib/numeric.c
index 35e7b92da40..bb2a86981ca 100644
--- a/src/interfaces/ecpg/pgtypeslib/numeric.c
+++ b/src/interfaces/ecpg/pgtypeslib/numeric.c
@@ -232,7 +232,7 @@ get_str_from_var(numeric *var, int dscale)
 
 	if (var->sign == NUMERIC_NAN)
 	{
-		str = (char *) pgtypes_alloc(4);
+		str = pgtypes_alloc(4);
 		if (str == NULL)
 			return NULL;
 		sprintf(str, "NaN");
@@ -269,7 +269,7 @@ get_str_from_var(numeric *var, int dscale)
 	/*
 	 * Allocate space for the result
 	 */
-	if ((str = (char *) pgtypes_alloc(Max(0, dscale) + Max(0, var->weight) + 4)) == NULL)
+	if ((str = pgtypes_alloc(Max(0, dscale) + Max(0, var->weight) + 4)) == NULL)
 		return NULL;
 	cp = str;
 
-- 
2.48.1

From eac3e17df81428dac00efa0ef3086cf25813f8d3 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Tue, 24 Sep 2024 12:26:48 +0200
Subject: [PATCH v2 05/10] backend launchers void * arguments for binary data

Change backend launcher functions to take void * for binary data
instead of char *.  This removes the need for numerous casts.
---
 src/backend/postmaster/autovacuum.c         |  4 ++--
 src/backend/postmaster/bgworker.c           |  2 +-
 src/backend/postmaster/bgwriter.c           |  2 +-
 src/backend/postmaster/checkpointer.c       |  2 +-
 src/backend/postmaster/launch_backend.c     | 20 ++++++++++----------
 src/backend/postmaster/pgarch.c             |  2 +-
 src/backend/postmaster/postmaster.c         |  4 ++--
 src/backend/postmaster/startup.c            |  2 +-
 src/backend/postmaster/syslogger.c          |  6 +++---
 src/backend/postmaster/walsummarizer.c      |  2 +-
 src/backend/postmaster/walwriter.c          |  2 +-
 src/backend/replication/logical/slotsync.c  |  2 +-
 src/backend/replication/walreceiver.c       |  2 +-
 src/backend/tcop/backend_startup.c          |  4 ++--
 src/include/postmaster/autovacuum.h         |  4 ++--
 src/include/postmaster/bgworker_internals.h |  2 +-
 src/include/postmaster/bgwriter.h           |  4 ++--
 src/include/postmaster/pgarch.h             |  2 +-
 src/include/postmaster/postmaster.h         |  2 +-
 src/include/postmaster/startup.h            |  2 +-
 src/include/postmaster/syslogger.h          |  2 +-
 src/include/postmaster/walsummarizer.h      |  2 +-
 src/include/postmaster/walwriter.h          |  2 +-
 src/include/replication/slotsync.h          |  2 +-
 src/include/replication/walreceiver.h       |  2 +-
 src/include/tcop/backend_startup.h          |  2 +-
 26 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c
index 09ec9bb6990..4d21578c0cd 100644
--- a/src/backend/postmaster/autovacuum.c
+++ b/src/backend/postmaster/autovacuum.c
@@ -364,7 +364,7 @@ static void check_av_worker_gucs(void);
  * Main entry point for the autovacuum launcher process.
  */
 void
-AutoVacLauncherMain(char *startup_data, size_t startup_data_len)
+AutoVacLauncherMain(const void *startup_data, size_t startup_data_len)
 {
 	sigjmp_buf	local_sigjmp_buf;
 
@@ -1371,7 +1371,7 @@ avl_sigusr2_handler(SIGNAL_ARGS)
  * Main entry point for autovacuum worker processes.
  */
 void
-AutoVacWorkerMain(char *startup_data, size_t startup_data_len)
+AutoVacWorkerMain(const void *startup_data, size_t startup_data_len)
 {
 	sigjmp_buf	local_sigjmp_buf;
 	Oid			dbid;
diff --git a/src/backend/postmaster/bgworker.c b/src/backend/postmaster/bgworker.c
index b288915cec8..116ddf7b835 100644
--- a/src/backend/postmaster/bgworker.c
+++ b/src/backend/postmaster/bgworker.c
@@ -714,7 +714,7 @@ bgworker_die(SIGNAL_ARGS)
  * Main entry point for background worker processes.
  */
 void
-BackgroundWorkerMain(char *startup_data, size_t startup_data_len)
+BackgroundWorkerMain(const void *startup_data, size_t startup_data_len)
 {
 	sigjmp_buf	local_sigjmp_buf;
 	BackgroundWorker *worker;
diff --git a/src/backend/postmaster/bgwriter.c b/src/backend/postmaster/bgwriter.c
index 3eff5dc6f0e..64524d1831b 100644
--- a/src/backend/postmaster/bgwriter.c
+++ b/src/backend/postmaster/bgwriter.c
@@ -84,7 +84,7 @@ static XLogRecPtr last_snapshot_lsn = InvalidXLogRecPtr;
  * basic execution environment, but not enabled signals yet.
  */
 void
-BackgroundWriterMain(char *startup_data, size_t startup_data_len)
+BackgroundWriterMain(const void *startup_data, size_t startup_data_len)
 {
 	sigjmp_buf	local_sigjmp_buf;
 	MemoryContext bgwriter_context;
diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c
index b94f9cdff21..7acbbd3e267 100644
--- a/src/backend/postmaster/checkpointer.c
+++ b/src/backend/postmaster/checkpointer.c
@@ -175,7 +175,7 @@ static void ReqShutdownXLOG(SIGNAL_ARGS);
  * basic execution environment, but not enabled signals yet.
  */
 void
-CheckpointerMain(char *startup_data, size_t startup_data_len)
+CheckpointerMain(const void *startup_data, size_t startup_data_len)
 {
 	sigjmp_buf	local_sigjmp_buf;
 	MemoryContext checkpointer_context;
diff --git a/src/backend/postmaster/launch_backend.c b/src/backend/postmaster/launch_backend.c
index a97a1eda6da..47375e5bfaa 100644
--- a/src/backend/postmaster/launch_backend.c
+++ b/src/backend/postmaster/launch_backend.c
@@ -149,7 +149,7 @@ typedef struct
 
 #define SizeOfBackendParameters(startup_data_len) (offsetof(BackendParameters, startup_data) + startup_data_len)
 
-static void read_backend_variables(char *id, char **startup_data, size_t *startup_data_len);
+static void read_backend_variables(char *id, void **startup_data, size_t *startup_data_len);
 static void restore_backend_variables(BackendParameters *param);
 
 static bool save_backend_variables(BackendParameters *param, int child_slot,
@@ -157,10 +157,10 @@ static bool save_backend_variables(BackendParameters *param, int child_slot,
 #ifdef WIN32
 								   HANDLE childProcess, pid_t childPid,
 #endif
-								   char *startup_data, size_t startup_data_len);
+								   const void *startup_data, size_t startup_data_len);
 
 static pid_t internal_forkexec(const char *child_kind, int child_slot,
-							   char *startup_data, size_t startup_data_len,
+							   const void *startup_data, size_t startup_data_len,
 							   ClientSocket *client_sock);
 
 #endif							/* EXEC_BACKEND */
@@ -171,7 +171,7 @@ static pid_t internal_forkexec(const char *child_kind, int child_slot,
 typedef struct
 {
 	const char *name;
-	void		(*main_fn) (char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+	void		(*main_fn) (const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 	bool		shmem_attach;
 } child_process_kind;
 
@@ -225,7 +225,7 @@ PostmasterChildName(BackendType child_type)
  */
 pid_t
 postmaster_child_launch(BackendType child_type, int child_slot,
-						char *startup_data, size_t startup_data_len,
+						const void *startup_data, size_t startup_data_len,
 						ClientSocket *client_sock)
 {
 	pid_t		pid;
@@ -289,7 +289,7 @@ postmaster_child_launch(BackendType child_type, int child_slot,
  */
 static pid_t
 internal_forkexec(const char *child_kind, int child_slot,
-				  char *startup_data, size_t startup_data_len, ClientSocket *client_sock)
+				  const void *startup_data, size_t startup_data_len, ClientSocket *client_sock)
 {
 	static unsigned long tmpBackendFileNum = 0;
 	pid_t		pid;
@@ -399,7 +399,7 @@ internal_forkexec(const char *child_kind, int child_slot,
  */
 static pid_t
 internal_forkexec(const char *child_kind, int child_slot,
-				  char *startup_data, size_t startup_data_len, ClientSocket *client_sock)
+				  const void *startup_data, size_t startup_data_len, ClientSocket *client_sock)
 {
 	int			retry_count = 0;
 	STARTUPINFO si;
@@ -581,7 +581,7 @@ internal_forkexec(const char *child_kind, int child_slot,
 void
 SubPostmasterMain(int argc, char *argv[])
 {
-	char	   *startup_data;
+	void	   *startup_data;
 	size_t		startup_data_len;
 	char	   *child_kind;
 	BackendType child_type;
@@ -699,7 +699,7 @@ save_backend_variables(BackendParameters *param,
 #ifdef WIN32
 					   HANDLE childProcess, pid_t childPid,
 #endif
-					   char *startup_data, size_t startup_data_len)
+					   const void *startup_data, size_t startup_data_len)
 {
 	if (client_sock)
 		memcpy(&param->client_sock, client_sock, sizeof(ClientSocket));
@@ -867,7 +867,7 @@ read_inheritable_socket(SOCKET *dest, InheritableSocket *src)
 #endif
 
 static void
-read_backend_variables(char *id, char **startup_data, size_t *startup_data_len)
+read_backend_variables(char *id, void **startup_data, size_t *startup_data_len)
 {
 	BackendParameters param;
 
diff --git a/src/backend/postmaster/pgarch.c b/src/backend/postmaster/pgarch.c
index 12ee815a626..e6cd78679ce 100644
--- a/src/backend/postmaster/pgarch.c
+++ b/src/backend/postmaster/pgarch.c
@@ -214,7 +214,7 @@ PgArchCanRestart(void)
 
 /* Main entry point for archiver process */
 void
-PgArchiverMain(char *startup_data, size_t startup_data_len)
+PgArchiverMain(const void *startup_data, size_t startup_data_len)
 {
 	Assert(startup_data_len == 0);
 
diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
index bb22b13adef..5dd3b6a4fd4 100644
--- a/src/backend/postmaster/postmaster.c
+++ b/src/backend/postmaster/postmaster.c
@@ -3517,7 +3517,7 @@ BackendStartup(ClientSocket *client_sock)
 	bn->bgworker_notify = false;
 
 	pid = postmaster_child_launch(bn->bkend_type, bn->child_slot,
-								  (char *) &startup_data, sizeof(startup_data),
+								  &startup_data, sizeof(startup_data),
 								  client_sock);
 	if (pid < 0)
 	{
@@ -4080,7 +4080,7 @@ StartBackgroundWorker(RegisteredBgWorker *rw)
 							 rw->rw_worker.bgw_name)));
 
 	worker_pid = postmaster_child_launch(B_BG_WORKER, bn->child_slot,
-										 (char *) &rw->rw_worker, sizeof(BackgroundWorker), NULL);
+										 &rw->rw_worker, sizeof(BackgroundWorker), NULL);
 	if (worker_pid == -1)
 	{
 		/* in postmaster, fork failed ... */
diff --git a/src/backend/postmaster/startup.c b/src/backend/postmaster/startup.c
index 59d213031b3..88eab3d0baf 100644
--- a/src/backend/postmaster/startup.c
+++ b/src/backend/postmaster/startup.c
@@ -213,7 +213,7 @@ StartupProcExit(int code, Datum arg)
  * ----------------------------------
  */
 void
-StartupProcessMain(char *startup_data, size_t startup_data_len)
+StartupProcessMain(const void *startup_data, size_t startup_data_len)
 {
 	Assert(startup_data_len == 0);
 
diff --git a/src/backend/postmaster/syslogger.c b/src/backend/postmaster/syslogger.c
index 7e9b3f2a0fd..50c2edec1f6 100644
--- a/src/backend/postmaster/syslogger.c
+++ b/src/backend/postmaster/syslogger.c
@@ -162,7 +162,7 @@ typedef struct
  * argc/argv parameters are valid only in EXEC_BACKEND case.
  */
 void
-SysLoggerMain(char *startup_data, size_t startup_data_len)
+SysLoggerMain(const void *startup_data, size_t startup_data_len)
 {
 #ifndef WIN32
 	char		logbuffer[READ_BUF_SIZE];
@@ -183,7 +183,7 @@ SysLoggerMain(char *startup_data, size_t startup_data_len)
 	 */
 #ifdef EXEC_BACKEND
 	{
-		SysloggerStartupData *slsdata = (SysloggerStartupData *) startup_data;
+		const SysloggerStartupData *slsdata = startup_data;
 
 		Assert(startup_data_len == sizeof(*slsdata));
 		syslogFile = syslogger_fdopen(slsdata->syslogFile);
@@ -699,7 +699,7 @@ SysLogger_Start(int child_slot)
 	startup_data.csvlogFile = syslogger_fdget(csvlogFile);
 	startup_data.jsonlogFile = syslogger_fdget(jsonlogFile);
 	sysloggerPid = postmaster_child_launch(B_LOGGER, child_slot,
-										   (char *) &startup_data, sizeof(startup_data), NULL);
+										   &startup_data, sizeof(startup_data), NULL);
 #else
 	sysloggerPid = postmaster_child_launch(B_LOGGER, child_slot,
 										   NULL, 0, NULL);
diff --git a/src/backend/postmaster/walsummarizer.c b/src/backend/postmaster/walsummarizer.c
index ffbf0439358..f4d61c1f3bb 100644
--- a/src/backend/postmaster/walsummarizer.c
+++ b/src/backend/postmaster/walsummarizer.c
@@ -208,7 +208,7 @@ WalSummarizerShmemInit(void)
  * Entry point for walsummarizer process.
  */
 void
-WalSummarizerMain(char *startup_data, size_t startup_data_len)
+WalSummarizerMain(const void *startup_data, size_t startup_data_len)
 {
 	sigjmp_buf	local_sigjmp_buf;
 	MemoryContext context;
diff --git a/src/backend/postmaster/walwriter.c b/src/backend/postmaster/walwriter.c
index df4f7634969..15a71ad684d 100644
--- a/src/backend/postmaster/walwriter.c
+++ b/src/backend/postmaster/walwriter.c
@@ -84,7 +84,7 @@ int			WalWriterFlushAfter = DEFAULT_WAL_WRITER_FLUSH_AFTER;
  * basic execution environment, but not enabled signals yet.
  */
 void
-WalWriterMain(char *startup_data, size_t startup_data_len)
+WalWriterMain(const void *startup_data, size_t startup_data_len)
 {
 	sigjmp_buf	local_sigjmp_buf;
 	MemoryContext walwriter_context;
diff --git a/src/backend/replication/logical/slotsync.c b/src/backend/replication/logical/slotsync.c
index 987857b9491..2c0a7439be4 100644
--- a/src/backend/replication/logical/slotsync.c
+++ b/src/backend/replication/logical/slotsync.c
@@ -1326,7 +1326,7 @@ reset_syncing_flag()
  * information periodically in order to create and sync the slots.
  */
 void
-ReplSlotSyncWorkerMain(char *startup_data, size_t startup_data_len)
+ReplSlotSyncWorkerMain(const void *startup_data, size_t startup_data_len)
 {
 	WalReceiverConn *wrconn = NULL;
 	char	   *dbname;
diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
index bd09262e27d..82f7302ff9f 100644
--- a/src/backend/replication/walreceiver.c
+++ b/src/backend/replication/walreceiver.c
@@ -180,7 +180,7 @@ ProcessWalRcvInterrupts(void)
 
 /* Main entry point for walreceiver process */
 void
-WalReceiverMain(char *startup_data, size_t startup_data_len)
+WalReceiverMain(const void *startup_data, size_t startup_data_len)
 {
 	char		conninfo[MAXCONNINFO];
 	char	   *tmp_conninfo;
diff --git a/src/backend/tcop/backend_startup.c b/src/backend/tcop/backend_startup.c
index bd9640d0eb1..9ee738eb1e0 100644
--- a/src/backend/tcop/backend_startup.c
+++ b/src/backend/tcop/backend_startup.c
@@ -56,9 +56,9 @@ static void StartupPacketTimeoutHandler(void);
  * client, and start the main processing loop.
  */
 void
-BackendMain(char *startup_data, size_t startup_data_len)
+BackendMain(const void *startup_data, size_t startup_data_len)
 {
-	BackendStartupData *bsdata = (BackendStartupData *) startup_data;
+	const BackendStartupData *bsdata = startup_data;
 
 	Assert(startup_data_len == sizeof(BackendStartupData));
 	Assert(MyClientSocket != NULL);
diff --git a/src/include/postmaster/autovacuum.h b/src/include/postmaster/autovacuum.h
index 06d4a593575..6a95e5f55bd 100644
--- a/src/include/postmaster/autovacuum.h
+++ b/src/include/postmaster/autovacuum.h
@@ -58,8 +58,8 @@ extern void autovac_init(void);
 /* called from postmaster when a worker could not be forked */
 extern void AutoVacWorkerFailed(void);
 
-extern void AutoVacLauncherMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
-extern void AutoVacWorkerMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void AutoVacLauncherMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void AutoVacWorkerMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 
 extern bool AutoVacuumRequestWork(AutoVacuumWorkItemType type,
 								  Oid relationId, BlockNumber blkno);
diff --git a/src/include/postmaster/bgworker_internals.h b/src/include/postmaster/bgworker_internals.h
index 092b1610663..29e6f44cf08 100644
--- a/src/include/postmaster/bgworker_internals.h
+++ b/src/include/postmaster/bgworker_internals.h
@@ -52,6 +52,6 @@ extern void ForgetUnstartedBackgroundWorkers(void);
 extern void ResetBackgroundWorkerCrashTimes(void);
 
 /* Entry point for background worker processes */
-extern void BackgroundWorkerMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void BackgroundWorkerMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 
 #endif							/* BGWORKER_INTERNALS_H */
diff --git a/src/include/postmaster/bgwriter.h b/src/include/postmaster/bgwriter.h
index 2d5854e6879..4fd717169f0 100644
--- a/src/include/postmaster/bgwriter.h
+++ b/src/include/postmaster/bgwriter.h
@@ -27,8 +27,8 @@ extern PGDLLIMPORT int CheckPointTimeout;
 extern PGDLLIMPORT int CheckPointWarning;
 extern PGDLLIMPORT double CheckPointCompletionTarget;
 
-extern void BackgroundWriterMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
-extern void CheckpointerMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void BackgroundWriterMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void CheckpointerMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 
 extern void RequestCheckpoint(int flags);
 extern void CheckpointWriteDelay(int flags, double progress);
diff --git a/src/include/postmaster/pgarch.h b/src/include/postmaster/pgarch.h
index 8fc6bfeec1b..a32d78feb27 100644
--- a/src/include/postmaster/pgarch.h
+++ b/src/include/postmaster/pgarch.h
@@ -29,7 +29,7 @@
 extern Size PgArchShmemSize(void);
 extern void PgArchShmemInit(void);
 extern bool PgArchCanRestart(void);
-extern void PgArchiverMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void PgArchiverMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 extern void PgArchWakeup(void);
 extern void PgArchForceDirScan(void);
 
diff --git a/src/include/postmaster/postmaster.h b/src/include/postmaster/postmaster.h
index 188a06e2379..d8a9f14b3b8 100644
--- a/src/include/postmaster/postmaster.h
+++ b/src/include/postmaster/postmaster.h
@@ -109,7 +109,7 @@ extern PGDLLIMPORT struct ClientSocket *MyClientSocket;
 /* prototypes for functions in launch_backend.c */
 extern pid_t postmaster_child_launch(BackendType child_type,
 									 int child_slot,
-									 char *startup_data,
+									 const void *startup_data,
 									 size_t startup_data_len,
 									 struct ClientSocket *client_sock);
 const char *PostmasterChildName(BackendType child_type);
diff --git a/src/include/postmaster/startup.h b/src/include/postmaster/startup.h
index 736c97d121a..ae0f6347fc0 100644
--- a/src/include/postmaster/startup.h
+++ b/src/include/postmaster/startup.h
@@ -26,7 +26,7 @@
 extern PGDLLIMPORT int log_startup_progress_interval;
 
 extern void HandleStartupProcInterrupts(void);
-extern void StartupProcessMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void StartupProcessMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 extern void PreRestoreCommand(void);
 extern void PostRestoreCommand(void);
 extern bool IsPromoteSignaled(void);
diff --git a/src/include/postmaster/syslogger.h b/src/include/postmaster/syslogger.h
index e92d8531478..197d8e43fdd 100644
--- a/src/include/postmaster/syslogger.h
+++ b/src/include/postmaster/syslogger.h
@@ -90,7 +90,7 @@ extern int	SysLogger_Start(int child_slot);
 
 extern void write_syslogger_file(const char *buffer, int count, int destination);
 
-extern void SysLoggerMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void SysLoggerMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 
 extern bool CheckLogrotateSignal(void);
 extern void RemoveLogrotateSignalFiles(void);
diff --git a/src/include/postmaster/walsummarizer.h b/src/include/postmaster/walsummarizer.h
index bfe86663ccb..e1086d02c8b 100644
--- a/src/include/postmaster/walsummarizer.h
+++ b/src/include/postmaster/walsummarizer.h
@@ -21,7 +21,7 @@ extern PGDLLIMPORT int wal_summary_keep_time;
 
 extern Size WalSummarizerShmemSize(void);
 extern void WalSummarizerShmemInit(void);
-extern void WalSummarizerMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void WalSummarizerMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 
 extern void GetWalSummarizerState(TimeLineID *summarized_tli,
 								  XLogRecPtr *summarized_lsn,
diff --git a/src/include/postmaster/walwriter.h b/src/include/postmaster/walwriter.h
index 9fc3c665774..ea8c22b174f 100644
--- a/src/include/postmaster/walwriter.h
+++ b/src/include/postmaster/walwriter.h
@@ -18,6 +18,6 @@
 extern PGDLLIMPORT int WalWriterDelay;
 extern PGDLLIMPORT int WalWriterFlushAfter;
 
-extern void WalWriterMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void WalWriterMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 
 #endif							/* _WALWRITER_H */
diff --git a/src/include/replication/slotsync.h b/src/include/replication/slotsync.h
index 3fad27f0a63..6cde7f81cec 100644
--- a/src/include/replication/slotsync.h
+++ b/src/include/replication/slotsync.h
@@ -26,7 +26,7 @@ extern PGDLLIMPORT char *PrimarySlotName;
 extern char *CheckAndGetDbnameFromConninfo(void);
 extern bool ValidateSlotSyncParams(int elevel);
 
-extern void ReplSlotSyncWorkerMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void ReplSlotSyncWorkerMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 
 extern void ShutDownSlotSync(void);
 extern bool SlotSyncWorkerCanRestart(void);
diff --git a/src/include/replication/walreceiver.h b/src/include/replication/walreceiver.h
index 204419bd8a3..992be93cce8 100644
--- a/src/include/replication/walreceiver.h
+++ b/src/include/replication/walreceiver.h
@@ -486,7 +486,7 @@ walrcv_clear_result(WalRcvExecResult *walres)
 }
 
 /* prototypes for functions in walreceiver.c */
-extern void WalReceiverMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void WalReceiverMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 extern void ProcessWalRcvInterrupts(void);
 extern void WalRcvForceReply(void);
 
diff --git a/src/include/tcop/backend_startup.h b/src/include/tcop/backend_startup.h
index 01baf4aad75..73285611203 100644
--- a/src/include/tcop/backend_startup.h
+++ b/src/include/tcop/backend_startup.h
@@ -39,6 +39,6 @@ typedef struct BackendStartupData
 	CAC_state	canAcceptConnections;
 } BackendStartupData;
 
-extern void BackendMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn();
+extern void BackendMain(const void *startup_data, size_t startup_data_len) pg_attribute_noreturn();
 
 #endif							/* BACKEND_STARTUP_H */
-- 
2.48.1

From 6f5d4b7281fe335bed88487938dbed6f507f85d3 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Tue, 24 Sep 2024 12:11:49 +0200
Subject: [PATCH v2 06/10] backend libpq void * argument for binary data

Change some backend libpq functions to take void * for binary data
instead of char *.  This removes the need for numerous casts.

getbytes/putbytes void * argument
---
 src/backend/libpq/pqcomm.c         | 13 ++++++++-----
 src/backend/libpq/pqformat.c       | 10 +++++-----
 src/backend/tcop/backend_startup.c |  2 +-
 src/backend/utils/adt/varbit.c     |  4 ++--
 src/include/libpq/libpq.h          |  2 +-
 src/include/libpq/pqformat.h       |  2 +-
 6 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/src/backend/libpq/pqcomm.c b/src/backend/libpq/pqcomm.c
index bddd6465de2..7ee5f3497f0 100644
--- a/src/backend/libpq/pqcomm.c
+++ b/src/backend/libpq/pqcomm.c
@@ -144,7 +144,7 @@ static int	socket_flush_if_writable(void);
 static bool socket_is_send_pending(void);
 static int	socket_putmessage(char msgtype, const char *s, size_t len);
 static void socket_putmessage_noblock(char msgtype, const char *s, size_t len);
-static inline int internal_putbytes(const char *s, size_t len);
+static inline int internal_putbytes(const void *b, size_t len);
 static inline int internal_flush(void);
 static pg_noinline int internal_flush_buffer(const char *buf, size_t *start,
 											 size_t *end);
@@ -1060,8 +1060,9 @@ pq_getbyte_if_available(unsigned char *c)
  * --------------------------------
  */
 int
-pq_getbytes(char *s, size_t len)
+pq_getbytes(void *b, size_t len)
 {
+	char	   *s = b;
 	size_t		amount;
 
 	Assert(PqCommReadingMsg);
@@ -1209,7 +1210,7 @@ pq_getmessage(StringInfo s, int maxlen)
 	resetStringInfo(s);
 
 	/* Read message length word */
-	if (pq_getbytes((char *) &len, 4) == EOF)
+	if (pq_getbytes(&len, 4) == EOF)
 	{
 		ereport(COMMERROR,
 				(errcode(ERRCODE_PROTOCOL_VIOLATION),
@@ -1274,8 +1275,10 @@ pq_getmessage(StringInfo s, int maxlen)
 
 
 static inline int
-internal_putbytes(const char *s, size_t len)
+internal_putbytes(const void *b, size_t len)
 {
+	const char *s = b;
+
 	while (len > 0)
 	{
 		/* If buffer is full, then flush it out */
@@ -1499,7 +1502,7 @@ socket_putmessage(char msgtype, const char *s, size_t len)
 		goto fail;
 
 	n32 = pg_hton32((uint32) (len + 4));
-	if (internal_putbytes((char *) &n32, 4))
+	if (internal_putbytes(&n32, 4))
 		goto fail;
 
 	if (internal_putbytes(s, len))
diff --git a/src/backend/libpq/pqformat.c b/src/backend/libpq/pqformat.c
index 295297cb559..1cc126772f7 100644
--- a/src/backend/libpq/pqformat.c
+++ b/src/backend/libpq/pqformat.c
@@ -422,15 +422,15 @@ pq_getmsgint(StringInfo msg, int b)
 	switch (b)
 	{
 		case 1:
-			pq_copymsgbytes(msg, (char *) &n8, 1);
+			pq_copymsgbytes(msg, &n8, 1);
 			result = n8;
 			break;
 		case 2:
-			pq_copymsgbytes(msg, (char *) &n16, 2);
+			pq_copymsgbytes(msg, &n16, 2);
 			result = pg_ntoh16(n16);
 			break;
 		case 4:
-			pq_copymsgbytes(msg, (char *) &n32, 4);
+			pq_copymsgbytes(msg, &n32, 4);
 			result = pg_ntoh32(n32);
 			break;
 		default:
@@ -454,7 +454,7 @@ pq_getmsgint64(StringInfo msg)
 {
 	uint64		n64;
 
-	pq_copymsgbytes(msg, (char *) &n64, sizeof(n64));
+	pq_copymsgbytes(msg, &n64, sizeof(n64));
 
 	return pg_ntoh64(n64);
 }
@@ -525,7 +525,7 @@ pq_getmsgbytes(StringInfo msg, int datalen)
  * --------------------------------
  */
 void
-pq_copymsgbytes(StringInfo msg, char *buf, int datalen)
+pq_copymsgbytes(StringInfo msg, void *buf, int datalen)
 {
 	if (datalen < 0 || datalen > (msg->len - msg->cursor))
 		ereport(ERROR,
diff --git a/src/backend/tcop/backend_startup.c b/src/backend/tcop/backend_startup.c
index 9ee738eb1e0..c70746fa562 100644
--- a/src/backend/tcop/backend_startup.c
+++ b/src/backend/tcop/backend_startup.c
@@ -480,7 +480,7 @@ ProcessStartupPacket(Port *port, bool ssl_done, bool gss_done)
 	 * sound inefficient, but it's not really, because of buffering in
 	 * pqcomm.c.)
 	 */
-	if (pq_getbytes((char *) &len, 1) == EOF)
+	if (pq_getbytes(&len, 1) == EOF)
 	{
 		/*
 		 * If we get no data at all, don't clutter the log with a complaint;
diff --git a/src/backend/utils/adt/varbit.c b/src/backend/utils/adt/varbit.c
index 0071e026f01..205a67dafc5 100644
--- a/src/backend/utils/adt/varbit.c
+++ b/src/backend/utils/adt/varbit.c
@@ -361,7 +361,7 @@ bit_recv(PG_FUNCTION_ARGS)
 	SET_VARSIZE(result, len);
 	VARBITLEN(result) = bitlen;
 
-	pq_copymsgbytes(buf, (char *) VARBITS(result), VARBITBYTES(result));
+	pq_copymsgbytes(buf, VARBITS(result), VARBITBYTES(result));
 
 	/* Make sure last byte is correctly zero-padded */
 	VARBIT_PAD(result);
@@ -666,7 +666,7 @@ varbit_recv(PG_FUNCTION_ARGS)
 	SET_VARSIZE(result, len);
 	VARBITLEN(result) = bitlen;
 
-	pq_copymsgbytes(buf, (char *) VARBITS(result), VARBITBYTES(result));
+	pq_copymsgbytes(buf, VARBITS(result), VARBITBYTES(result));
 
 	/* Make sure last byte is correctly zero-padded */
 	VARBIT_PAD(result);
diff --git a/src/include/libpq/libpq.h b/src/include/libpq/libpq.h
index 8defcb6de19..aeb66ca40cf 100644
--- a/src/include/libpq/libpq.h
+++ b/src/include/libpq/libpq.h
@@ -71,7 +71,7 @@ extern int	AcceptConnection(pgsocket server_fd, ClientSocket *client_sock);
 extern void TouchSocketFiles(void);
 extern void RemoveSocketFiles(void);
 extern Port *pq_init(ClientSocket *client_sock);
-extern int	pq_getbytes(char *s, size_t len);
+extern int	pq_getbytes(void *b, size_t len);
 extern void pq_startmsgread(void);
 extern void pq_endmsgread(void);
 extern bool pq_is_reading_msg(void);
diff --git a/src/include/libpq/pqformat.h b/src/include/libpq/pqformat.h
index 6b1a31f8541..9a1534be521 100644
--- a/src/include/libpq/pqformat.h
+++ b/src/include/libpq/pqformat.h
@@ -200,7 +200,7 @@ extern int64 pq_getmsgint64(StringInfo msg);
 extern float4 pq_getmsgfloat4(StringInfo msg);
 extern float8 pq_getmsgfloat8(StringInfo msg);
 extern const char *pq_getmsgbytes(StringInfo msg, int datalen);
-extern void pq_copymsgbytes(StringInfo msg, char *buf, int datalen);
+extern void pq_copymsgbytes(StringInfo msg, void *buf, int datalen);
 extern char *pq_getmsgtext(StringInfo msg, int rawbytes, int *nbytes);
 extern const char *pq_getmsgstring(StringInfo msg);
 extern const char *pq_getmsgrawstring(StringInfo msg);
-- 
2.48.1

From a6b868b05f4144dd8af176395484925123ad83b6 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Tue, 24 Sep 2024 12:14:38 +0200
Subject: [PATCH v2 07/10] jsonb internal API void * argument for binary data

Change some internal jsonb API functions to take void * for binary
data instead of char *.  This removes the need for numerous casts.
---
 src/backend/utils/adt/jsonb_util.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/backend/utils/adt/jsonb_util.c b/src/backend/utils/adt/jsonb_util.c
index 773f3690c7b..c8b6c15e059 100644
--- a/src/backend/utils/adt/jsonb_util.c
+++ b/src/backend/utils/adt/jsonb_util.c
@@ -48,8 +48,8 @@ static void convertJsonbObject(StringInfo buffer, JEntry *header, JsonbValue *va
 static void convertJsonbScalar(StringInfo buffer, JEntry *header, JsonbValue *scalarVal);
 
 static int	reserveFromBuffer(StringInfo buffer, int len);
-static void appendToBuffer(StringInfo buffer, const char *data, int len);
-static void copyToBuffer(StringInfo buffer, int offset, const char *data, int len);
+static void appendToBuffer(StringInfo buffer, const void *data, int len);
+static void copyToBuffer(StringInfo buffer, int offset, const void *data, int len);
 static short padBufferToInt(StringInfo buffer);
 
 static JsonbIterator *iteratorFromContainer(JsonbContainer *container, JsonbIterator *parent);
@@ -1508,7 +1508,7 @@ reserveFromBuffer(StringInfo buffer, int len)
  * Copy 'len' bytes to a previously reserved area in buffer.
  */
 static void
-copyToBuffer(StringInfo buffer, int offset, const char *data, int len)
+copyToBuffer(StringInfo buffer, int offset, const void *data, int len)
 {
 	memcpy(buffer->data + offset, data, len);
 }
@@ -1517,7 +1517,7 @@ copyToBuffer(StringInfo buffer, int offset, const char *data, int len)
  * A shorthand for reserveFromBuffer + copyToBuffer.
  */
 static void
-appendToBuffer(StringInfo buffer, const char *data, int len)
+appendToBuffer(StringInfo buffer, const void *data, int len)
 {
 	int			offset;
 
@@ -1646,7 +1646,7 @@ convertJsonbArray(StringInfo buffer, JEntry *header, JsonbValue *val, int level)
 		containerhead |= JB_FSCALAR;
 	}
 
-	appendToBuffer(buffer, (char *) &containerhead, sizeof(uint32));
+	appendToBuffer(buffer, &containerhead, sizeof(uint32));
 
 	/* Reserve space for the JEntries of the elements. */
 	jentry_offset = reserveFromBuffer(buffer, sizeof(JEntry) * nElems);
@@ -1684,7 +1684,7 @@ convertJsonbArray(StringInfo buffer, JEntry *header, JsonbValue *val, int level)
 		if ((i % JB_OFFSET_STRIDE) == 0)
 			meta = (meta & JENTRY_TYPEMASK) | totallen | JENTRY_HAS_OFF;
 
-		copyToBuffer(buffer, jentry_offset, (char *) &meta, sizeof(JEntry));
+		copyToBuffer(buffer, jentry_offset, &meta, sizeof(JEntry));
 		jentry_offset += sizeof(JEntry);
 	}
 
@@ -1723,7 +1723,7 @@ convertJsonbObject(StringInfo buffer, JEntry *header, JsonbValue *val, int level
 	 * variable-length payload.
 	 */
 	containerheader = nPairs | JB_FOBJECT;
-	appendToBuffer(buffer, (char *) &containerheader, sizeof(uint32));
+	appendToBuffer(buffer, &containerheader, sizeof(uint32));
 
 	/* Reserve space for the JEntries of the keys and values. */
 	jentry_offset = reserveFromBuffer(buffer, sizeof(JEntry) * nPairs * 2);
@@ -1765,7 +1765,7 @@ convertJsonbObject(StringInfo buffer, JEntry *header, JsonbValue *val, int level
 		if ((i % JB_OFFSET_STRIDE) == 0)
 			meta = (meta & JENTRY_TYPEMASK) | totallen | JENTRY_HAS_OFF;
 
-		copyToBuffer(buffer, jentry_offset, (char *) &meta, sizeof(JEntry));
+		copyToBuffer(buffer, jentry_offset, &meta, sizeof(JEntry));
 		jentry_offset += sizeof(JEntry);
 	}
 	for (i = 0; i < nPairs; i++)
@@ -1800,7 +1800,7 @@ convertJsonbObject(StringInfo buffer, JEntry *header, JsonbValue *val, int level
 		if (((i + nPairs) % JB_OFFSET_STRIDE) == 0)
 			meta = (meta & JENTRY_TYPEMASK) | totallen | JENTRY_HAS_OFF;
 
-		copyToBuffer(buffer, jentry_offset, (char *) &meta, sizeof(JEntry));
+		copyToBuffer(buffer, jentry_offset, &meta, sizeof(JEntry));
 		jentry_offset += sizeof(JEntry);
 	}
 
@@ -1840,7 +1840,7 @@ convertJsonbScalar(StringInfo buffer, JEntry *header, JsonbValue *scalarVal)
 			numlen = VARSIZE_ANY(scalarVal->val.numeric);
 			padlen = padBufferToInt(buffer);
 
-			appendToBuffer(buffer, (char *) scalarVal->val.numeric, numlen);
+			appendToBuffer(buffer, scalarVal->val.numeric, numlen);
 
 			*header = JENTRY_ISNUMERIC | (padlen + numlen);
 			break;
-- 
2.48.1

From d26468323878a164035288afc0751bd60f952e26 Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Tue, 24 Sep 2024 12:18:31 +0200
Subject: [PATCH v2 08/10] SnapBuildRestoreContents() void * argument for
 binary data

Change internal snapbuild API function to take void * for binary data
instead of char *.  This removes the need for numerous casts.
---
 src/backend/replication/logical/snapbuild.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/backend/replication/logical/snapbuild.c b/src/backend/replication/logical/snapbuild.c
index bbedd3de318..9839eb7735c 100644
--- a/src/backend/replication/logical/snapbuild.c
+++ b/src/backend/replication/logical/snapbuild.c
@@ -173,7 +173,7 @@ static void SnapBuildWaitSnapshot(xl_running_xacts *running, TransactionId cutof
 /* serialization functions */
 static void SnapBuildSerialize(SnapBuild *builder, XLogRecPtr lsn);
 static bool SnapBuildRestore(SnapBuild *builder, XLogRecPtr lsn);
-static void SnapBuildRestoreContents(int fd, char *dest, Size size, const char *path);
+static void SnapBuildRestoreContents(int fd, void *dest, Size size, const char *path);
 
 /*
  * Allocate a new snapshot builder.
@@ -1722,7 +1722,7 @@ SnapBuildRestoreSnapshot(SnapBuildOnDisk *ondisk, const char *path,
 	fsync_fname(PG_LOGICAL_SNAPSHOTS_DIR, true);
 
 	/* read statically sized portion of snapshot */
-	SnapBuildRestoreContents(fd, (char *) ondisk, SnapBuildOnDiskConstantSize, path);
+	SnapBuildRestoreContents(fd, ondisk, SnapBuildOnDiskConstantSize, path);
 
 	if (ondisk->magic != SNAPBUILD_MAGIC)
 		ereport(ERROR,
@@ -1742,7 +1742,7 @@ SnapBuildRestoreSnapshot(SnapBuildOnDisk *ondisk, const char *path,
 				SnapBuildOnDiskConstantSize - SnapBuildOnDiskNotChecksummedSize);
 
 	/* read SnapBuild */
-	SnapBuildRestoreContents(fd, (char *) &ondisk->builder, sizeof(SnapBuild), path);
+	SnapBuildRestoreContents(fd, &ondisk->builder, sizeof(SnapBuild), path);
 	COMP_CRC32C(checksum, &ondisk->builder, sizeof(SnapBuild));
 
 	/* restore committed xacts information */
@@ -1750,7 +1750,7 @@ SnapBuildRestoreSnapshot(SnapBuildOnDisk *ondisk, const char *path,
 	{
 		sz = sizeof(TransactionId) * ondisk->builder.committed.xcnt;
 		ondisk->builder.committed.xip = MemoryContextAllocZero(context, sz);
-		SnapBuildRestoreContents(fd, (char *) ondisk->builder.committed.xip, sz, path);
+		SnapBuildRestoreContents(fd, ondisk->builder.committed.xip, sz, path);
 		COMP_CRC32C(checksum, ondisk->builder.committed.xip, sz);
 	}
 
@@ -1759,7 +1759,7 @@ SnapBuildRestoreSnapshot(SnapBuildOnDisk *ondisk, const char *path,
 	{
 		sz = sizeof(TransactionId) * ondisk->builder.catchange.xcnt;
 		ondisk->builder.catchange.xip = MemoryContextAllocZero(context, sz);
-		SnapBuildRestoreContents(fd, (char *) ondisk->builder.catchange.xip, sz, path);
+		SnapBuildRestoreContents(fd, ondisk->builder.catchange.xip, sz, path);
 		COMP_CRC32C(checksum, ondisk->builder.catchange.xip, sz);
 	}
 
@@ -1882,7 +1882,7 @@ SnapBuildRestore(SnapBuild *builder, XLogRecPtr lsn)
  * Read the contents of the serialized snapshot to 'dest'.
  */
 static void
-SnapBuildRestoreContents(int fd, char *dest, Size size, const char *path)
+SnapBuildRestoreContents(int fd, void *dest, Size size, const char *path)
 {
 	int			readBytes;
 
-- 
2.48.1

From 0c013cce73c2582b64c4cd778c7f01dc83c0745b Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Mon, 30 Dec 2024 16:10:41 +0100
Subject: [PATCH v2 09/10] XLogRegisterData, XLogRegisterBufData void *
 argument for binary data

Change XLogRegisterData() and XLogRegisterBufData() functions to take
void * for binary data instead of char *.  This will remove the need
for numerous casts.
---
 src/backend/access/transam/README       | 4 ++--
 src/backend/access/transam/xloginsert.c | 4 ++--
 src/include/access/xlog_internal.h      | 2 +-
 src/include/access/xloginsert.h         | 4 ++--
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/backend/access/transam/README b/src/backend/access/transam/README
index 6e4711dace7..231106270fd 100644
--- a/src/backend/access/transam/README
+++ b/src/backend/access/transam/README
@@ -586,13 +586,13 @@ void XLogRegisterBuffer(uint8 block_id, Buffer buf, uint8 flags);
     XLogRegisterBufData() is included in the WAL record even if a full-page
     image is taken.
 
-void XLogRegisterData(const char *data, int len);
+void XLogRegisterData(const void *data, int len);
 
     XLogRegisterData is used to include arbitrary data in the WAL record.  If
     XLogRegisterData() is called multiple times, the data are appended, and
     will be made available to the redo routine as one contiguous chunk.
 
-void XLogRegisterBufData(uint8 block_id, const char *data, int len);
+void XLogRegisterBufData(uint8 block_id, const void *data, int len);
 
     XLogRegisterBufData is used to include data associated with a particular
     buffer that was registered earlier with XLogRegisterBuffer().  If
diff --git a/src/backend/access/transam/xloginsert.c b/src/backend/access/transam/xloginsert.c
index c66012c3a8b..14d583ae7ae 100644
--- a/src/backend/access/transam/xloginsert.c
+++ b/src/backend/access/transam/xloginsert.c
@@ -361,7 +361,7 @@ XLogRegisterBlock(uint8 block_id, RelFileLocator *rlocator, ForkNumber forknum,
  * XLogRecGetData().
  */
 void
-XLogRegisterData(const char *data, uint32 len)
+XLogRegisterData(const void *data, uint32 len)
 {
 	XLogRecData *rdata;
 
@@ -402,7 +402,7 @@ XLogRegisterData(const char *data, uint32 len)
  * limited)
  */
 void
-XLogRegisterBufData(uint8 block_id, const char *data, uint32 len)
+XLogRegisterBufData(uint8 block_id, const void *data, uint32 len)
 {
 	registered_buffer *regbuf;
 	XLogRecData *rdata;
diff --git a/src/include/access/xlog_internal.h b/src/include/access/xlog_internal.h
index 0b7c56332b5..2cf8d55d706 100644
--- a/src/include/access/xlog_internal.h
+++ b/src/include/access/xlog_internal.h
@@ -312,7 +312,7 @@ typedef struct xl_end_of_recovery
 typedef struct XLogRecData
 {
 	struct XLogRecData *next;	/* next struct in chain, or NULL */
-	const char *data;			/* start of rmgr data to include */
+	const void *data;			/* start of rmgr data to include */
 	uint32		len;			/* length of rmgr data to include */
 } XLogRecData;
 
diff --git a/src/include/access/xloginsert.h b/src/include/access/xloginsert.h
index 3f6b3510527..cf057f033a2 100644
--- a/src/include/access/xloginsert.h
+++ b/src/include/access/xloginsert.h
@@ -45,12 +45,12 @@ extern void XLogBeginInsert(void);
 extern void XLogSetRecordFlags(uint8 flags);
 extern XLogRecPtr XLogInsert(RmgrId rmid, uint8 info);
 extern void XLogEnsureRecordSpace(int max_block_id, int ndatas);
-extern void XLogRegisterData(const char *data, uint32 len);
+extern void XLogRegisterData(const void *data, uint32 len);
 extern void XLogRegisterBuffer(uint8 block_id, Buffer buffer, uint8 flags);
 extern void XLogRegisterBlock(uint8 block_id, RelFileLocator *rlocator,
 							  ForkNumber forknum, BlockNumber blknum, const PageData *page,
 							  uint8 flags);
-extern void XLogRegisterBufData(uint8 block_id, const char *data, uint32 len);
+extern void XLogRegisterBufData(uint8 block_id, const void *data, uint32 len);
 extern void XLogResetInsertion(void);
 extern bool XLogCheckBufferNeedsBackup(Buffer buffer);
 
-- 
2.48.1

From d18acf285214076d19e8e67d52b2124cb662881a Mon Sep 17 00:00:00 2001
From: Peter Eisentraut <peter@eisentraut.org>
Date: Mon, 30 Dec 2024 16:43:26 +0100
Subject: [PATCH v2 10/10] Remove unnecessary (char *) casts [xlog]

Remove (char *) casts no longer needed after XLogRegisterData() and
XLogRegisterBufData() argument type change.
---
 contrib/pg_visibility/pg_visibility.c         |  2 +-
 src/backend/access/brin/brin.c                |  2 +-
 src/backend/access/brin/brin_pageops.c        | 12 ++---
 src/backend/access/brin/brin_revmap.c         |  4 +-
 src/backend/access/gin/ginbtree.c             |  6 +--
 src/backend/access/gin/gindatapage.c          |  8 +--
 src/backend/access/gin/ginentrypage.c         |  4 +-
 src/backend/access/gin/ginfast.c              |  6 +--
 src/backend/access/gin/ginutil.c              |  2 +-
 src/backend/access/gin/ginvacuum.c            |  2 +-
 src/backend/access/gist/gistxlog.c            | 22 ++++----
 src/backend/access/hash/hash.c                |  6 +--
 src/backend/access/hash/hashinsert.c          |  8 +--
 src/backend/access/hash/hashovfl.c            | 26 +++++-----
 src/backend/access/hash/hashpage.c            | 16 +++---
 src/backend/access/heap/heapam.c              | 46 ++++++++--------
 src/backend/access/heap/pruneheap.c           | 22 ++++----
 src/backend/access/heap/rewriteheap.c         |  2 +-
 src/backend/access/nbtree/nbtdedup.c          |  4 +-
 src/backend/access/nbtree/nbtinsert.c         | 26 +++++-----
 src/backend/access/nbtree/nbtpage.c           | 26 +++++-----
 src/backend/access/spgist/spgdoinsert.c       | 36 ++++++-------
 src/backend/access/spgist/spgvacuum.c         | 22 ++++----
 src/backend/access/transam/clog.c             |  4 +-
 src/backend/access/transam/commit_ts.c        |  4 +-
 src/backend/access/transam/multixact.c        |  8 +--
 src/backend/access/transam/xact.c             | 52 +++++++++----------
 src/backend/access/transam/xlog.c             | 18 +++----
 src/backend/catalog/storage.c                 |  4 +-
 src/backend/commands/dbcommands.c             | 14 ++---
 src/backend/commands/sequence.c               | 12 ++---
 src/backend/commands/tablecmds.c              |  4 +-
 src/backend/commands/tablespace.c             |  6 +--
 src/backend/replication/logical/message.c     |  2 +-
 src/backend/replication/logical/origin.c      |  4 +-
 src/backend/storage/ipc/standby.c             | 12 ++---
 src/backend/utils/cache/inval.c               |  6 +--
 src/backend/utils/cache/relmapper.c           |  4 +-
 .../test_custom_rmgrs/test_custom_rmgrs.c     |  4 +-
 39 files changed, 234 insertions(+), 234 deletions(-)

diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
index c900cfcea40..7f268a18a74 100644
--- a/contrib/pg_visibility/pg_visibility.c
+++ b/contrib/pg_visibility/pg_visibility.c
@@ -424,7 +424,7 @@ pg_truncate_visibility_map(PG_FUNCTION_ARGS)
 		xlrec.flags = SMGR_TRUNCATE_VM;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, sizeof(xlrec));
+		XLogRegisterData(&xlrec, sizeof(xlrec));
 
 		lsn = XLogInsert(RM_SMGR_ID,
 						 XLOG_SMGR_TRUNCATE | XLR_SPECIAL_REL_UPDATE);
diff --git a/src/backend/access/brin/brin.c b/src/backend/access/brin/brin.c
index ccf824bbdb2..4265687afa4 100644
--- a/src/backend/access/brin/brin.c
+++ b/src/backend/access/brin/brin.c
@@ -1135,7 +1135,7 @@ brinbuild(Relation heap, Relation index, IndexInfo *indexInfo)
 		xlrec.pagesPerRange = BrinGetPagesPerRange(index);
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfBrinCreateIdx);
+		XLogRegisterData(&xlrec, SizeOfBrinCreateIdx);
 		XLogRegisterBuffer(0, meta, REGBUF_WILL_INIT | REGBUF_STANDARD);
 
 		recptr = XLogInsert(RM_BRIN_ID, XLOG_BRIN_CREATE_INDEX);
diff --git a/src/backend/access/brin/brin_pageops.c b/src/backend/access/brin/brin_pageops.c
index 4bff280a135..6d8dd1512d6 100644
--- a/src/backend/access/brin/brin_pageops.c
+++ b/src/backend/access/brin/brin_pageops.c
@@ -190,10 +190,10 @@ brin_doupdate(Relation idxrel, BlockNumber pagesPerRange,
 			xlrec.offnum = oldoff;
 
 			XLogBeginInsert();
-			XLogRegisterData((char *) &xlrec, SizeOfBrinSamepageUpdate);
+			XLogRegisterData(&xlrec, SizeOfBrinSamepageUpdate);
 
 			XLogRegisterBuffer(0, oldbuf, REGBUF_STANDARD);
-			XLogRegisterBufData(0, (const char *) newtup, newsz);
+			XLogRegisterBufData(0, newtup, newsz);
 
 			recptr = XLogInsert(RM_BRIN_ID, info);
 
@@ -282,10 +282,10 @@ brin_doupdate(Relation idxrel, BlockNumber pagesPerRange,
 			XLogBeginInsert();
 
 			/* new page */
-			XLogRegisterData((char *) &xlrec, SizeOfBrinUpdate);
+			XLogRegisterData(&xlrec, SizeOfBrinUpdate);
 
 			XLogRegisterBuffer(0, newbuf, REGBUF_STANDARD | (extended ? REGBUF_WILL_INIT : 0));
-			XLogRegisterBufData(0, (const char *) newtup, newsz);
+			XLogRegisterBufData(0, newtup, newsz);
 
 			/* revmap page */
 			XLogRegisterBuffer(1, revmapbuf, 0);
@@ -435,10 +435,10 @@ brin_doinsert(Relation idxrel, BlockNumber pagesPerRange,
 		xlrec.offnum = off;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfBrinInsert);
+		XLogRegisterData(&xlrec, SizeOfBrinInsert);
 
 		XLogRegisterBuffer(0, *buffer, REGBUF_STANDARD | (extended ? REGBUF_WILL_INIT : 0));
-		XLogRegisterBufData(0, (char *) tup, itemsz);
+		XLogRegisterBufData(0, tup, itemsz);
 
 		XLogRegisterBuffer(1, revmapbuf, 0);
 
diff --git a/src/backend/access/brin/brin_revmap.c b/src/backend/access/brin/brin_revmap.c
index ea722d95ebc..4e380ecc710 100644
--- a/src/backend/access/brin/brin_revmap.c
+++ b/src/backend/access/brin/brin_revmap.c
@@ -416,7 +416,7 @@ brinRevmapDesummarizeRange(Relation idxrel, BlockNumber heapBlk)
 		xlrec.regOffset = regOffset;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfBrinDesummarize);
+		XLogRegisterData(&xlrec, SizeOfBrinDesummarize);
 		XLogRegisterBuffer(0, revmapBuf, 0);
 		XLogRegisterBuffer(1, regBuf, REGBUF_STANDARD);
 		recptr = XLogInsert(RM_BRIN_ID, XLOG_BRIN_DESUMMARIZE);
@@ -627,7 +627,7 @@ revmap_physical_extend(BrinRevmap *revmap)
 		xlrec.targetBlk = mapBlk;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfBrinRevmapExtend);
+		XLogRegisterData(&xlrec, SizeOfBrinRevmapExtend);
 		XLogRegisterBuffer(0, revmap->rm_metaBuf, REGBUF_STANDARD);
 
 		XLogRegisterBuffer(1, buf, REGBUF_WILL_INIT);
diff --git a/src/backend/access/gin/ginbtree.c b/src/backend/access/gin/ginbtree.c
index 57741263abd..26a0bdc2063 100644
--- a/src/backend/access/gin/ginbtree.c
+++ b/src/backend/access/gin/ginbtree.c
@@ -423,7 +423,7 @@ ginPlaceToPage(GinBtree btree, GinBtreeStack *stack,
 
 			xlrec.flags = xlflags;
 
-			XLogRegisterData((char *) &xlrec, sizeof(ginxlogInsert));
+			XLogRegisterData(&xlrec, sizeof(ginxlogInsert));
 
 			/*
 			 * Log information about child if this was an insertion of a
@@ -433,7 +433,7 @@ ginPlaceToPage(GinBtree btree, GinBtreeStack *stack,
 			{
 				BlockIdSet(&childblknos[0], BufferGetBlockNumber(childbuf));
 				BlockIdSet(&childblknos[1], GinPageGetOpaque(childpage)->rightlink);
-				XLogRegisterData((char *) childblknos,
+				XLogRegisterData(childblknos,
 								 sizeof(BlockIdData) * 2);
 			}
 
@@ -617,7 +617,7 @@ ginPlaceToPage(GinBtree btree, GinBtreeStack *stack,
 			if (BufferIsValid(childbuf))
 				XLogRegisterBuffer(3, childbuf, REGBUF_STANDARD);
 
-			XLogRegisterData((char *) &data, sizeof(ginxlogSplit));
+			XLogRegisterData(&data, sizeof(ginxlogSplit));
 
 			recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_SPLIT);
 
diff --git a/src/backend/access/gin/gindatapage.c b/src/backend/access/gin/gindatapage.c
index 662626efd82..6c2c6194720 100644
--- a/src/backend/access/gin/gindatapage.c
+++ b/src/backend/access/gin/gindatapage.c
@@ -63,7 +63,7 @@ typedef struct
 	 * If we need WAL data representing the reconstructed leaf page, it's
 	 * stored here by computeLeafRecompressWALData.
 	 */
-	char	   *walinfo;		/* buffer start */
+	void	   *walinfo;		/* buffer start */
 	int			walinfolen;		/* and length */
 } disassembledLeaf;
 
@@ -1173,7 +1173,7 @@ dataExecPlaceToPageInternal(GinBtree btree, Buffer buf, GinBtreeStack *stack,
 		data.newitem = *pitem;
 
 		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterBufData(0, (char *) &data,
+		XLogRegisterBufData(0, &data,
 							sizeof(ginxlogInsertDataInternal));
 	}
 }
@@ -1844,9 +1844,9 @@ createPostingTree(Relation index, ItemPointerData *items, uint32 nitems,
 		data.size = rootsize;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &data, sizeof(ginxlogCreatePostingTree));
+		XLogRegisterData(&data, sizeof(ginxlogCreatePostingTree));
 
-		XLogRegisterData((char *) GinDataLeafPageGetPostingList(page),
+		XLogRegisterData(GinDataLeafPageGetPostingList(page),
 						 rootsize);
 		XLogRegisterBuffer(0, buffer, REGBUF_WILL_INIT);
 
diff --git a/src/backend/access/gin/ginentrypage.c b/src/backend/access/gin/ginentrypage.c
index c668d809f60..ba6bbd562df 100644
--- a/src/backend/access/gin/ginentrypage.c
+++ b/src/backend/access/gin/ginentrypage.c
@@ -585,9 +585,9 @@ entryExecPlaceToPage(GinBtree btree, Buffer buf, GinBtreeStack *stack,
 		data.offset = off;
 
 		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterBufData(0, (char *) &data,
+		XLogRegisterBufData(0, &data,
 							offsetof(ginxlogInsertEntry, tuple));
-		XLogRegisterBufData(0, (char *) insertData->entry,
+		XLogRegisterBufData(0, insertData->entry,
 							IndexTupleSize(insertData->entry));
 	}
 }
diff --git a/src/backend/access/gin/ginfast.c b/src/backend/access/gin/ginfast.c
index 4ab815fefe0..f4ed949b90b 100644
--- a/src/backend/access/gin/ginfast.c
+++ b/src/backend/access/gin/ginfast.c
@@ -122,7 +122,7 @@ writeListPage(Relation index, Buffer buffer,
 		data.ntuples = ntuples;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &data, sizeof(ginxlogInsertListPage));
+		XLogRegisterData(&data, sizeof(ginxlogInsertListPage));
 
 		XLogRegisterBuffer(0, buffer, REGBUF_WILL_INIT);
 		XLogRegisterBufData(0, workspace.data, size);
@@ -431,7 +431,7 @@ ginHeapTupleFastInsert(GinState *ginstate, GinTupleCollector *collector)
 		memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
 
 		XLogRegisterBuffer(0, metabuffer, REGBUF_WILL_INIT | REGBUF_STANDARD);
-		XLogRegisterData((char *) &data, sizeof(ginxlogUpdateMeta));
+		XLogRegisterData(&data, sizeof(ginxlogUpdateMeta));
 
 		recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_UPDATE_META_PAGE);
 		PageSetLSN(metapage, recptr);
@@ -646,7 +646,7 @@ shiftList(Relation index, Buffer metabuffer, BlockNumber newHead,
 
 			memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
 
-			XLogRegisterData((char *) &data,
+			XLogRegisterData(&data,
 							 sizeof(ginxlogDeleteListPages));
 
 			recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_DELETE_LISTPAGE);
diff --git a/src/backend/access/gin/ginutil.c b/src/backend/access/gin/ginutil.c
index 2500d16b7bc..1f9e58c4f1f 100644
--- a/src/backend/access/gin/ginutil.c
+++ b/src/backend/access/gin/ginutil.c
@@ -689,7 +689,7 @@ ginUpdateStats(Relation index, const GinStatsData *stats, bool is_build)
 		memcpy(&data.metadata, metadata, sizeof(GinMetaPageData));
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &data, sizeof(ginxlogUpdateMeta));
+		XLogRegisterData(&data, sizeof(ginxlogUpdateMeta));
 		XLogRegisterBuffer(0, metabuffer, REGBUF_WILL_INIT | REGBUF_STANDARD);
 
 		recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_UPDATE_META_PAGE);
diff --git a/src/backend/access/gin/ginvacuum.c b/src/backend/access/gin/ginvacuum.c
index d98c54b7cf7..88d9b8dc13e 100644
--- a/src/backend/access/gin/ginvacuum.c
+++ b/src/backend/access/gin/ginvacuum.c
@@ -216,7 +216,7 @@ ginDeletePage(GinVacuumState *gvs, BlockNumber deleteBlkno, BlockNumber leftBlkn
 		data.rightLink = GinPageGetOpaque(page)->rightlink;
 		data.deleteXid = GinPageGetDeleteXid(page);
 
-		XLogRegisterData((char *) &data, sizeof(ginxlogDeletePage));
+		XLogRegisterData(&data, sizeof(ginxlogDeletePage));
 
 		recptr = XLogInsert(RM_GIN_ID, XLOG_GIN_DELETE_PAGE);
 		PageSetLSN(page, recptr);
diff --git a/src/backend/access/gist/gistxlog.c b/src/backend/access/gist/gistxlog.c
index 9d54e64787a..b354e4ba5d1 100644
--- a/src/backend/access/gist/gistxlog.c
+++ b/src/backend/access/gist/gistxlog.c
@@ -528,14 +528,14 @@ gistXLogSplit(bool page_is_leaf,
 	 * of buffer or data registrations here, make sure you modify the
 	 * XLogEnsureRecordSpace() calls accordingly!
 	 */
-	XLogRegisterData((char *) &xlrec, sizeof(gistxlogPageSplit));
+	XLogRegisterData(&xlrec, sizeof(gistxlogPageSplit));
 
 	i = 1;
 	for (ptr = dist; ptr; ptr = ptr->next)
 	{
 		XLogRegisterBuffer(i, ptr->buffer, REGBUF_WILL_INIT);
-		XLogRegisterBufData(i, (char *) &(ptr->block.num), sizeof(int));
-		XLogRegisterBufData(i, (char *) ptr->list, ptr->lenlist);
+		XLogRegisterBufData(i, &(ptr->block.num), sizeof(int));
+		XLogRegisterBufData(i, ptr->list, ptr->lenlist);
 		i++;
 	}
 
@@ -559,7 +559,7 @@ gistXLogPageDelete(Buffer buffer, FullTransactionId xid,
 	xlrec.downlinkOffset = downlinkOffset;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, SizeOfGistxlogPageDelete);
+	XLogRegisterData(&xlrec, SizeOfGistxlogPageDelete);
 
 	XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 	XLogRegisterBuffer(1, parentBuffer, REGBUF_STANDARD);
@@ -583,7 +583,7 @@ gistXLogAssignLSN(void)
 	 */
 	XLogBeginInsert();
 	XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
-	XLogRegisterData((char *) &dummy, sizeof(dummy));
+	XLogRegisterData(&dummy, sizeof(dummy));
 	return XLogInsert(RM_GIST_ID, XLOG_GIST_ASSIGN_LSN);
 }
 
@@ -609,7 +609,7 @@ gistXLogPageReuse(Relation rel, Relation heaprel,
 	xlrec_reuse.snapshotConflictHorizon = deleteXid;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec_reuse, SizeOfGistxlogPageReuse);
+	XLogRegisterData(&xlrec_reuse, SizeOfGistxlogPageReuse);
 
 	XLogInsert(RM_GIST_ID, XLOG_GIST_PAGE_REUSE);
 }
@@ -639,14 +639,14 @@ gistXLogUpdate(Buffer buffer,
 	xlrec.ntoinsert = ituplen;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, sizeof(gistxlogPageUpdate));
+	XLogRegisterData(&xlrec, sizeof(gistxlogPageUpdate));
 
 	XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
-	XLogRegisterBufData(0, (char *) todelete, sizeof(OffsetNumber) * ntodelete);
+	XLogRegisterBufData(0, todelete, sizeof(OffsetNumber) * ntodelete);
 
 	/* new tuples */
 	for (i = 0; i < ituplen; i++)
-		XLogRegisterBufData(0, (char *) (itup[i]), IndexTupleSize(itup[i]));
+		XLogRegisterBufData(0, itup[i], IndexTupleSize(itup[i]));
 
 	/*
 	 * Include a full page image of the child buf. (only necessary if a
@@ -678,14 +678,14 @@ gistXLogDelete(Buffer buffer, OffsetNumber *todelete, int ntodelete,
 	xlrec.ntodelete = ntodelete;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, SizeOfGistxlogDelete);
+	XLogRegisterData(&xlrec, SizeOfGistxlogDelete);
 
 	/*
 	 * We need the target-offsets array whether or not we store the whole
 	 * buffer, to allow us to find the snapshotConflictHorizon on a standby
 	 * server.
 	 */
-	XLogRegisterData((char *) todelete, ntodelete * sizeof(OffsetNumber));
+	XLogRegisterData(todelete, ntodelete * sizeof(OffsetNumber));
 
 	XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
diff --git a/src/backend/access/hash/hash.c b/src/backend/access/hash/hash.c
index 63b568e7f24..03cb8fbb70c 100644
--- a/src/backend/access/hash/hash.c
+++ b/src/backend/access/hash/hash.c
@@ -616,7 +616,7 @@ hashbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 		xlrec.ntuples = metap->hashm_ntuples;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfHashUpdateMetaPage);
+		XLogRegisterData(&xlrec, SizeOfHashUpdateMetaPage);
 
 		XLogRegisterBuffer(0, metabuf, REGBUF_STANDARD);
 
@@ -823,7 +823,7 @@ hashbucketcleanup(Relation rel, Bucket cur_bucket, Buffer bucket_buf,
 				xlrec.is_primary_bucket_page = (buf == bucket_buf);
 
 				XLogBeginInsert();
-				XLogRegisterData((char *) &xlrec, SizeOfHashDelete);
+				XLogRegisterData(&xlrec, SizeOfHashDelete);
 
 				/*
 				 * bucket buffer was not changed, but still needs to be
@@ -838,7 +838,7 @@ hashbucketcleanup(Relation rel, Bucket cur_bucket, Buffer bucket_buf,
 				}
 
 				XLogRegisterBuffer(1, buf, REGBUF_STANDARD);
-				XLogRegisterBufData(1, (char *) deletable,
+				XLogRegisterBufData(1, deletable,
 									ndeletable * sizeof(OffsetNumber));
 
 				recptr = XLogInsert(RM_HASH_ID, XLOG_HASH_DELETE);
diff --git a/src/backend/access/hash/hashinsert.c b/src/backend/access/hash/hashinsert.c
index 87fab13900b..10de1580dc2 100644
--- a/src/backend/access/hash/hashinsert.c
+++ b/src/backend/access/hash/hashinsert.c
@@ -221,12 +221,12 @@ _hash_doinsert(Relation rel, IndexTuple itup, Relation heapRel, bool sorted)
 		xlrec.offnum = itup_off;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfHashInsert);
+		XLogRegisterData(&xlrec, SizeOfHashInsert);
 
 		XLogRegisterBuffer(1, metabuf, REGBUF_STANDARD);
 
 		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterBufData(0, (char *) itup, IndexTupleSize(itup));
+		XLogRegisterBufData(0, itup, IndexTupleSize(itup));
 
 		recptr = XLogInsert(RM_HASH_ID, XLOG_HASH_INSERT);
 
@@ -436,14 +436,14 @@ _hash_vacuum_one_page(Relation rel, Relation hrel, Buffer metabuf, Buffer buf)
 
 			XLogBeginInsert();
 			XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-			XLogRegisterData((char *) &xlrec, SizeOfHashVacuumOnePage);
+			XLogRegisterData(&xlrec, SizeOfHashVacuumOnePage);
 
 			/*
 			 * We need the target-offsets array whether or not we store the
 			 * whole buffer, to allow us to find the snapshotConflictHorizon
 			 * on a standby server.
 			 */
-			XLogRegisterData((char *) deletable,
+			XLogRegisterData(deletable,
 							 ndeletable * sizeof(OffsetNumber));
 
 			XLogRegisterBuffer(1, metabuf, REGBUF_STANDARD);
diff --git a/src/backend/access/hash/hashovfl.c b/src/backend/access/hash/hashovfl.c
index 3fa2c5fe2ef..4f5fd3b2837 100644
--- a/src/backend/access/hash/hashovfl.c
+++ b/src/backend/access/hash/hashovfl.c
@@ -388,24 +388,24 @@ _hash_addovflpage(Relation rel, Buffer metabuf, Buffer buf, bool retain_pin)
 		xlrec.bmsize = metap->hashm_bmsize;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfHashAddOvflPage);
+		XLogRegisterData(&xlrec, SizeOfHashAddOvflPage);
 
 		XLogRegisterBuffer(0, ovflbuf, REGBUF_WILL_INIT);
-		XLogRegisterBufData(0, (char *) &pageopaque->hasho_bucket, sizeof(Bucket));
+		XLogRegisterBufData(0, &pageopaque->hasho_bucket, sizeof(Bucket));
 
 		XLogRegisterBuffer(1, buf, REGBUF_STANDARD);
 
 		if (BufferIsValid(mapbuf))
 		{
 			XLogRegisterBuffer(2, mapbuf, REGBUF_STANDARD);
-			XLogRegisterBufData(2, (char *) &bitmap_page_bit, sizeof(uint32));
+			XLogRegisterBufData(2, &bitmap_page_bit, sizeof(uint32));
 		}
 
 		if (BufferIsValid(newmapbuf))
 			XLogRegisterBuffer(3, newmapbuf, REGBUF_WILL_INIT);
 
 		XLogRegisterBuffer(4, metabuf, REGBUF_STANDARD);
-		XLogRegisterBufData(4, (char *) &metap->hashm_firstfree, sizeof(uint32));
+		XLogRegisterBufData(4, &metap->hashm_firstfree, sizeof(uint32));
 
 		recptr = XLogInsert(RM_HASH_ID, XLOG_HASH_ADD_OVFL_PAGE);
 
@@ -656,7 +656,7 @@ _hash_freeovflpage(Relation rel, Buffer bucketbuf, Buffer ovflbuf,
 		xlrec.is_prev_bucket_same_wrt = (wbuf == prevbuf);
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfHashSqueezePage);
+		XLogRegisterData(&xlrec, SizeOfHashSqueezePage);
 
 		/*
 		 * bucket buffer was not changed, but still needs to be registered to
@@ -676,10 +676,10 @@ _hash_freeovflpage(Relation rel, Buffer bucketbuf, Buffer ovflbuf,
 			/* Remember that wbuf is modified. */
 			mod_wbuf = true;
 
-			XLogRegisterBufData(1, (char *) itup_offsets,
+			XLogRegisterBufData(1, itup_offsets,
 								nitups * sizeof(OffsetNumber));
 			for (i = 0; i < nitups; i++)
-				XLogRegisterBufData(1, (char *) itups[i], tups_size[i]);
+				XLogRegisterBufData(1, itups[i], tups_size[i]);
 		}
 		else if (xlrec.is_prim_bucket_same_wrt || xlrec.is_prev_bucket_same_wrt)
 		{
@@ -721,12 +721,12 @@ _hash_freeovflpage(Relation rel, Buffer bucketbuf, Buffer ovflbuf,
 			XLogRegisterBuffer(4, nextbuf, REGBUF_STANDARD);
 
 		XLogRegisterBuffer(5, mapbuf, REGBUF_STANDARD);
-		XLogRegisterBufData(5, (char *) &bitmapbit, sizeof(uint32));
+		XLogRegisterBufData(5, &bitmapbit, sizeof(uint32));
 
 		if (update_metap)
 		{
 			XLogRegisterBuffer(6, metabuf, REGBUF_STANDARD);
-			XLogRegisterBufData(6, (char *) &metap->hashm_firstfree, sizeof(uint32));
+			XLogRegisterBufData(6, &metap->hashm_firstfree, sizeof(uint32));
 		}
 
 		recptr = XLogInsert(RM_HASH_ID, XLOG_HASH_SQUEEZE_PAGE);
@@ -993,7 +993,7 @@ _hash_squeezebucket(Relation rel,
 						xlrec.is_prim_bucket_same_wrt = (wbuf == bucket_buf);
 
 						XLogBeginInsert();
-						XLogRegisterData((char *) &xlrec, SizeOfHashMovePageContents);
+						XLogRegisterData(&xlrec, SizeOfHashMovePageContents);
 
 						/*
 						 * bucket buffer was not changed, but still needs to
@@ -1008,13 +1008,13 @@ _hash_squeezebucket(Relation rel,
 						}
 
 						XLogRegisterBuffer(1, wbuf, REGBUF_STANDARD);
-						XLogRegisterBufData(1, (char *) itup_offsets,
+						XLogRegisterBufData(1, itup_offsets,
 											nitups * sizeof(OffsetNumber));
 						for (i = 0; i < nitups; i++)
-							XLogRegisterBufData(1, (char *) itups[i], tups_size[i]);
+							XLogRegisterBufData(1, itups[i], tups_size[i]);
 
 						XLogRegisterBuffer(2, rbuf, REGBUF_STANDARD);
-						XLogRegisterBufData(2, (char *) deletable,
+						XLogRegisterBufData(2, deletable,
 											ndeletable * sizeof(OffsetNumber));
 
 						recptr = XLogInsert(RM_HASH_ID, XLOG_HASH_MOVE_PAGE_CONTENTS);
diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c
index 97efd4e14ab..b8e5bd005e5 100644
--- a/src/backend/access/hash/hashpage.c
+++ b/src/backend/access/hash/hashpage.c
@@ -394,7 +394,7 @@ _hash_init(Relation rel, double num_tuples, ForkNumber forkNum)
 		xlrec.ffactor = metap->hashm_ffactor;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfHashInitMetaPage);
+		XLogRegisterData(&xlrec, SizeOfHashInitMetaPage);
 		XLogRegisterBuffer(0, metabuf, REGBUF_WILL_INIT | REGBUF_STANDARD);
 
 		recptr = XLogInsert(RM_HASH_ID, XLOG_HASH_INIT_META_PAGE);
@@ -468,7 +468,7 @@ _hash_init(Relation rel, double num_tuples, ForkNumber forkNum)
 		xlrec.bmsize = metap->hashm_bmsize;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfHashInitBitmapPage);
+		XLogRegisterData(&xlrec, SizeOfHashInitBitmapPage);
 		XLogRegisterBuffer(0, bitmapbuf, REGBUF_WILL_INIT);
 
 		/*
@@ -916,21 +916,21 @@ _hash_expandtable(Relation rel, Buffer metabuf)
 		if (metap_update_masks)
 		{
 			xlrec.flags |= XLH_SPLIT_META_UPDATE_MASKS;
-			XLogRegisterBufData(2, (char *) &metap->hashm_lowmask, sizeof(uint32));
-			XLogRegisterBufData(2, (char *) &metap->hashm_highmask, sizeof(uint32));
+			XLogRegisterBufData(2, &metap->hashm_lowmask, sizeof(uint32));
+			XLogRegisterBufData(2, &metap->hashm_highmask, sizeof(uint32));
 		}
 
 		if (metap_update_splitpoint)
 		{
 			xlrec.flags |= XLH_SPLIT_META_UPDATE_SPLITPOINT;
-			XLogRegisterBufData(2, (char *) &metap->hashm_ovflpoint,
+			XLogRegisterBufData(2, &metap->hashm_ovflpoint,
 								sizeof(uint32));
 			XLogRegisterBufData(2,
-								(char *) &metap->hashm_spares[metap->hashm_ovflpoint],
+								&metap->hashm_spares[metap->hashm_ovflpoint],
 								sizeof(uint32));
 		}
 
-		XLogRegisterData((char *) &xlrec, SizeOfHashSplitAllocPage);
+		XLogRegisterData(&xlrec, SizeOfHashSplitAllocPage);
 
 		recptr = XLogInsert(RM_HASH_ID, XLOG_HASH_SPLIT_ALLOCATE_PAGE);
 
@@ -1304,7 +1304,7 @@ _hash_splitbucket(Relation rel,
 
 		XLogBeginInsert();
 
-		XLogRegisterData((char *) &xlrec, SizeOfHashSplitComplete);
+		XLogRegisterData(&xlrec, SizeOfHashSplitComplete);
 
 		XLogRegisterBuffer(0, bucket_obuf, REGBUF_STANDARD);
 		XLogRegisterBuffer(1, bucket_nbuf, REGBUF_STANDARD);
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index ea0a12b39af..6338a2f80d5 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -2133,7 +2133,7 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 		}
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfHeapInsert);
+		XLogRegisterData(&xlrec, SizeOfHeapInsert);
 
 		xlhdr.t_infomask2 = heaptup->t_data->t_infomask2;
 		xlhdr.t_infomask = heaptup->t_data->t_infomask;
@@ -2145,10 +2145,10 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
 		 * xl_heap_header in the xlog.
 		 */
 		XLogRegisterBuffer(0, buffer, REGBUF_STANDARD | bufflags);
-		XLogRegisterBufData(0, (char *) &xlhdr, SizeOfHeapHeader);
+		XLogRegisterBufData(0, &xlhdr, SizeOfHeapHeader);
 		/* PG73FORMAT: write bitmap [+ padding] [+ oid] + data */
 		XLogRegisterBufData(0,
-							(char *) heaptup->t_data + SizeofHeapTupleHeader,
+							((char *) heaptup->t_data) + SizeofHeapTupleHeader,
 							heaptup->t_len - SizeofHeapTupleHeader);
 
 		/* filtering by origin on a row level is much more efficient */
@@ -2542,7 +2542,7 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
 				bufflags |= REGBUF_KEEP_DATA;
 
 			XLogBeginInsert();
-			XLogRegisterData((char *) xlrec, tupledata - scratch.data);
+			XLogRegisterData(xlrec, tupledata - scratch.data);
 			XLogRegisterBuffer(0, buffer, REGBUF_STANDARD | bufflags);
 
 			XLogRegisterBufData(0, tupledata, totaldatalen);
@@ -3032,7 +3032,7 @@ heap_delete(Relation relation, ItemPointer tid,
 		}
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfHeapDelete);
+		XLogRegisterData(&xlrec, SizeOfHeapDelete);
 
 		XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
@@ -3045,8 +3045,8 @@ heap_delete(Relation relation, ItemPointer tid,
 			xlhdr.t_infomask = old_key_tuple->t_data->t_infomask;
 			xlhdr.t_hoff = old_key_tuple->t_data->t_hoff;
 
-			XLogRegisterData((char *) &xlhdr, SizeOfHeapHeader);
-			XLogRegisterData((char *) old_key_tuple->t_data
+			XLogRegisterData(&xlhdr, SizeOfHeapHeader);
+			XLogRegisterData(((char *) old_key_tuple->t_data)
 							 + SizeofHeapTupleHeader,
 							 old_key_tuple->t_len
 							 - SizeofHeapTupleHeader);
@@ -3811,7 +3811,7 @@ heap_update(Relation relation, ItemPointer otid, HeapTuple newtup,
 												  oldtup.t_data->t_infomask2);
 			xlrec.flags =
 				cleared_all_frozen ? XLH_LOCK_ALL_FROZEN_CLEARED : 0;
-			XLogRegisterData((char *) &xlrec, SizeOfHeapLock);
+			XLogRegisterData(&xlrec, SizeOfHeapLock);
 			recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_LOCK);
 			PageSetLSN(page, recptr);
 		}
@@ -5142,7 +5142,7 @@ heap_lock_tuple(Relation relation, HeapTuple tuple,
 		xlrec.infobits_set = compute_infobits(new_infomask,
 											  tuple->t_data->t_infomask2);
 		xlrec.flags = cleared_all_frozen ? XLH_LOCK_ALL_FROZEN_CLEARED : 0;
-		XLogRegisterData((char *) &xlrec, SizeOfHeapLock);
+		XLogRegisterData(&xlrec, SizeOfHeapLock);
 
 		/* we don't decode row locks atm, so no need to log the origin */
 
@@ -5895,7 +5895,7 @@ heap_lock_updated_tuple_rec(Relation rel, ItemPointer tid, TransactionId xid,
 			xlrec.flags =
 				cleared_all_frozen ? XLH_LOCK_ALL_FROZEN_CLEARED : 0;
 
-			XLogRegisterData((char *) &xlrec, SizeOfHeapLockUpdated);
+			XLogRegisterData(&xlrec, SizeOfHeapLockUpdated);
 
 			recptr = XLogInsert(RM_HEAP2_ID, XLOG_HEAP2_LOCK_UPDATED);
 
@@ -6048,7 +6048,7 @@ heap_finish_speculative(Relation relation, ItemPointer tid)
 		/* We want the same filtering on this as on a plain insert */
 		XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
 
-		XLogRegisterData((char *) &xlrec, SizeOfHeapConfirm);
+		XLogRegisterData(&xlrec, SizeOfHeapConfirm);
 		XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
 		recptr = XLogInsert(RM_HEAP_ID, XLOG_HEAP_CONFIRM);
@@ -6193,7 +6193,7 @@ heap_abort_speculative(Relation relation, ItemPointer tid)
 		xlrec.xmax = xid;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfHeapDelete);
+		XLogRegisterData(&xlrec, SizeOfHeapDelete);
 		XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
 		/* No replica identity & replication origin logged */
@@ -6489,9 +6489,9 @@ heap_inplace_update_and_unlock(Relation relation,
 		xlrec.nmsgs = nmsgs;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, MinSizeOfHeapInplace);
+		XLogRegisterData(&xlrec, MinSizeOfHeapInplace);
 		if (nmsgs != 0)
-			XLogRegisterData((char *) invalMessages,
+			XLogRegisterData(invalMessages,
 							 nmsgs * sizeof(SharedInvalidationMessage));
 
 		/* register block matching what buffer will look like after changes */
@@ -8722,7 +8722,7 @@ log_heap_visible(Relation rel, Buffer heap_buffer, Buffer vm_buffer,
 	if (RelationIsAccessibleInLogicalDecoding(rel))
 		xlrec.flags |= VISIBILITYMAP_XLOG_CATALOG_REL;
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, SizeOfHeapVisible);
+	XLogRegisterData(&xlrec, SizeOfHeapVisible);
 
 	XLogRegisterBuffer(0, vm_buffer, 0);
 
@@ -8873,7 +8873,7 @@ log_heap_update(Relation reln, Buffer oldbuf,
 	if (oldbuf != newbuf)
 		XLogRegisterBuffer(1, oldbuf, REGBUF_STANDARD);
 
-	XLogRegisterData((char *) &xlrec, SizeOfHeapUpdate);
+	XLogRegisterData(&xlrec, SizeOfHeapUpdate);
 
 	/*
 	 * Prepare WAL data for the new tuple.
@@ -8884,15 +8884,15 @@ log_heap_update(Relation reln, Buffer oldbuf,
 		{
 			prefix_suffix[0] = prefixlen;
 			prefix_suffix[1] = suffixlen;
-			XLogRegisterBufData(0, (char *) &prefix_suffix, sizeof(uint16) * 2);
+			XLogRegisterBufData(0, &prefix_suffix, sizeof(uint16) * 2);
 		}
 		else if (prefixlen > 0)
 		{
-			XLogRegisterBufData(0, (char *) &prefixlen, sizeof(uint16));
+			XLogRegisterBufData(0, &prefixlen, sizeof(uint16));
 		}
 		else
 		{
-			XLogRegisterBufData(0, (char *) &suffixlen, sizeof(uint16));
+			XLogRegisterBufData(0, &suffixlen, sizeof(uint16));
 		}
 	}
 
@@ -8906,7 +8906,7 @@ log_heap_update(Relation reln, Buffer oldbuf,
 	 *
 	 * The 'data' doesn't include the common prefix or suffix.
 	 */
-	XLogRegisterBufData(0, (char *) &xlhdr, SizeOfHeapHeader);
+	XLogRegisterBufData(0, &xlhdr, SizeOfHeapHeader);
 	if (prefixlen == 0)
 	{
 		XLogRegisterBufData(0,
@@ -8941,10 +8941,10 @@ log_heap_update(Relation reln, Buffer oldbuf,
 		xlhdr_idx.t_infomask = old_key_tuple->t_data->t_infomask;
 		xlhdr_idx.t_hoff = old_key_tuple->t_data->t_hoff;
 
-		XLogRegisterData((char *) &xlhdr_idx, SizeOfHeapHeader);
+		XLogRegisterData(&xlhdr_idx, SizeOfHeapHeader);
 
 		/* PG73FORMAT: write bitmap [+ padding] [+ oid] + data */
-		XLogRegisterData((char *) old_key_tuple->t_data + SizeofHeapTupleHeader,
+		XLogRegisterData(((char *) old_key_tuple->t_data) + SizeofHeapTupleHeader,
 						 old_key_tuple->t_len - SizeofHeapTupleHeader);
 	}
 
@@ -9021,7 +9021,7 @@ log_heap_new_cid(Relation relation, HeapTuple tup)
 	 * called us certainly did, but that's WAL-logged separately.
 	 */
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, SizeOfHeapNewCid);
+	XLogRegisterData(&xlrec, SizeOfHeapNewCid);
 
 	/* will be looked at irrespective of origin */
 
diff --git a/src/backend/access/heap/pruneheap.c b/src/backend/access/heap/pruneheap.c
index 5e2d2645dd2..a8025889be0 100644
--- a/src/backend/access/heap/pruneheap.c
+++ b/src/backend/access/heap/pruneheap.c
@@ -2093,9 +2093,9 @@ log_heap_prune_and_freeze(Relation relation, Buffer buffer,
 		nplans = heap_log_freeze_plan(frozen, nfrozen, plans, frz_offsets);
 
 		freeze_plans.nplans = nplans;
-		XLogRegisterBufData(0, (char *) &freeze_plans,
+		XLogRegisterBufData(0, &freeze_plans,
 							offsetof(xlhp_freeze_plans, plans));
-		XLogRegisterBufData(0, (char *) plans,
+		XLogRegisterBufData(0, plans,
 							sizeof(xlhp_freeze_plan) * nplans);
 	}
 	if (nredirected > 0)
@@ -2103,9 +2103,9 @@ log_heap_prune_and_freeze(Relation relation, Buffer buffer,
 		xlrec.flags |= XLHP_HAS_REDIRECTIONS;
 
 		redirect_items.ntargets = nredirected;
-		XLogRegisterBufData(0, (char *) &redirect_items,
+		XLogRegisterBufData(0, &redirect_items,
 							offsetof(xlhp_prune_items, data));
-		XLogRegisterBufData(0, (char *) redirected,
+		XLogRegisterBufData(0, redirected,
 							sizeof(OffsetNumber[2]) * nredirected);
 	}
 	if (ndead > 0)
@@ -2113,9 +2113,9 @@ log_heap_prune_and_freeze(Relation relation, Buffer buffer,
 		xlrec.flags |= XLHP_HAS_DEAD_ITEMS;
 
 		dead_items.ntargets = ndead;
-		XLogRegisterBufData(0, (char *) &dead_items,
+		XLogRegisterBufData(0, &dead_items,
 							offsetof(xlhp_prune_items, data));
-		XLogRegisterBufData(0, (char *) dead,
+		XLogRegisterBufData(0, dead,
 							sizeof(OffsetNumber) * ndead);
 	}
 	if (nunused > 0)
@@ -2123,13 +2123,13 @@ log_heap_prune_and_freeze(Relation relation, Buffer buffer,
 		xlrec.flags |= XLHP_HAS_NOW_UNUSED_ITEMS;
 
 		unused_items.ntargets = nunused;
-		XLogRegisterBufData(0, (char *) &unused_items,
+		XLogRegisterBufData(0, &unused_items,
 							offsetof(xlhp_prune_items, data));
-		XLogRegisterBufData(0, (char *) unused,
+		XLogRegisterBufData(0, unused,
 							sizeof(OffsetNumber) * nunused);
 	}
 	if (nfrozen > 0)
-		XLogRegisterBufData(0, (char *) frz_offsets,
+		XLogRegisterBufData(0, frz_offsets,
 							sizeof(OffsetNumber) * nfrozen);
 
 	/*
@@ -2147,9 +2147,9 @@ log_heap_prune_and_freeze(Relation relation, Buffer buffer,
 		Assert(nredirected == 0 && ndead == 0);
 		/* also, any items in 'unused' must've been LP_DEAD previously */
 	}
-	XLogRegisterData((char *) &xlrec, SizeOfHeapPrune);
+	XLogRegisterData(&xlrec, SizeOfHeapPrune);
 	if (TransactionIdIsValid(conflict_xid))
-		XLogRegisterData((char *) &conflict_xid, sizeof(TransactionId));
+		XLogRegisterData(&conflict_xid, sizeof(TransactionId));
 
 	switch (reason)
 	{
diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c
index 05a1cb4f5e6..e6d2b5fced1 100644
--- a/src/backend/access/heap/rewriteheap.c
+++ b/src/backend/access/heap/rewriteheap.c
@@ -887,7 +887,7 @@ logical_heap_rewrite_flush_mappings(RewriteState state)
 		src->off += len;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) (&xlrec), sizeof(xlrec));
+		XLogRegisterData(&xlrec, sizeof(xlrec));
 		XLogRegisterData(waldata_start, len);
 
 		/* write xlog record */
diff --git a/src/backend/access/nbtree/nbtdedup.c b/src/backend/access/nbtree/nbtdedup.c
index 53363ee695a..cbe73675f86 100644
--- a/src/backend/access/nbtree/nbtdedup.c
+++ b/src/backend/access/nbtree/nbtdedup.c
@@ -252,14 +252,14 @@ _bt_dedup_pass(Relation rel, Buffer buf, IndexTuple newitem, Size newitemsz,
 
 		XLogBeginInsert();
 		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_dedup, SizeOfBtreeDedup);
+		XLogRegisterData(&xlrec_dedup, SizeOfBtreeDedup);
 
 		/*
 		 * The intervals array is not in the buffer, but pretend that it is.
 		 * When XLogInsert stores the whole buffer, the array need not be
 		 * stored too.
 		 */
-		XLogRegisterBufData(0, (char *) state->intervals,
+		XLogRegisterBufData(0, state->intervals,
 							state->nintervals * sizeof(BTDedupInterval));
 
 		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_DEDUP);
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 3eddbcf3a82..19ce79227b7 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -1320,7 +1320,7 @@ _bt_insertonpg(Relation rel,
 			xlrec.offnum = newitemoff;
 
 			XLogBeginInsert();
-			XLogRegisterData((char *) &xlrec, SizeOfBtreeInsert);
+			XLogRegisterData(&xlrec, SizeOfBtreeInsert);
 
 			if (isleaf && postingoff == 0)
 			{
@@ -1358,7 +1358,7 @@ _bt_insertonpg(Relation rel,
 
 					XLogRegisterBuffer(2, metabuf,
 									   REGBUF_WILL_INIT | REGBUF_STANDARD);
-					XLogRegisterBufData(2, (char *) &xlmeta,
+					XLogRegisterBufData(2, &xlmeta,
 										sizeof(xl_btree_metadata));
 				}
 			}
@@ -1367,7 +1367,7 @@ _bt_insertonpg(Relation rel,
 			if (postingoff == 0)
 			{
 				/* Just log itup from caller */
-				XLogRegisterBufData(0, (char *) itup, IndexTupleSize(itup));
+				XLogRegisterBufData(0, itup, IndexTupleSize(itup));
 			}
 			else
 			{
@@ -1381,8 +1381,8 @@ _bt_insertonpg(Relation rel,
 				 */
 				upostingoff = postingoff;
 
-				XLogRegisterBufData(0, (char *) &upostingoff, sizeof(uint16));
-				XLogRegisterBufData(0, (char *) origitup,
+				XLogRegisterBufData(0, &upostingoff, sizeof(uint16));
+				XLogRegisterBufData(0, origitup,
 									IndexTupleSize(origitup));
 			}
 
@@ -1979,7 +1979,7 @@ _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
 			xlrec.postingoff = postingoff;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfBtreeSplit);
+		XLogRegisterData(&xlrec, SizeOfBtreeSplit);
 
 		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
 		XLogRegisterBuffer(1, rbuf, REGBUF_WILL_INIT);
@@ -2017,13 +2017,13 @@ _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
 		 * newitem-logged case).
 		 */
 		if (newitemonleft && xlrec.postingoff == 0)
-			XLogRegisterBufData(0, (char *) newitem, newitemsz);
+			XLogRegisterBufData(0, newitem, newitemsz);
 		else if (xlrec.postingoff != 0)
 		{
 			Assert(isleaf);
 			Assert(newitemonleft || firstrightoff == newitemoff);
 			Assert(newitemsz == IndexTupleSize(orignewitem));
-			XLogRegisterBufData(0, (char *) orignewitem, newitemsz);
+			XLogRegisterBufData(0, orignewitem, newitemsz);
 		}
 
 		/* Log the left page's new high key */
@@ -2033,7 +2033,7 @@ _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
 			itemid = PageGetItemId(origpage, P_HIKEY);
 			lefthighkey = (IndexTuple) PageGetItem(origpage, itemid);
 		}
-		XLogRegisterBufData(0, (char *) lefthighkey,
+		XLogRegisterBufData(0, lefthighkey,
 							MAXALIGN(IndexTupleSize(lefthighkey)));
 
 		/*
@@ -2047,7 +2047,7 @@ _bt_split(Relation rel, Relation heaprel, BTScanInsert itup_key, Buffer buf,
 		 * _bt_restore_page().
 		 */
 		XLogRegisterBufData(1,
-							(char *) rightpage + ((PageHeader) rightpage)->pd_upper,
+							((char *) rightpage) + ((PageHeader) rightpage)->pd_upper,
 							((PageHeader) rightpage)->pd_special - ((PageHeader) rightpage)->pd_upper);
 
 		xlinfo = newitemonleft ? XLOG_BTREE_SPLIT_L : XLOG_BTREE_SPLIT_R;
@@ -2564,7 +2564,7 @@ _bt_newlevel(Relation rel, Relation heaprel, Buffer lbuf, Buffer rbuf)
 		xlrec.level = metad->btm_level;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfBtreeNewroot);
+		XLogRegisterData(&xlrec, SizeOfBtreeNewroot);
 
 		XLogRegisterBuffer(0, rootbuf, REGBUF_WILL_INIT);
 		XLogRegisterBuffer(1, lbuf, REGBUF_STANDARD);
@@ -2579,14 +2579,14 @@ _bt_newlevel(Relation rel, Relation heaprel, Buffer lbuf, Buffer rbuf)
 		md.last_cleanup_num_delpages = metad->btm_last_cleanup_num_delpages;
 		md.allequalimage = metad->btm_allequalimage;
 
-		XLogRegisterBufData(2, (char *) &md, sizeof(xl_btree_metadata));
+		XLogRegisterBufData(2, &md, sizeof(xl_btree_metadata));
 
 		/*
 		 * Direct access to page is not good but faster - we should implement
 		 * some new func in page API.
 		 */
 		XLogRegisterBufData(0,
-							(char *) rootpage + ((PageHeader) rootpage)->pd_upper,
+							((char *) rootpage) + ((PageHeader) rootpage)->pd_upper,
 							((PageHeader) rootpage)->pd_special -
 							((PageHeader) rootpage)->pd_upper);
 
diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c
index 5321e256b1a..c79dd38ee18 100644
--- a/src/backend/access/nbtree/nbtpage.c
+++ b/src/backend/access/nbtree/nbtpage.c
@@ -299,7 +299,7 @@ _bt_set_cleanup_info(Relation rel, BlockNumber num_delpages)
 		md.last_cleanup_num_delpages = num_delpages;
 		md.allequalimage = metad->btm_allequalimage;
 
-		XLogRegisterBufData(0, (char *) &md, sizeof(xl_btree_metadata));
+		XLogRegisterBufData(0, &md, sizeof(xl_btree_metadata));
 
 		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_META_CLEANUP);
 
@@ -488,12 +488,12 @@ _bt_getroot(Relation rel, Relation heaprel, int access)
 			md.last_cleanup_num_delpages = 0;
 			md.allequalimage = metad->btm_allequalimage;
 
-			XLogRegisterBufData(2, (char *) &md, sizeof(xl_btree_metadata));
+			XLogRegisterBufData(2, &md, sizeof(xl_btree_metadata));
 
 			xlrec.rootblk = rootblkno;
 			xlrec.level = 0;
 
-			XLogRegisterData((char *) &xlrec, SizeOfBtreeNewroot);
+			XLogRegisterData(&xlrec, SizeOfBtreeNewroot);
 
 			recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_NEWROOT);
 
@@ -948,7 +948,7 @@ _bt_allocbuf(Relation rel, Relation heaprel)
 						RelationIsAccessibleInLogicalDecoding(heaprel);
 
 					XLogBeginInsert();
-					XLogRegisterData((char *) &xlrec_reuse, SizeOfBtreeReusePage);
+					XLogRegisterData(&xlrec_reuse, SizeOfBtreeReusePage);
 
 					XLogInsert(RM_BTREE_ID, XLOG_BTREE_REUSE_PAGE);
 				}
@@ -1234,15 +1234,15 @@ _bt_delitems_vacuum(Relation rel, Buffer buf,
 
 		XLogBeginInsert();
 		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_vacuum, SizeOfBtreeVacuum);
+		XLogRegisterData(&xlrec_vacuum, SizeOfBtreeVacuum);
 
 		if (ndeletable > 0)
-			XLogRegisterBufData(0, (char *) deletable,
+			XLogRegisterBufData(0, deletable,
 								ndeletable * sizeof(OffsetNumber));
 
 		if (nupdatable > 0)
 		{
-			XLogRegisterBufData(0, (char *) updatedoffsets,
+			XLogRegisterBufData(0, updatedoffsets,
 								nupdatable * sizeof(OffsetNumber));
 			XLogRegisterBufData(0, updatedbuf, updatedbuflen);
 		}
@@ -1353,15 +1353,15 @@ _bt_delitems_delete(Relation rel, Buffer buf,
 
 		XLogBeginInsert();
 		XLogRegisterBuffer(0, buf, REGBUF_STANDARD);
-		XLogRegisterData((char *) &xlrec_delete, SizeOfBtreeDelete);
+		XLogRegisterData(&xlrec_delete, SizeOfBtreeDelete);
 
 		if (ndeletable > 0)
-			XLogRegisterBufData(0, (char *) deletable,
+			XLogRegisterBufData(0, deletable,
 								ndeletable * sizeof(OffsetNumber));
 
 		if (nupdatable > 0)
 		{
-			XLogRegisterBufData(0, (char *) updatedoffsets,
+			XLogRegisterBufData(0, updatedoffsets,
 								nupdatable * sizeof(OffsetNumber));
 			XLogRegisterBufData(0, updatedbuf, updatedbuflen);
 		}
@@ -2269,7 +2269,7 @@ _bt_mark_page_halfdead(Relation rel, Relation heaprel, Buffer leafbuf,
 		xlrec.leftblk = opaque->btpo_prev;
 		xlrec.rightblk = opaque->btpo_next;
 
-		XLogRegisterData((char *) &xlrec, SizeOfBtreeMarkPageHalfDead);
+		XLogRegisterData(&xlrec, SizeOfBtreeMarkPageHalfDead);
 
 		recptr = XLogInsert(RM_BTREE_ID, XLOG_BTREE_MARK_PAGE_HALFDEAD);
 
@@ -2694,7 +2694,7 @@ _bt_unlink_halfdead_page(Relation rel, Buffer leafbuf, BlockNumber scanblkno,
 		xlrec.leafrightsib = leafrightsib;
 		xlrec.leaftopparent = leaftopparent;
 
-		XLogRegisterData((char *) &xlrec, SizeOfBtreeUnlinkPage);
+		XLogRegisterData(&xlrec, SizeOfBtreeUnlinkPage);
 
 		if (BufferIsValid(metabuf))
 		{
@@ -2709,7 +2709,7 @@ _bt_unlink_halfdead_page(Relation rel, Buffer leafbuf, BlockNumber scanblkno,
 			xlmeta.last_cleanup_num_delpages = metad->btm_last_cleanup_num_delpages;
 			xlmeta.allequalimage = metad->btm_allequalimage;
 
-			XLogRegisterBufData(4, (char *) &xlmeta, sizeof(xl_btree_metadata));
+			XLogRegisterBufData(4, &xlmeta, sizeof(xl_btree_metadata));
 			xlinfo = XLOG_BTREE_UNLINK_PAGE_META;
 		}
 		else
diff --git a/src/backend/access/spgist/spgdoinsert.c b/src/backend/access/spgist/spgdoinsert.c
index 58c06ef2dc4..af6b27b2135 100644
--- a/src/backend/access/spgist/spgdoinsert.c
+++ b/src/backend/access/spgist/spgdoinsert.c
@@ -295,8 +295,8 @@ addLeafTuple(Relation index, SpGistState *state, SpGistLeafTuple leafTuple,
 		int			flags;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, sizeof(xlrec));
-		XLogRegisterData((char *) leafTuple, leafTuple->size);
+		XLogRegisterData(&xlrec, sizeof(xlrec));
+		XLogRegisterData(leafTuple, leafTuple->size);
 
 		flags = REGBUF_STANDARD;
 		if (xlrec.newPage)
@@ -532,12 +532,12 @@ moveLeafs(Relation index, SpGistState *state,
 		xlrec.nodeI = parent->node;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfSpgxlogMoveLeafs);
-		XLogRegisterData((char *) toDelete,
+		XLogRegisterData(&xlrec, SizeOfSpgxlogMoveLeafs);
+		XLogRegisterData(toDelete,
 						 sizeof(OffsetNumber) * nDelete);
-		XLogRegisterData((char *) toInsert,
+		XLogRegisterData(toInsert,
 						 sizeof(OffsetNumber) * nInsert);
-		XLogRegisterData((char *) leafdata, leafptr - leafdata);
+		XLogRegisterData(leafdata, leafptr - leafdata);
 
 		XLogRegisterBuffer(0, current->buffer, REGBUF_STANDARD);
 		XLogRegisterBuffer(1, nbuf, REGBUF_STANDARD | (xlrec.newPage ? REGBUF_WILL_INIT : 0));
@@ -1365,15 +1365,15 @@ doPickSplit(Relation index, SpGistState *state,
 		XLogBeginInsert();
 
 		xlrec.nInsert = nToInsert;
-		XLogRegisterData((char *) &xlrec, SizeOfSpgxlogPickSplit);
+		XLogRegisterData(&xlrec, SizeOfSpgxlogPickSplit);
 
-		XLogRegisterData((char *) toDelete,
+		XLogRegisterData(toDelete,
 						 sizeof(OffsetNumber) * xlrec.nDelete);
-		XLogRegisterData((char *) toInsert,
+		XLogRegisterData(toInsert,
 						 sizeof(OffsetNumber) * xlrec.nInsert);
-		XLogRegisterData((char *) leafPageSelect,
+		XLogRegisterData(leafPageSelect,
 						 sizeof(uint8) * xlrec.nInsert);
-		XLogRegisterData((char *) innerTuple, innerTuple->size);
+		XLogRegisterData(innerTuple, innerTuple->size);
 		XLogRegisterData(leafdata, leafptr - leafdata);
 
 		/* Old leaf page */
@@ -1559,8 +1559,8 @@ spgAddNodeAction(Relation index, SpGistState *state,
 			XLogRecPtr	recptr;
 
 			XLogBeginInsert();
-			XLogRegisterData((char *) &xlrec, sizeof(xlrec));
-			XLogRegisterData((char *) newInnerTuple, newInnerTuple->size);
+			XLogRegisterData(&xlrec, sizeof(xlrec));
+			XLogRegisterData(newInnerTuple, newInnerTuple->size);
 
 			XLogRegisterBuffer(0, current->buffer, REGBUF_STANDARD);
 
@@ -1685,8 +1685,8 @@ spgAddNodeAction(Relation index, SpGistState *state,
 			if (xlrec.parentBlk == 2)
 				XLogRegisterBuffer(2, parent->buffer, REGBUF_STANDARD);
 
-			XLogRegisterData((char *) &xlrec, sizeof(xlrec));
-			XLogRegisterData((char *) newInnerTuple, newInnerTuple->size);
+			XLogRegisterData(&xlrec, sizeof(xlrec));
+			XLogRegisterData(newInnerTuple, newInnerTuple->size);
 
 			recptr = XLogInsert(RM_SPGIST_ID, XLOG_SPGIST_ADD_NODE);
 
@@ -1868,9 +1868,9 @@ spgSplitNodeAction(Relation index, SpGistState *state,
 		XLogRecPtr	recptr;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, sizeof(xlrec));
-		XLogRegisterData((char *) prefixTuple, prefixTuple->size);
-		XLogRegisterData((char *) postfixTuple, postfixTuple->size);
+		XLogRegisterData(&xlrec, sizeof(xlrec));
+		XLogRegisterData(prefixTuple, prefixTuple->size);
+		XLogRegisterData(postfixTuple, postfixTuple->size);
 
 		XLogRegisterBuffer(0, current->buffer, REGBUF_STANDARD);
 		if (newBuffer != InvalidBuffer)
diff --git a/src/backend/access/spgist/spgvacuum.c b/src/backend/access/spgist/spgvacuum.c
index 894aefa19e1..5836f558b69 100644
--- a/src/backend/access/spgist/spgvacuum.c
+++ b/src/backend/access/spgist/spgvacuum.c
@@ -380,14 +380,14 @@ vacuumLeafPage(spgBulkDeleteState *bds, Relation index, Buffer buffer,
 
 		STORE_STATE(&bds->spgstate, xlrec.stateSrc);
 
-		XLogRegisterData((char *) &xlrec, SizeOfSpgxlogVacuumLeaf);
+		XLogRegisterData(&xlrec, SizeOfSpgxlogVacuumLeaf);
 		/* sizeof(xlrec) should be a multiple of sizeof(OffsetNumber) */
-		XLogRegisterData((char *) toDead, sizeof(OffsetNumber) * xlrec.nDead);
-		XLogRegisterData((char *) toPlaceholder, sizeof(OffsetNumber) * xlrec.nPlaceholder);
-		XLogRegisterData((char *) moveSrc, sizeof(OffsetNumber) * xlrec.nMove);
-		XLogRegisterData((char *) moveDest, sizeof(OffsetNumber) * xlrec.nMove);
-		XLogRegisterData((char *) chainSrc, sizeof(OffsetNumber) * xlrec.nChain);
-		XLogRegisterData((char *) chainDest, sizeof(OffsetNumber) * xlrec.nChain);
+		XLogRegisterData(toDead, sizeof(OffsetNumber) * xlrec.nDead);
+		XLogRegisterData(toPlaceholder, sizeof(OffsetNumber) * xlrec.nPlaceholder);
+		XLogRegisterData(moveSrc, sizeof(OffsetNumber) * xlrec.nMove);
+		XLogRegisterData(moveDest, sizeof(OffsetNumber) * xlrec.nMove);
+		XLogRegisterData(chainSrc, sizeof(OffsetNumber) * xlrec.nChain);
+		XLogRegisterData(chainDest, sizeof(OffsetNumber) * xlrec.nChain);
 
 		XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
 
@@ -465,9 +465,9 @@ vacuumLeafRoot(spgBulkDeleteState *bds, Relation index, Buffer buffer)
 		/* Prepare WAL record */
 		STORE_STATE(&bds->spgstate, xlrec.stateSrc);
 
-		XLogRegisterData((char *) &xlrec, SizeOfSpgxlogVacuumRoot);
+		XLogRegisterData(&xlrec, SizeOfSpgxlogVacuumRoot);
 		/* sizeof(xlrec) should be a multiple of sizeof(OffsetNumber) */
-		XLogRegisterData((char *) toDelete,
+		XLogRegisterData(toDelete,
 						 sizeof(OffsetNumber) * xlrec.nDelete);
 
 		XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
@@ -600,8 +600,8 @@ vacuumRedirectAndPlaceholder(Relation index, Relation heaprel, Buffer buffer)
 
 		XLogBeginInsert();
 
-		XLogRegisterData((char *) &xlrec, SizeOfSpgxlogVacuumRedirect);
-		XLogRegisterData((char *) itemToPlaceholder,
+		XLogRegisterData(&xlrec, SizeOfSpgxlogVacuumRedirect);
+		XLogRegisterData(itemToPlaceholder,
 						 sizeof(OffsetNumber) * xlrec.nToPlaceholder);
 
 		XLogRegisterBuffer(0, buffer, REGBUF_STANDARD);
diff --git a/src/backend/access/transam/clog.c b/src/backend/access/transam/clog.c
index 0d556c00b8c..48f10bec91e 100644
--- a/src/backend/access/transam/clog.c
+++ b/src/backend/access/transam/clog.c
@@ -1074,7 +1074,7 @@ static void
 WriteZeroPageXlogRec(int64 pageno)
 {
 	XLogBeginInsert();
-	XLogRegisterData((char *) (&pageno), sizeof(pageno));
+	XLogRegisterData(&pageno, sizeof(pageno));
 	(void) XLogInsert(RM_CLOG_ID, CLOG_ZEROPAGE);
 }
 
@@ -1095,7 +1095,7 @@ WriteTruncateXlogRec(int64 pageno, TransactionId oldestXact, Oid oldestXactDb)
 	xlrec.oldestXactDb = oldestXactDb;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) (&xlrec), sizeof(xl_clog_truncate));
+	XLogRegisterData(&xlrec, sizeof(xl_clog_truncate));
 	recptr = XLogInsert(RM_CLOG_ID, CLOG_TRUNCATE);
 	XLogFlush(recptr);
 }
diff --git a/src/backend/access/transam/commit_ts.c b/src/backend/access/transam/commit_ts.c
index 95049acd0b5..113fae1437a 100644
--- a/src/backend/access/transam/commit_ts.c
+++ b/src/backend/access/transam/commit_ts.c
@@ -989,7 +989,7 @@ static void
 WriteZeroPageXlogRec(int64 pageno)
 {
 	XLogBeginInsert();
-	XLogRegisterData((char *) (&pageno), sizeof(pageno));
+	XLogRegisterData(&pageno, sizeof(pageno));
 	(void) XLogInsert(RM_COMMIT_TS_ID, COMMIT_TS_ZEROPAGE);
 }
 
@@ -1005,7 +1005,7 @@ WriteTruncateXlogRec(int64 pageno, TransactionId oldestXid)
 	xlrec.oldestXid = oldestXid;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) (&xlrec), SizeOfCommitTsTruncate);
+	XLogRegisterData(&xlrec, SizeOfCommitTsTruncate);
 	(void) XLogInsert(RM_COMMIT_TS_ID, COMMIT_TS_TRUNCATE);
 }
 
diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
index 27ccdf9500f..c1e2c42e1bb 100644
--- a/src/backend/access/transam/multixact.c
+++ b/src/backend/access/transam/multixact.c
@@ -886,8 +886,8 @@ MultiXactIdCreateFromMembers(int nmembers, MultiXactMember *members)
 	 * Not clear that it's worth the trouble though.
 	 */
 	XLogBeginInsert();
-	XLogRegisterData((char *) (&xlrec), SizeOfMultiXactCreate);
-	XLogRegisterData((char *) members, nmembers * sizeof(MultiXactMember));
+	XLogRegisterData(&xlrec, SizeOfMultiXactCreate);
+	XLogRegisterData(members, nmembers * sizeof(MultiXactMember));
 
 	(void) XLogInsert(RM_MULTIXACT_ID, XLOG_MULTIXACT_CREATE_ID);
 
@@ -3355,7 +3355,7 @@ static void
 WriteMZeroPageXlogRec(int64 pageno, uint8 info)
 {
 	XLogBeginInsert();
-	XLogRegisterData((char *) (&pageno), sizeof(pageno));
+	XLogRegisterData(&pageno, sizeof(pageno));
 	(void) XLogInsert(RM_MULTIXACT_ID, info);
 }
 
@@ -3382,7 +3382,7 @@ WriteMTruncateXlogRec(Oid oldestMultiDB,
 	xlrec.endTruncMemb = endTruncMemb;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) (&xlrec), SizeOfMultiXactTruncate);
+	XLogRegisterData(&xlrec, SizeOfMultiXactTruncate);
 	recptr = XLogInsert(RM_MULTIXACT_ID, XLOG_MULTIXACT_TRUNCATE_ID);
 	XLogFlush(recptr);
 }
diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
index d331ab90d78..1b4f21a88d3 100644
--- a/src/backend/access/transam/xact.c
+++ b/src/backend/access/transam/xact.c
@@ -770,8 +770,8 @@ AssignTransactionId(TransactionState s)
 			xlrec.nsubxacts = nUnreportedXids;
 
 			XLogBeginInsert();
-			XLogRegisterData((char *) &xlrec, MinSizeOfXactAssignment);
-			XLogRegisterData((char *) unreportedXids,
+			XLogRegisterData(&xlrec, MinSizeOfXactAssignment);
+			XLogRegisterData(unreportedXids,
 							 nUnreportedXids * sizeof(TransactionId));
 
 			(void) XLogInsert(RM_XACT_ID, XLOG_XACT_ASSIGNMENT);
@@ -5909,54 +5909,54 @@ XactLogCommitRecord(TimestampTz commit_time,
 
 	XLogBeginInsert();
 
-	XLogRegisterData((char *) (&xlrec), sizeof(xl_xact_commit));
+	XLogRegisterData(&xlrec, sizeof(xl_xact_commit));
 
 	if (xl_xinfo.xinfo != 0)
-		XLogRegisterData((char *) (&xl_xinfo.xinfo), sizeof(xl_xinfo.xinfo));
+		XLogRegisterData(&xl_xinfo.xinfo, sizeof(xl_xinfo.xinfo));
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
-		XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));
+		XLogRegisterData(&xl_dbinfo, sizeof(xl_dbinfo));
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
 	{
-		XLogRegisterData((char *) (&xl_subxacts),
+		XLogRegisterData(&xl_subxacts,
 						 MinSizeOfXactSubxacts);
-		XLogRegisterData((char *) subxacts,
+		XLogRegisterData(subxacts,
 						 nsubxacts * sizeof(TransactionId));
 	}
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
 	{
-		XLogRegisterData((char *) (&xl_relfilelocators),
+		XLogRegisterData(&xl_relfilelocators,
 						 MinSizeOfXactRelfileLocators);
-		XLogRegisterData((char *) rels,
+		XLogRegisterData(rels,
 						 nrels * sizeof(RelFileLocator));
 	}
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
 	{
-		XLogRegisterData((char *) (&xl_dropped_stats),
+		XLogRegisterData(&xl_dropped_stats,
 						 MinSizeOfXactStatsItems);
-		XLogRegisterData((char *) droppedstats,
+		XLogRegisterData(droppedstats,
 						 ndroppedstats * sizeof(xl_xact_stats_item));
 	}
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_INVALS)
 	{
-		XLogRegisterData((char *) (&xl_invals), MinSizeOfXactInvals);
-		XLogRegisterData((char *) msgs,
+		XLogRegisterData(&xl_invals, MinSizeOfXactInvals);
+		XLogRegisterData(msgs,
 						 nmsgs * sizeof(SharedInvalidationMessage));
 	}
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
 	{
-		XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
+		XLogRegisterData(&xl_twophase, sizeof(xl_xact_twophase));
 		if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
 			XLogRegisterData(twophase_gid, strlen(twophase_gid) + 1);
 	}
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
-		XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));
+		XLogRegisterData(&xl_origin, sizeof(xl_xact_origin));
 
 	/* we allow filtering by xacts */
 	XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
@@ -6062,47 +6062,47 @@ XactLogAbortRecord(TimestampTz abort_time,
 
 	XLogBeginInsert();
 
-	XLogRegisterData((char *) (&xlrec), MinSizeOfXactAbort);
+	XLogRegisterData(&xlrec, MinSizeOfXactAbort);
 
 	if (xl_xinfo.xinfo != 0)
-		XLogRegisterData((char *) (&xl_xinfo), sizeof(xl_xinfo));
+		XLogRegisterData(&xl_xinfo, sizeof(xl_xinfo));
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_DBINFO)
-		XLogRegisterData((char *) (&xl_dbinfo), sizeof(xl_dbinfo));
+		XLogRegisterData(&xl_dbinfo, sizeof(xl_dbinfo));
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_SUBXACTS)
 	{
-		XLogRegisterData((char *) (&xl_subxacts),
+		XLogRegisterData(&xl_subxacts,
 						 MinSizeOfXactSubxacts);
-		XLogRegisterData((char *) subxacts,
+		XLogRegisterData(subxacts,
 						 nsubxacts * sizeof(TransactionId));
 	}
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_RELFILELOCATORS)
 	{
-		XLogRegisterData((char *) (&xl_relfilelocators),
+		XLogRegisterData(&xl_relfilelocators,
 						 MinSizeOfXactRelfileLocators);
-		XLogRegisterData((char *) rels,
+		XLogRegisterData(rels,
 						 nrels * sizeof(RelFileLocator));
 	}
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_DROPPED_STATS)
 	{
-		XLogRegisterData((char *) (&xl_dropped_stats),
+		XLogRegisterData(&xl_dropped_stats,
 						 MinSizeOfXactStatsItems);
-		XLogRegisterData((char *) droppedstats,
+		XLogRegisterData(droppedstats,
 						 ndroppedstats * sizeof(xl_xact_stats_item));
 	}
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_TWOPHASE)
 	{
-		XLogRegisterData((char *) (&xl_twophase), sizeof(xl_xact_twophase));
+		XLogRegisterData(&xl_twophase, sizeof(xl_xact_twophase));
 		if (xl_xinfo.xinfo & XACT_XINFO_HAS_GID)
 			XLogRegisterData(twophase_gid, strlen(twophase_gid) + 1);
 	}
 
 	if (xl_xinfo.xinfo & XACT_XINFO_HAS_ORIGIN)
-		XLogRegisterData((char *) (&xl_origin), sizeof(xl_xact_origin));
+		XLogRegisterData(&xl_origin, sizeof(xl_xact_origin));
 
 	/* Include the replication origin */
 	XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index 124676b460a..d123882ffa1 100644
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -7078,7 +7078,7 @@ CreateCheckPoint(int flags)
 	{
 		/* Include WAL level in record for WAL summarizer's benefit. */
 		XLogBeginInsert();
-		XLogRegisterData((char *) &wal_level, sizeof(wal_level));
+		XLogRegisterData(&wal_level, sizeof(wal_level));
 		(void) XLogInsert(RM_XLOG_ID, XLOG_CHECKPOINT_REDO);
 
 		/*
@@ -7231,7 +7231,7 @@ CreateCheckPoint(int flags)
 	 * Now insert the checkpoint record into XLOG.
 	 */
 	XLogBeginInsert();
-	XLogRegisterData((char *) (&checkPoint), sizeof(checkPoint));
+	XLogRegisterData(&checkPoint, sizeof(checkPoint));
 	recptr = XLogInsert(RM_XLOG_ID,
 						shutdown ? XLOG_CHECKPOINT_SHUTDOWN :
 						XLOG_CHECKPOINT_ONLINE);
@@ -7413,7 +7413,7 @@ CreateEndOfRecoveryRecord(void)
 	START_CRIT_SECTION();
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, sizeof(xl_end_of_recovery));
+	XLogRegisterData(&xlrec, sizeof(xl_end_of_recovery));
 	recptr = XLogInsert(RM_XLOG_ID, XLOG_END_OF_RECOVERY);
 
 	XLogFlush(recptr);
@@ -7506,7 +7506,7 @@ CreateOverwriteContrecordRecord(XLogRecPtr aborted_lsn, XLogRecPtr pagePtr,
 	XLogBeginInsert();
 	xlrec.overwritten_lsn = aborted_lsn;
 	xlrec.overwrite_time = GetCurrentTimestamp();
-	XLogRegisterData((char *) &xlrec, sizeof(xl_overwrite_contrecord));
+	XLogRegisterData(&xlrec, sizeof(xl_overwrite_contrecord));
 	recptr = XLogInsert(RM_XLOG_ID, XLOG_OVERWRITE_CONTRECORD);
 
 	/* check that the record was inserted to the right place */
@@ -8044,7 +8044,7 @@ void
 XLogPutNextOid(Oid nextOid)
 {
 	XLogBeginInsert();
-	XLogRegisterData((char *) (&nextOid), sizeof(Oid));
+	XLogRegisterData(&nextOid, sizeof(Oid));
 	(void) XLogInsert(RM_XLOG_ID, XLOG_NEXTOID);
 
 	/*
@@ -8105,7 +8105,7 @@ XLogRestorePoint(const char *rpName)
 	strlcpy(xlrec.rp_name, rpName, MAXFNAMELEN);
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, sizeof(xl_restore_point));
+	XLogRegisterData(&xlrec, sizeof(xl_restore_point));
 
 	RecPtr = XLogInsert(RM_XLOG_ID, XLOG_RESTORE_POINT);
 
@@ -8154,7 +8154,7 @@ XLogReportParameters(void)
 			xlrec.track_commit_timestamp = track_commit_timestamp;
 
 			XLogBeginInsert();
-			XLogRegisterData((char *) &xlrec, sizeof(xlrec));
+			XLogRegisterData(&xlrec, sizeof(xlrec));
 
 			recptr = XLogInsert(RM_XLOG_ID, XLOG_PARAMETER_CHANGE);
 			XLogFlush(recptr);
@@ -8229,7 +8229,7 @@ UpdateFullPageWrites(void)
 	if (XLogStandbyInfoActive() && !recoveryInProgress)
 	{
 		XLogBeginInsert();
-		XLogRegisterData((char *) (&fullPageWrites), sizeof(bool));
+		XLogRegisterData(&fullPageWrites, sizeof(bool));
 
 		XLogInsert(RM_XLOG_ID, XLOG_FPW_CHANGE);
 	}
@@ -9272,7 +9272,7 @@ do_pg_backup_stop(BackupState *state, bool waitforarchive)
 		 * Write the backup-end xlog record
 		 */
 		XLogBeginInsert();
-		XLogRegisterData((char *) (&state->startpoint),
+		XLogRegisterData(&state->startpoint,
 						 sizeof(state->startpoint));
 		state->stoppoint = XLogInsert(RM_XLOG_ID, XLOG_BACKUP_END);
 
diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c
index eba0e716549..690b1dbc6ee 100644
--- a/src/backend/catalog/storage.c
+++ b/src/backend/catalog/storage.c
@@ -194,7 +194,7 @@ log_smgrcreate(const RelFileLocator *rlocator, ForkNumber forkNum)
 	xlrec.forkNum = forkNum;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, sizeof(xlrec));
+	XLogRegisterData(&xlrec, sizeof(xlrec));
 	XLogInsert(RM_SMGR_ID, XLOG_SMGR_CREATE | XLR_SPECIAL_REL_UPDATE);
 }
 
@@ -397,7 +397,7 @@ RelationTruncate(Relation rel, BlockNumber nblocks)
 		xlrec.flags = SMGR_TRUNCATE_ALL;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, sizeof(xlrec));
+		XLogRegisterData(&xlrec, sizeof(xlrec));
 
 		lsn = XLogInsert(RM_SMGR_ID,
 						 XLOG_SMGR_TRUNCATE | XLR_SPECIAL_REL_UPDATE);
diff --git a/src/backend/commands/dbcommands.c b/src/backend/commands/dbcommands.c
index 46310add459..1753b289074 100644
--- a/src/backend/commands/dbcommands.c
+++ b/src/backend/commands/dbcommands.c
@@ -529,7 +529,7 @@ CreateDirAndVersionFile(char *dbpath, Oid dbid, Oid tsid, bool isRedo)
 		xlrec.tablespace_id = tsid;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) (&xlrec),
+		XLogRegisterData(&xlrec,
 						 sizeof(xl_dbase_create_wal_log_rec));
 
 		(void) XLogInsert(RM_DBASE_ID, XLOG_DBASE_CREATE_WAL_LOG);
@@ -625,7 +625,7 @@ CreateDatabaseUsingFileCopy(Oid src_dboid, Oid dst_dboid, Oid src_tsid,
 			xlrec.src_tablespace_id = srctablespace;
 
 			XLogBeginInsert();
-			XLogRegisterData((char *) &xlrec,
+			XLogRegisterData(&xlrec,
 							 sizeof(xl_dbase_create_file_copy_rec));
 
 			(void) XLogInsert(RM_DBASE_ID,
@@ -2183,7 +2183,7 @@ movedb(const char *dbname, const char *tblspcname)
 			xlrec.src_tablespace_id = src_tblspcoid;
 
 			XLogBeginInsert();
-			XLogRegisterData((char *) &xlrec,
+			XLogRegisterData(&xlrec,
 							 sizeof(xl_dbase_create_file_copy_rec));
 
 			(void) XLogInsert(RM_DBASE_ID,
@@ -2279,8 +2279,8 @@ movedb(const char *dbname, const char *tblspcname)
 		xlrec.ntablespaces = 1;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, sizeof(xl_dbase_drop_rec));
-		XLogRegisterData((char *) &src_tblspcoid, sizeof(Oid));
+		XLogRegisterData(&xlrec, sizeof(xl_dbase_drop_rec));
+		XLogRegisterData(&src_tblspcoid, sizeof(Oid));
 
 		(void) XLogInsert(RM_DBASE_ID,
 						  XLOG_DBASE_DROP | XLR_SPECIAL_REL_UPDATE);
@@ -3037,8 +3037,8 @@ remove_dbtablespaces(Oid db_id)
 		xlrec.ntablespaces = ntblspc;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, MinSizeOfDbaseDropRec);
-		XLogRegisterData((char *) tablespace_ids, ntblspc * sizeof(Oid));
+		XLogRegisterData(&xlrec, MinSizeOfDbaseDropRec);
+		XLogRegisterData(tablespace_ids, ntblspc * sizeof(Oid));
 
 		(void) XLogInsert(RM_DBASE_ID,
 						  XLOG_DBASE_DROP | XLR_SPECIAL_REL_UPDATE);
diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index b13ee2b745d..4b7c5113aab 100644
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -415,8 +415,8 @@ fill_seq_fork_with_data(Relation rel, HeapTuple tuple, ForkNumber forkNum)
 
 		xlrec.locator = rel->rd_locator;
 
-		XLogRegisterData((char *) &xlrec, sizeof(xl_seq_rec));
-		XLogRegisterData((char *) tuple->t_data, tuple->t_len);
+		XLogRegisterData(&xlrec, sizeof(xl_seq_rec));
+		XLogRegisterData(tuple->t_data, tuple->t_len);
 
 		recptr = XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG);
 
@@ -840,8 +840,8 @@ nextval_internal(Oid relid, bool check_permissions)
 
 		xlrec.locator = seqrel->rd_locator;
 
-		XLogRegisterData((char *) &xlrec, sizeof(xl_seq_rec));
-		XLogRegisterData((char *) seqdatatuple.t_data, seqdatatuple.t_len);
+		XLogRegisterData(&xlrec, sizeof(xl_seq_rec));
+		XLogRegisterData(seqdatatuple.t_data, seqdatatuple.t_len);
 
 		recptr = XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG);
 
@@ -1026,8 +1026,8 @@ do_setval(Oid relid, int64 next, bool iscalled)
 		XLogRegisterBuffer(0, buf, REGBUF_WILL_INIT);
 
 		xlrec.locator = seqrel->rd_locator;
-		XLogRegisterData((char *) &xlrec, sizeof(xl_seq_rec));
-		XLogRegisterData((char *) seqdatatuple.t_data, seqdatatuple.t_len);
+		XLogRegisterData(&xlrec, sizeof(xl_seq_rec));
+		XLogRegisterData(seqdatatuple.t_data, seqdatatuple.t_len);
 
 		recptr = XLogInsert(RM_SEQ_ID, XLOG_SEQ_LOG);
 
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 5823fce9340..72a1b64c2a2 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -2283,8 +2283,8 @@ ExecuteTruncateGuts(List *explicit_rels,
 			xlrec.flags |= XLH_TRUNCATE_RESTART_SEQS;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, SizeOfHeapTruncate);
-		XLogRegisterData((char *) logrelids, list_length(relids_logged) * sizeof(Oid));
+		XLogRegisterData(&xlrec, SizeOfHeapTruncate);
+		XLogRegisterData(logrelids, list_length(relids_logged) * sizeof(Oid));
 
 		XLogSetRecordFlags(XLOG_INCLUDE_ORIGIN);
 
diff --git a/src/backend/commands/tablespace.c b/src/backend/commands/tablespace.c
index 4ac2763c7f3..a9005cc7212 100644
--- a/src/backend/commands/tablespace.c
+++ b/src/backend/commands/tablespace.c
@@ -363,9 +363,9 @@ CreateTableSpace(CreateTableSpaceStmt *stmt)
 		xlrec.ts_id = tablespaceoid;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec,
+		XLogRegisterData(&xlrec,
 						 offsetof(xl_tblspc_create_rec, ts_path));
-		XLogRegisterData((char *) location, strlen(location) + 1);
+		XLogRegisterData(location, strlen(location) + 1);
 
 		(void) XLogInsert(RM_TBLSPC_ID, XLOG_TBLSPC_CREATE);
 	}
@@ -533,7 +533,7 @@ DropTableSpace(DropTableSpaceStmt *stmt)
 		xlrec.ts_id = tablespaceoid;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) &xlrec, sizeof(xl_tblspc_drop_rec));
+		XLogRegisterData(&xlrec, sizeof(xl_tblspc_drop_rec));
 
 		(void) XLogInsert(RM_TBLSPC_ID, XLOG_TBLSPC_DROP);
 	}
diff --git a/src/backend/replication/logical/message.c b/src/backend/replication/logical/message.c
index 0d6cf67c107..ebc8454bad9 100644
--- a/src/backend/replication/logical/message.c
+++ b/src/backend/replication/logical/message.c
@@ -62,7 +62,7 @@ LogLogicalMessage(const char *prefix, const char *message, size_t size,
 	xlrec.message_size = size;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, SizeOfLogicalMessage);
+	XLogRegisterData(&xlrec, SizeOfLogicalMessage);
 	XLogRegisterData(prefix, xlrec.prefix_size);
 	XLogRegisterData(message, size);
 
diff --git a/src/backend/replication/logical/origin.c b/src/backend/replication/logical/origin.c
index 1b586cb1cf2..c3c1d7a2a51 100644
--- a/src/backend/replication/logical/origin.c
+++ b/src/backend/replication/logical/origin.c
@@ -391,7 +391,7 @@ replorigin_state_clear(RepOriginId roident, bool nowait)
 
 				xlrec.node_id = roident;
 				XLogBeginInsert();
-				XLogRegisterData((char *) (&xlrec), sizeof(xlrec));
+				XLogRegisterData(&xlrec, sizeof(xlrec));
 				XLogInsert(RM_REPLORIGIN_ID, XLOG_REPLORIGIN_DROP);
 			}
 
@@ -986,7 +986,7 @@ replorigin_advance(RepOriginId node,
 		xlrec.force = go_backward;
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) (&xlrec), sizeof(xlrec));
+		XLogRegisterData(&xlrec, sizeof(xlrec));
 
 		XLogInsert(RM_REPLORIGIN_ID, XLOG_REPLORIGIN_SET);
 	}
diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c
index 2039062554d..5acb4508f85 100644
--- a/src/backend/storage/ipc/standby.c
+++ b/src/backend/storage/ipc/standby.c
@@ -1353,11 +1353,11 @@ LogCurrentRunningXacts(RunningTransactions CurrRunningXacts)
 	/* Header */
 	XLogBeginInsert();
 	XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
-	XLogRegisterData((char *) (&xlrec), MinSizeOfXactRunningXacts);
+	XLogRegisterData(&xlrec, MinSizeOfXactRunningXacts);
 
 	/* array of TransactionIds */
 	if (xlrec.xcnt > 0)
-		XLogRegisterData((char *) CurrRunningXacts->xids,
+		XLogRegisterData(CurrRunningXacts->xids,
 						 (xlrec.xcnt + xlrec.subxcnt) * sizeof(TransactionId));
 
 	recptr = XLogInsert(RM_STANDBY_ID, XLOG_RUNNING_XACTS);
@@ -1405,8 +1405,8 @@ LogAccessExclusiveLocks(int nlocks, xl_standby_lock *locks)
 	xlrec.nlocks = nlocks;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, offsetof(xl_standby_locks, locks));
-	XLogRegisterData((char *) locks, nlocks * sizeof(xl_standby_lock));
+	XLogRegisterData(&xlrec, offsetof(xl_standby_locks, locks));
+	XLogRegisterData(locks, nlocks * sizeof(xl_standby_lock));
 	XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
 
 	(void) XLogInsert(RM_STANDBY_ID, XLOG_STANDBY_LOCK);
@@ -1469,8 +1469,8 @@ LogStandbyInvalidations(int nmsgs, SharedInvalidationMessage *msgs,
 
 	/* perform insertion */
 	XLogBeginInsert();
-	XLogRegisterData((char *) (&xlrec), MinSizeOfInvalidations);
-	XLogRegisterData((char *) msgs,
+	XLogRegisterData(&xlrec, MinSizeOfInvalidations);
+	XLogRegisterData(msgs,
 					 nmsgs * sizeof(SharedInvalidationMessage));
 	XLogInsert(RM_STANDBY_ID, XLOG_INVALIDATIONS);
 }
diff --git a/src/backend/utils/cache/inval.c b/src/backend/utils/cache/inval.c
index 32cf28bb8bc..6aff1ec01d7 100644
--- a/src/backend/utils/cache/inval.c
+++ b/src/backend/utils/cache/inval.c
@@ -1813,12 +1813,12 @@ LogLogicalInvalidations(void)
 
 		/* perform insertion */
 		XLogBeginInsert();
-		XLogRegisterData((char *) (&xlrec), MinSizeOfXactInvals);
+		XLogRegisterData(&xlrec, MinSizeOfXactInvals);
 		ProcessMessageSubGroupMulti(group, CatCacheMsgs,
-									XLogRegisterData((char *) msgs,
+									XLogRegisterData(msgs,
 													 n * sizeof(SharedInvalidationMessage)));
 		ProcessMessageSubGroupMulti(group, RelCacheMsgs,
-									XLogRegisterData((char *) msgs,
+									XLogRegisterData(msgs,
 													 n * sizeof(SharedInvalidationMessage)));
 		XLogInsert(RM_XACT_ID, XLOG_XACT_INVALIDATIONS);
 	}
diff --git a/src/backend/utils/cache/relmapper.c b/src/backend/utils/cache/relmapper.c
index 30f968cd9cf..abf89f0776e 100644
--- a/src/backend/utils/cache/relmapper.c
+++ b/src/backend/utils/cache/relmapper.c
@@ -969,8 +969,8 @@ write_relmap_file(RelMapFile *newmap, bool write_wal, bool send_sinval,
 		xlrec.nbytes = sizeof(RelMapFile);
 
 		XLogBeginInsert();
-		XLogRegisterData((char *) (&xlrec), MinSizeOfRelmapUpdate);
-		XLogRegisterData((char *) newmap, sizeof(RelMapFile));
+		XLogRegisterData(&xlrec, MinSizeOfRelmapUpdate);
+		XLogRegisterData(newmap, sizeof(RelMapFile));
 
 		lsn = XLogInsert(RM_RELMAP_ID, XLOG_RELMAP_UPDATE);
 
diff --git a/src/test/modules/test_custom_rmgrs/test_custom_rmgrs.c b/src/test/modules/test_custom_rmgrs/test_custom_rmgrs.c
index b989a35f801..1a424ad55a8 100644
--- a/src/test/modules/test_custom_rmgrs/test_custom_rmgrs.c
+++ b/src/test/modules/test_custom_rmgrs/test_custom_rmgrs.c
@@ -128,8 +128,8 @@ test_custom_rmgrs_insert_wal_record(PG_FUNCTION_ARGS)
 	xlrec.message_size = len;
 
 	XLogBeginInsert();
-	XLogRegisterData((char *) &xlrec, SizeOfTestCustomRmgrsMessage);
-	XLogRegisterData((char *) payload, len);
+	XLogRegisterData(&xlrec, SizeOfTestCustomRmgrsMessage);
+	XLogRegisterData(payload, len);
 
 	/* Let's mark this record as unimportant, just in case. */
 	XLogSetRecordFlags(XLOG_MARK_UNIMPORTANT);
-- 
2.48.1