v2-0001-Use-PRI-64-instead-of-ll-in-format-strings-contin.patch

From 0fbdf913ba07e14f9821e7e9982970649e751c93 Mon Sep 17 00:00:00 2001
From: Thomas Munro <thomas.munro@gmail.com>
Date: Fri, 6 Dec 2024 04:42:59 +1300
Subject: [PATCH v2 1/5] Use PRI?64 instead of "ll?" in format strings
 (continued).

Continuation of work started in commit 15a79c73, after initial trial.

Discussion: https://postgr.es/m/b936d2fb-590d-49c3-a615-92c3a88c6c19%40eisentraut.org
---
 contrib/file_fdw/file_fdw.c                   | 20 +++----
 contrib/pageinspect/btreefuncs.c              |  6 +-
 contrib/pageinspect/hashfuncs.c               |  4 +-
 contrib/pg_prewarm/pg_prewarm.c               |  8 +--
 src/backend/access/brin/brin.c                |  7 +--
 src/backend/access/heap/vacuumlazy.c          | 44 +++++++--------
 src/backend/access/rmgrdesc/clogdesc.c        |  6 +-
 src/backend/access/rmgrdesc/committsdesc.c    |  6 +-
 src/backend/access/rmgrdesc/mxactdesc.c       |  2 +-
 src/backend/access/rmgrdesc/xactdesc.c        |  4 +-
 src/backend/access/transam/multixact.c        | 28 +++++-----
 src/backend/access/transam/slru.c             |  3 +-
 src/backend/access/transam/twophase.c         | 12 ++--
 src/backend/access/transam/xlogarchive.c      |  6 +-
 src/backend/access/transam/xloginsert.c       |  8 +--
 src/backend/access/transam/xlogreader.c       | 10 ++--
 src/backend/backup/basebackup.c               |  6 +-
 src/backend/backup/basebackup_incremental.c   |  6 +-
 src/backend/backup/walsummaryfuncs.c          |  2 +-
 src/backend/catalog/catalog.c                 | 12 ++--
 src/backend/commands/analyze.c                | 18 +++---
 src/backend/commands/copy.c                   |  4 +-
 src/backend/commands/copyfrom.c               | 36 ++++++------
 src/backend/commands/copyfromparse.c          |  8 +--
 src/backend/commands/explain.c                | 54 +++++++++---------
 src/backend/commands/sequence.c               | 56 +++++++++----------
 src/backend/commands/vacuum.c                 |  4 +-
 src/backend/replication/logical/logical.c     | 18 +++---
 src/backend/replication/slot.c                |  6 +-
 src/backend/replication/walreceiver.c         |  4 +-
 src/backend/storage/ipc/ipc.c                 |  4 +-
 src/backend/storage/ipc/signalfuncs.c         |  6 +-
 src/backend/utils/activity/pgstat.c           | 16 +++---
 src/backend/utils/activity/pgstat_replslot.c  |  4 +-
 src/backend/utils/activity/pgstat_shmem.c     |  4 +-
 src/backend/utils/activity/pgstat_xact.c      |  4 +-
 src/backend/utils/adt/datetime.c              | 24 ++++----
 src/backend/utils/adt/varlena.c               |  8 +--
 src/backend/utils/adt/xid8funcs.c             |  4 +-
 src/backend/utils/error/csvlog.c              |  2 +-
 src/backend/utils/error/elog.c                |  8 +--
 src/backend/utils/error/jsonlog.c             |  4 +-
 src/backend/utils/mmgr/mcxt.c                 | 16 +++---
 src/backend/utils/sort/logtape.c              | 16 +++---
 src/backend/utils/sort/tuplesort.c            |  8 +--
 src/bin/pg_basebackup/pg_createsubscriber.c   | 10 ++--
 src/bin/pg_basebackup/pg_receivewal.c         |  4 +-
 src/bin/pg_combinebackup/load_manifest.c      | 10 ++--
 src/bin/pg_combinebackup/pg_combinebackup.c   | 19 +++----
 src/bin/pg_combinebackup/reconstruct.c        | 10 ++--
 src/bin/pg_combinebackup/write_manifest.c     |  3 +-
 src/bin/pg_controldata/pg_controldata.c       |  4 +-
 src/bin/pg_dump/pg_backup_tar.c               | 18 +++---
 src/bin/pg_resetwal/pg_resetwal.c             |  4 +-
 src/bin/pg_rewind/libpq_source.c              |  8 +--
 src/bin/pg_verifybackup/astreamer_verify.c    | 18 +++---
 src/bin/pg_verifybackup/pg_verifybackup.c     | 27 +++++----
 src/fe_utils/archive.c                        |  6 +-
 src/fe_utils/print.c                          | 10 ++--
 src/include/lib/radixtree.h                   |  6 +-
 .../modules/libpq_pipeline/libpq_pipeline.c   |  2 +-
 .../test_copy_callbacks/test_copy_callbacks.c |  4 +-
 src/test/modules/test_slru/test_slru.c        |  8 +--
 .../modules/xid_wraparound/xid_wraparound.c   | 10 ++--
 64 files changed, 354 insertions(+), 363 deletions(-)

diff --git a/contrib/file_fdw/file_fdw.c b/contrib/file_fdw/file_fdw.c
index bf707c812ed..5d9c09c5c4d 100644
--- a/contrib/file_fdw/file_fdw.c
+++ b/contrib/file_fdw/file_fdw.c
@@ -794,8 +794,8 @@ retry:
 				cstate->num_errors > cstate->opts.reject_limit)
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
-						 errmsg("skipped more than REJECT_LIMIT (%lld) rows due to data type incompatibility",
-								(long long) cstate->opts.reject_limit)));
+						 errmsg("skipped more than REJECT_LIMIT (%" PRId64 ") rows due to data type incompatibility",
+								cstate->opts.reject_limit)));
 
 			/* Repeat NextCopyFrom() until no soft error occurs */
 			goto retry;
@@ -851,10 +851,10 @@ fileEndForeignScan(ForeignScanState *node)
 		festate->cstate->num_errors > 0 &&
 		festate->cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT)
 		ereport(NOTICE,
-				errmsg_plural("%llu row was skipped due to data type incompatibility",
-							  "%llu rows were skipped due to data type incompatibility",
-							  (unsigned long long) festate->cstate->num_errors,
-							  (unsigned long long) festate->cstate->num_errors));
+				errmsg_plural("%" PRIu64 " row was skipped due to data type incompatibility",
+							  "%" PRIu64 " rows were skipped due to data type incompatibility",
+							  festate->cstate->num_errors,
+							  festate->cstate->num_errors));
 
 	EndCopyFrom(festate->cstate);
 }
@@ -1315,10 +1315,10 @@ file_acquire_sample_rows(Relation onerel, int elevel,
 		cstate->num_errors > 0 &&
 		cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT)
 		ereport(NOTICE,
-				errmsg_plural("%llu row was skipped due to data type incompatibility",
-							  "%llu rows were skipped due to data type incompatibility",
-							  (unsigned long long) cstate->num_errors,
-							  (unsigned long long) cstate->num_errors));
+				errmsg_plural("%" PRIu64 " row was skipped due to data type incompatibility",
+							  "%" PRIu64 " rows were skipped due to data type incompatibility",
+							  cstate->num_errors,
+							  cstate->num_errors));
 
 	EndCopyFrom(cstate);
 
diff --git a/contrib/pageinspect/btreefuncs.c b/contrib/pageinspect/btreefuncs.c
index 9cdc8e182b4..294821231fc 100644
--- a/contrib/pageinspect/btreefuncs.c
+++ b/contrib/pageinspect/btreefuncs.c
@@ -206,14 +206,12 @@ check_relation_block_range(Relation rel, int64 blkno)
 	if (blkno < 0 || blkno > MaxBlockNumber)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("invalid block number %lld",
-						(long long) blkno)));
+				 errmsg("invalid block number %" PRId64, blkno)));
 
 	if ((BlockNumber) (blkno) >= RelationGetNumberOfBlocks(rel))
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("block number %lld is out of range",
-						(long long) blkno)));
+				 errmsg("block number %" PRId64 " is out of range", blkno)));
 }
 
 /* -----------------------------------------------
diff --git a/contrib/pageinspect/hashfuncs.c b/contrib/pageinspect/hashfuncs.c
index d4a2a1d676a..ca7f1f6e741 100644
--- a/contrib/pageinspect/hashfuncs.c
+++ b/contrib/pageinspect/hashfuncs.c
@@ -436,8 +436,8 @@ hash_bitmap_info(PG_FUNCTION_ARGS)
 	if (ovflblkno >= RelationGetNumberOfBlocks(indexRel))
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("block number %lld is out of range for relation \"%s\"",
-						(long long int) ovflblkno, RelationGetRelationName(indexRel))));
+				 errmsg("block number %" PRId64 " is out of range for relation \"%s\"",
+						ovflblkno, RelationGetRelationName(indexRel))));
 
 	/* Read the metapage so we can determine which bitmap page to use */
 	metabuf = _hash_getbuf(indexRel, HASH_METAPAGE, HASH_READ, LH_META_PAGE);
diff --git a/contrib/pg_prewarm/pg_prewarm.c b/contrib/pg_prewarm/pg_prewarm.c
index a2f0ac4af0c..8f96656c52a 100644
--- a/contrib/pg_prewarm/pg_prewarm.c
+++ b/contrib/pg_prewarm/pg_prewarm.c
@@ -126,8 +126,8 @@ pg_prewarm(PG_FUNCTION_ARGS)
 		if (first_block < 0 || first_block >= nblocks)
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-					 errmsg("starting block number must be between 0 and %lld",
-							(long long) (nblocks - 1))));
+					 errmsg("starting block number must be between 0 and %" PRId64,
+							(nblocks - 1))));
 	}
 	if (PG_ARGISNULL(4))
 		last_block = nblocks - 1;
@@ -137,8 +137,8 @@ pg_prewarm(PG_FUNCTION_ARGS)
 		if (last_block < 0 || last_block >= nblocks)
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-					 errmsg("ending block number must be between 0 and %lld",
-							(long long) (nblocks - 1))));
+					 errmsg("ending block number must be between 0 and %" PRId64,
+							(nblocks - 1))));
 	}
 
 	/* Now we're ready to do the real work. */
diff --git a/src/backend/access/brin/brin.c b/src/backend/access/brin/brin.c
index 75a65ec9c75..9276fe5d5e1 100644
--- a/src/backend/access/brin/brin.c
+++ b/src/backend/access/brin/brin.c
@@ -1397,8 +1397,7 @@ brin_summarize_range(PG_FUNCTION_ARGS)
 	if (heapBlk64 > BRIN_ALL_BLOCKRANGES || heapBlk64 < 0)
 		ereport(ERROR,
 				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
-				 errmsg("block number out of range: %lld",
-						(long long) heapBlk64)));
+				 errmsg("block number out of range: %" PRId64, heapBlk64)));
 	heapBlk = (BlockNumber) heapBlk64;
 
 	/*
@@ -1505,8 +1504,8 @@ brin_desummarize_range(PG_FUNCTION_ARGS)
 	if (heapBlk64 > MaxBlockNumber || heapBlk64 < 0)
 		ereport(ERROR,
 				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
-				 errmsg("block number out of range: %lld",
-						(long long) heapBlk64)));
+				 errmsg("block number out of range: %" PRId64,
+						heapBlk64)));
 	heapBlk = (BlockNumber) heapBlk64;
 
 	/*
diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index 1af18a78a2b..5ba661b9fa6 100644
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -1010,14 +1010,14 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
 							 orig_rel_pages,
 							 vacrel->eager_scanned_pages);
 			appendStringInfo(&buf,
-							 _("tuples: %lld removed, %lld remain, %lld are dead but not yet removable\n"),
-							 (long long) vacrel->tuples_deleted,
-							 (long long) vacrel->new_rel_tuples,
-							 (long long) vacrel->recently_dead_tuples);
+							 _("tuples: %" PRId64 " removed, %" PRId64 " remain, %" PRId64 " are dead but not yet removable\n"),
+							 vacrel->tuples_deleted,
+							 (int64) vacrel->new_rel_tuples,
+							 vacrel->recently_dead_tuples);
 			if (vacrel->missed_dead_tuples > 0)
 				appendStringInfo(&buf,
-								 _("tuples missed: %lld dead from %u pages not removed due to cleanup lock contention\n"),
-								 (long long) vacrel->missed_dead_tuples,
+								 _("tuples missed: %" PRId64 " dead from %u pages not removed due to cleanup lock contention\n"),
+								 vacrel->missed_dead_tuples,
 								 vacrel->missed_dead_pages);
 			diff = (int32) (ReadNextTransactionId() -
 							vacrel->cutoffs.OldestXmin);
@@ -1040,12 +1040,12 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
 								 _("new relminmxid: %u, which is %d MXIDs ahead of previous value\n"),
 								 vacrel->NewRelminMxid, diff);
 			}
-			appendStringInfo(&buf, _("frozen: %u pages from table (%.2f%% of total) had %lld tuples frozen\n"),
+			appendStringInfo(&buf, _("frozen: %u pages from table (%.2f%% of total) had %" PRId64 " tuples frozen\n"),
 							 vacrel->new_frozen_tuple_pages,
 							 orig_rel_pages == 0 ? 100.0 :
 							 100.0 * vacrel->new_frozen_tuple_pages /
 							 orig_rel_pages,
-							 (long long) vacrel->tuples_frozen);
+							 vacrel->tuples_frozen);
 
 			appendStringInfo(&buf,
 							 _("visibility map: %u pages set all-visible, %u pages set all-frozen (%u were all-visible)\n"),
@@ -1060,7 +1060,7 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
 				else
 					appendStringInfoString(&buf, _("index scan needed: "));
 
-				msgfmt = _("%u pages from table (%.2f%% of total) had %lld dead item identifiers removed\n");
+				msgfmt = _("%u pages from table (%.2f%% of total) had %" PRId64 " dead item identifiers removed\n");
 			}
 			else
 			{
@@ -1069,13 +1069,13 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
 				else
 					appendStringInfoString(&buf, _("index scan bypassed by failsafe: "));
 
-				msgfmt = _("%u pages from table (%.2f%% of total) have %lld dead item identifiers\n");
+				msgfmt = _("%u pages from table (%.2f%% of total) have %" PRId64 " dead item identifiers\n");
 			}
 			appendStringInfo(&buf, msgfmt,
 							 vacrel->lpdead_item_pages,
 							 orig_rel_pages == 0 ? 100.0 :
 							 100.0 * vacrel->lpdead_item_pages / orig_rel_pages,
-							 (long long) vacrel->lpdead_items);
+							 vacrel->lpdead_items);
 			for (int i = 0; i < vacrel->nindexes; i++)
 			{
 				IndexBulkDeleteResult *istat = vacrel->indstats[i];
@@ -1120,16 +1120,16 @@ heap_vacuum_rel(Relation rel, VacuumParams *params,
 			appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"),
 							 read_rate, write_rate);
 			appendStringInfo(&buf,
-							 _("buffer usage: %lld hits, %lld reads, %lld dirtied\n"),
-							 (long long) total_blks_hit,
-							 (long long) total_blks_read,
-							 (long long) total_blks_dirtied);
+							 _("buffer usage: %" PRId64 " hits, %" PRId64 " reads, %" PRId64 " dirtied\n"),
+							 total_blks_hit,
+							 total_blks_read,
+							 total_blks_dirtied);
 			appendStringInfo(&buf,
-							 _("WAL usage: %lld records, %lld full page images, %llu bytes, %lld buffers full\n"),
-							 (long long) walusage.wal_records,
-							 (long long) walusage.wal_fpi,
-							 (unsigned long long) walusage.wal_bytes,
-							 (long long) walusage.wal_buffers_full);
+							 _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRId64 " buffers full\n"),
+							 walusage.wal_records,
+							 walusage.wal_fpi,
+							 walusage.wal_bytes,
+							 walusage.wal_buffers_full);
 			appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0));
 
 			ereport(verbose ? INFO : LOG,
@@ -2789,8 +2789,8 @@ lazy_vacuum_heap_rel(LVRelState *vacrel)
 			vacuumed_pages == vacrel->lpdead_item_pages));
 
 	ereport(DEBUG2,
-			(errmsg("table \"%s\": removed %lld dead item identifiers in %u pages",
-					vacrel->relname, (long long) vacrel->dead_items_info->num_items,
+			(errmsg("table \"%s\": removed %" PRId64 " dead item identifiers in %u pages",
+					vacrel->relname, vacrel->dead_items_info->num_items,
 					vacuumed_pages)));
 
 	/* Revert to the previous phase information for error traceback */
diff --git a/src/backend/access/rmgrdesc/clogdesc.c b/src/backend/access/rmgrdesc/clogdesc.c
index f2d0ee7a023..41bf28dcfd0 100644
--- a/src/backend/access/rmgrdesc/clogdesc.c
+++ b/src/backend/access/rmgrdesc/clogdesc.c
@@ -28,15 +28,15 @@ clog_desc(StringInfo buf, XLogReaderState *record)
 		int64		pageno;
 
 		memcpy(&pageno, rec, sizeof(pageno));
-		appendStringInfo(buf, "page %lld", (long long) pageno);
+		appendStringInfo(buf, "page %" PRId64, pageno);
 	}
 	else if (info == CLOG_TRUNCATE)
 	{
 		xl_clog_truncate xlrec;
 
 		memcpy(&xlrec, rec, sizeof(xl_clog_truncate));
-		appendStringInfo(buf, "page %lld; oldestXact %u",
-						 (long long) xlrec.pageno, xlrec.oldestXact);
+		appendStringInfo(buf, "page %" PRId64 "; oldestXact %u",
+						 xlrec.pageno, xlrec.oldestXact);
 	}
 }
 
diff --git a/src/backend/access/rmgrdesc/committsdesc.c b/src/backend/access/rmgrdesc/committsdesc.c
index c5e1c1b5bb3..a6ab9dd78de 100644
--- a/src/backend/access/rmgrdesc/committsdesc.c
+++ b/src/backend/access/rmgrdesc/committsdesc.c
@@ -28,14 +28,14 @@ commit_ts_desc(StringInfo buf, XLogReaderState *record)
 		int64		pageno;
 
 		memcpy(&pageno, rec, sizeof(pageno));
-		appendStringInfo(buf, "%lld", (long long) pageno);
+		appendStringInfo(buf, "%" PRId64, pageno);
 	}
 	else if (info == COMMIT_TS_TRUNCATE)
 	{
 		xl_commit_ts_truncate *trunc = (xl_commit_ts_truncate *) rec;
 
-		appendStringInfo(buf, "pageno %lld, oldestXid %u",
-						 (long long) trunc->pageno, trunc->oldestXid);
+		appendStringInfo(buf, "pageno %" PRId64 ", oldestXid %u",
+						 trunc->pageno, trunc->oldestXid);
 	}
 }
 
diff --git a/src/backend/access/rmgrdesc/mxactdesc.c b/src/backend/access/rmgrdesc/mxactdesc.c
index 8bd3d5b63c7..3ca0582db36 100644
--- a/src/backend/access/rmgrdesc/mxactdesc.c
+++ b/src/backend/access/rmgrdesc/mxactdesc.c
@@ -58,7 +58,7 @@ multixact_desc(StringInfo buf, XLogReaderState *record)
 		int64		pageno;
 
 		memcpy(&pageno, rec, sizeof(pageno));
-		appendStringInfo(buf, "%lld", (long long) pageno);
+		appendStringInfo(buf, "%" PRId64, pageno);
 	}
 	else if (info == XLOG_MULTIXACT_CREATE_ID)
 	{
diff --git a/src/backend/access/rmgrdesc/xactdesc.c b/src/backend/access/rmgrdesc/xactdesc.c
index 7f94810defc..715cc1f7bad 100644
--- a/src/backend/access/rmgrdesc/xactdesc.c
+++ b/src/backend/access/rmgrdesc/xactdesc.c
@@ -320,10 +320,10 @@ xact_desc_stats(StringInfo buf, const char *label,
 			uint64		objid =
 				((uint64) dropped_stats[i].objid_hi) << 32 | dropped_stats[i].objid_lo;
 
-			appendStringInfo(buf, " %d/%u/%llu",
+			appendStringInfo(buf, " %d/%u/%" PRIu64,
 							 dropped_stats[i].kind,
 							 dropped_stats[i].dboid,
-							 (unsigned long long) objid);
+							 objid);
 		}
 	}
 }
diff --git a/src/backend/access/transam/multixact.c b/src/backend/access/transam/multixact.c
index c1e2c42e1bb..9d25a7df0d3 100644
--- a/src/backend/access/transam/multixact.c
+++ b/src/backend/access/transam/multixact.c
@@ -3058,8 +3058,8 @@ PerformMembersTruncation(MultiXactOffset oldestOffset, MultiXactOffset newOldest
 	 */
 	while (segment != endsegment)
 	{
-		elog(DEBUG2, "truncating multixact members segment %llx",
-			 (unsigned long long) segment);
+		elog(DEBUG2, "truncating multixact members segment %" PRIx64,
+			 segment);
 		SlruDeleteSegment(MultiXactMemberCtl, segment);
 
 		/* move to next segment, handling wraparound correctly */
@@ -3210,14 +3210,14 @@ TruncateMultiXact(MultiXactId newOldestMulti, Oid newOldestMultiDB)
 	}
 
 	elog(DEBUG1, "performing multixact truncation: "
-		 "offsets [%u, %u), offsets segments [%llx, %llx), "
-		 "members [%u, %u), members segments [%llx, %llx)",
+		 "offsets [%u, %u), offsets segments [%" PRIx64 ", %" PRIx64 "), "
+		 "members [%u, %u), members segments [%" PRIx64 ", %" PRIx64 ")",
 		 oldestMulti, newOldestMulti,
-		 (unsigned long long) MultiXactIdToOffsetSegment(oldestMulti),
-		 (unsigned long long) MultiXactIdToOffsetSegment(newOldestMulti),
+		 MultiXactIdToOffsetSegment(oldestMulti),
+		 MultiXactIdToOffsetSegment(newOldestMulti),
 		 oldestOffset, newOldestOffset,
-		 (unsigned long long) MXOffsetToMemberSegment(oldestOffset),
-		 (unsigned long long) MXOffsetToMemberSegment(newOldestOffset));
+		 MXOffsetToMemberSegment(oldestOffset),
+		 MXOffsetToMemberSegment(newOldestOffset));
 
 	/*
 	 * Do truncation, and the WAL logging of the truncation, in a critical
@@ -3470,14 +3470,14 @@ multixact_redo(XLogReaderState *record)
 			   SizeOfMultiXactTruncate);
 
 		elog(DEBUG1, "replaying multixact truncation: "
-			 "offsets [%u, %u), offsets segments [%llx, %llx), "
-			 "members [%u, %u), members segments [%llx, %llx)",
+			 "offsets [%u, %u), offsets segments [%" PRIx64 ", %" PRIx64 "), "
+			 "members [%u, %u), members segments [%" PRIx64 ", %" PRIx64 ")",
 			 xlrec.startTruncOff, xlrec.endTruncOff,
-			 (unsigned long long) MultiXactIdToOffsetSegment(xlrec.startTruncOff),
-			 (unsigned long long) MultiXactIdToOffsetSegment(xlrec.endTruncOff),
+			 MultiXactIdToOffsetSegment(xlrec.startTruncOff),
+			 MultiXactIdToOffsetSegment(xlrec.endTruncOff),
 			 xlrec.startTruncMemb, xlrec.endTruncMemb,
-			 (unsigned long long) MXOffsetToMemberSegment(xlrec.startTruncMemb),
-			 (unsigned long long) MXOffsetToMemberSegment(xlrec.endTruncMemb));
+			 MXOffsetToMemberSegment(xlrec.startTruncMemb),
+			 MXOffsetToMemberSegment(xlrec.endTruncMemb));
 
 		/* should not be required, but more than cheap enough */
 		LWLockAcquire(MultiXactTruncationLock, LW_EXCLUSIVE);
diff --git a/src/backend/access/transam/slru.c b/src/backend/access/transam/slru.c
index 9ce628e62a5..fe56286d9a9 100644
--- a/src/backend/access/transam/slru.c
+++ b/src/backend/access/transam/slru.c
@@ -100,8 +100,7 @@ SlruFileName(SlruCtl ctl, char *path, int64 segno)
 		 * that in the future we can't decrease SLRU_PAGES_PER_SEGMENT easily.
 		 */
 		Assert(segno >= 0 && segno <= INT64CONST(0xFFFFFFFFFFFFFFF));
-		return snprintf(path, MAXPGPATH, "%s/%015llX", ctl->Dir,
-						(long long) segno);
+		return snprintf(path, MAXPGPATH, "%s/%015" PRIX64, ctl->Dir, segno);
 	}
 	else
 	{
diff --git a/src/backend/access/transam/twophase.c b/src/backend/access/transam/twophase.c
index 73a80559194..eb8597df338 100644
--- a/src/backend/access/transam/twophase.c
+++ b/src/backend/access/transam/twophase.c
@@ -1326,10 +1326,10 @@ ReadTwoPhaseFile(TransactionId xid, bool missing_ok)
 		stat.st_size > MaxAllocSize)
 		ereport(ERROR,
 				(errcode(ERRCODE_DATA_CORRUPTED),
-				 errmsg_plural("incorrect size of file \"%s\": %lld byte",
-							   "incorrect size of file \"%s\": %lld bytes",
-							   (long long int) stat.st_size, path,
-							   (long long int) stat.st_size)));
+				 errmsg_plural("incorrect size of file \"%s\": %" PRId64 " byte",
+							   "incorrect size of file \"%s\": %" PRId64 " bytes",
+							   (pgoff_t) stat.st_size, path,
+							   (pgoff_t) stat.st_size)));
 
 	crc_offset = stat.st_size - sizeof(pg_crc32c);
 	if (crc_offset != MAXALIGN(crc_offset))
@@ -1353,8 +1353,8 @@ ReadTwoPhaseFile(TransactionId xid, bool missing_ok)
 					 errmsg("could not read file \"%s\": %m", path)));
 		else
 			ereport(ERROR,
-					(errmsg("could not read file \"%s\": read %d of %lld",
-							path, r, (long long int) stat.st_size)));
+					(errmsg("could not read file \"%s\": read %d of %" PRId64,
+							path, r, (pgoff_t) stat.st_size)));
 	}
 
 	pgstat_report_wait_end();
diff --git a/src/backend/access/transam/xlogarchive.c b/src/backend/access/transam/xlogarchive.c
index 1ef1713c91a..5971069f1d1 100644
--- a/src/backend/access/transam/xlogarchive.c
+++ b/src/backend/access/transam/xlogarchive.c
@@ -210,10 +210,10 @@ RestoreArchivedFile(char *path, const char *xlogfname,
 				else
 					elevel = FATAL;
 				ereport(elevel,
-						(errmsg("archive file \"%s\" has wrong size: %lld instead of %lld",
+						(errmsg("archive file \"%s\" has wrong size: %" PRId64 " instead of %" PRId64,
 								xlogfname,
-								(long long int) stat_buf.st_size,
-								(long long int) expectedSize)));
+								(pgoff_t) stat_buf.st_size,
+								(pgoff_t) expectedSize)));
 				return false;
 			}
 			else
diff --git a/src/backend/access/transam/xloginsert.c b/src/backend/access/transam/xloginsert.c
index 14d583ae7ae..5ee9d0b028e 100644
--- a/src/backend/access/transam/xloginsert.c
+++ b/src/backend/access/transam/xloginsert.c
@@ -869,8 +869,8 @@ XLogRecordAssemble(RmgrId rmid, uint8 info,
 			if (mainrdata_len > PG_UINT32_MAX)
 				ereport(ERROR,
 						(errmsg_internal("too much WAL data"),
-						 errdetail_internal("Main data length is %llu bytes for a maximum of %u bytes.",
-											(unsigned long long) mainrdata_len,
+						 errdetail_internal("Main data length is %" PRIu64 " bytes for a maximum of %u bytes.",
+											mainrdata_len,
 											PG_UINT32_MAX)));
 
 			mainrdata_len_4b = (uint32) mainrdata_len;
@@ -915,8 +915,8 @@ XLogRecordAssemble(RmgrId rmid, uint8 info,
 	if (total_len > XLogRecordMaxSize)
 		ereport(ERROR,
 				(errmsg_internal("oversized WAL record"),
-				 errdetail_internal("WAL record would be %llu bytes (of maximum %u bytes); rmid %u flags %u.",
-									(unsigned long long) total_len, XLogRecordMaxSize, rmid, info)));
+				 errdetail_internal("WAL record would be %" PRIu64 " bytes (of maximum %u bytes); rmid %u flags %u.",
+									total_len, XLogRecordMaxSize, rmid, info)));
 
 	/*
 	 * Fill in the fields in the record header. Prev-link is filled in later,
diff --git a/src/backend/access/transam/xlogreader.c b/src/backend/access/transam/xlogreader.c
index 5483d4f0dd2..42f3b725ff0 100644
--- a/src/backend/access/transam/xlogreader.c
+++ b/src/backend/access/transam/xlogreader.c
@@ -769,9 +769,9 @@ restart:
 				total_len != (pageHeader->xlp_rem_len + gotlen))
 			{
 				report_invalid_record(state,
-									  "invalid contrecord length %u (expected %lld) at %X/%X",
+									  "invalid contrecord length %u (expected %u) at %X/%X",
 									  pageHeader->xlp_rem_len,
-									  ((long long) total_len) - gotlen,
+									  total_len - gotlen,
 									  LSN_FORMAT_ARGS(RecPtr));
 				goto err;
 			}
@@ -1272,9 +1272,9 @@ XLogReaderValidatePageHeader(XLogReaderState *state, XLogRecPtr recptr,
 			longhdr->xlp_sysid != state->system_identifier)
 		{
 			report_invalid_record(state,
-								  "WAL file is from different database system: WAL file database system identifier is %llu, pg_control database system identifier is %llu",
-								  (unsigned long long) longhdr->xlp_sysid,
-								  (unsigned long long) state->system_identifier);
+								  "WAL file is from different database system: WAL file database system identifier is %" PRIu64 ", pg_control database system identifier is %" PRIu64,
+								  longhdr->xlp_sysid,
+								  state->system_identifier);
 			return false;
 		}
 		else if (longhdr->xlp_seg_size != state->segcxt.ws_segsize)
diff --git a/src/backend/backup/basebackup.c b/src/backend/backup/basebackup.c
index 3f8a3c55725..c41023b6a3f 100644
--- a/src/backend/backup/basebackup.c
+++ b/src/backend/backup/basebackup.c
@@ -123,7 +123,7 @@ static ssize_t basebackup_read_file(int fd, char *buf, size_t nbytes, off_t offs
 static bool backup_started_in_recovery = false;
 
 /* Total number of checksum failures during base backup. */
-static long long int total_checksum_failures;
+static int64 total_checksum_failures;
 
 /* Do not verify checksums. */
 static bool noverify_checksums = false;
@@ -655,8 +655,8 @@ perform_base_backup(basebackup_options *opt, bbsink *sink,
 	{
 		if (total_checksum_failures > 1)
 			ereport(WARNING,
-					(errmsg_plural("%lld total checksum verification failure",
-								   "%lld total checksum verification failures",
+					(errmsg_plural("%" PRId64 " total checksum verification failure",
+								   "%" PRId64 " total checksum verification failures",
 								   total_checksum_failures,
 								   total_checksum_failures)));
 
diff --git a/src/backend/backup/basebackup_incremental.c b/src/backend/backup/basebackup_incremental.c
index c2b7a55e347..51543699e83 100644
--- a/src/backend/backup/basebackup_incremental.c
+++ b/src/backend/backup/basebackup_incremental.c
@@ -949,9 +949,9 @@ manifest_process_system_identifier(JsonManifestParseContext *context,
 
 	if (manifest_system_identifier != system_identifier)
 		context->error_cb(context,
-						  "system identifier in backup manifest is %llu, but database system identifier is %llu",
-						  (unsigned long long) manifest_system_identifier,
-						  (unsigned long long) system_identifier);
+						  "system identifier in backup manifest is %" PRIu64 ", but database system identifier is %" PRIu64,
+						  manifest_system_identifier,
+						  system_identifier);
 }
 
 /*
diff --git a/src/backend/backup/walsummaryfuncs.c b/src/backend/backup/walsummaryfuncs.c
index 9811b79d62a..d6dd131da14 100644
--- a/src/backend/backup/walsummaryfuncs.c
+++ b/src/backend/backup/walsummaryfuncs.c
@@ -92,7 +92,7 @@ pg_wal_summary_contents(PG_FUNCTION_ARGS)
 	if (raw_tli < 1 || raw_tli > PG_INT32_MAX)
 		ereport(ERROR,
 				errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				errmsg("invalid timeline %lld", (long long) raw_tli));
+				errmsg("invalid timeline %" PRId64, raw_tli));
 
 	/* Prepare to read the specified WAL summary file. */
 	ws.tli = (TimeLineID) raw_tli;
diff --git a/src/backend/catalog/catalog.c b/src/backend/catalog/catalog.c
index 8436e312d4d..a6edf614606 100644
--- a/src/backend/catalog/catalog.c
+++ b/src/backend/catalog/catalog.c
@@ -474,10 +474,10 @@ GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
 			ereport(LOG,
 					(errmsg("still searching for an unused OID in relation \"%s\"",
 							RelationGetRelationName(relation)),
-					 errdetail_plural("OID candidates have been checked %llu time, but no unused OID has been found yet.",
-									  "OID candidates have been checked %llu times, but no unused OID has been found yet.",
+					 errdetail_plural("OID candidates have been checked %" PRIu64 " time, but no unused OID has been found yet.",
+									  "OID candidates have been checked %" PRIu64 " times, but no unused OID has been found yet.",
 									  retries,
-									  (unsigned long long) retries)));
+									  retries)));
 
 			/*
 			 * Double the number of retries to do before logging next until it
@@ -499,10 +499,10 @@ GetNewOidWithIndex(Relation relation, Oid indexId, AttrNumber oidcolumn)
 	if (retries > GETNEWOID_LOG_THRESHOLD)
 	{
 		ereport(LOG,
-				(errmsg_plural("new OID has been assigned in relation \"%s\" after %llu retry",
-							   "new OID has been assigned in relation \"%s\" after %llu retries",
+				(errmsg_plural("new OID has been assigned in relation \"%s\" after %" PRIu64 " retry",
+							   "new OID has been assigned in relation \"%s\" after %" PRIu64 " retries",
 							   retries,
-							   RelationGetRelationName(relation), (unsigned long long) retries)));
+							   RelationGetRelationName(relation), retries)));
 	}
 
 	return newOid;
diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c
index cd75954951b..087adea541a 100644
--- a/src/backend/commands/analyze.c
+++ b/src/backend/commands/analyze.c
@@ -827,16 +827,16 @@ do_analyze_rel(Relation onerel, VacuumParams *params,
 			}
 			appendStringInfo(&buf, _("avg read rate: %.3f MB/s, avg write rate: %.3f MB/s\n"),
 							 read_rate, write_rate);
-			appendStringInfo(&buf, _("buffer usage: %lld hits, %lld reads, %lld dirtied\n"),
-							 (long long) total_blks_hit,
-							 (long long) total_blks_read,
-							 (long long) total_blks_dirtied);
+			appendStringInfo(&buf, _("buffer usage: %" PRId64 " hits, %" PRId64 " reads, %" PRId64 " dirtied\n"),
+							 total_blks_hit,
+							 total_blks_read,
+							 total_blks_dirtied);
 			appendStringInfo(&buf,
-							 _("WAL usage: %lld records, %lld full page images, %llu bytes, %lld buffers full\n"),
-							 (long long) walusage.wal_records,
-							 (long long) walusage.wal_fpi,
-							 (unsigned long long) walusage.wal_bytes,
-							 (long long) walusage.wal_buffers_full);
+							 _("WAL usage: %" PRId64 " records, %" PRId64 " full page images, %" PRIu64 " bytes, %" PRId64 " buffers full\n"),
+							 walusage.wal_records,
+							 walusage.wal_fpi,
+							 walusage.wal_bytes,
+							 walusage.wal_buffers_full);
 			appendStringInfo(&buf, _("system usage: %s"), pg_rusage_show(&ru0));
 
 			ereport(verbose ? INFO : LOG,
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index cfca9d9dc29..74ae42b19a7 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -443,8 +443,8 @@ defGetCopyRejectLimitOption(DefElem *def)
 	if (reject_limit <= 0)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("REJECT_LIMIT (%lld) must be greater than zero",
-						(long long) reject_limit)));
+				 errmsg("REJECT_LIMIT (%" PRId64 ") must be greater than zero",
+						reject_limit)));
 
 	return reject_limit;
 }
diff --git a/src/backend/commands/copyfrom.c b/src/backend/commands/copyfrom.c
index 198cee2bc48..1909dde88d4 100644
--- a/src/backend/commands/copyfrom.c
+++ b/src/backend/commands/copyfrom.c
@@ -265,14 +265,14 @@ CopyFromErrorCallback(void *arg)
 	{
 		/* can't usefully display the data */
 		if (cstate->cur_attname)
-			errcontext("COPY %s, line %llu, column %s",
+			errcontext("COPY %s, line %" PRIu64 ", column %s",
 					   cstate->cur_relname,
-					   (unsigned long long) cstate->cur_lineno,
+					   cstate->cur_lineno,
 					   cstate->cur_attname);
 		else
-			errcontext("COPY %s, line %llu",
+			errcontext("COPY %s, line %" PRIu64,
 					   cstate->cur_relname,
-					   (unsigned long long) cstate->cur_lineno);
+					   cstate->cur_lineno);
 	}
 	else
 	{
@@ -282,9 +282,9 @@ CopyFromErrorCallback(void *arg)
 			char	   *attval;
 
 			attval = CopyLimitPrintoutLength(cstate->cur_attval);
-			errcontext("COPY %s, line %llu, column %s: \"%s\"",
+			errcontext("COPY %s, line %" PRIu64 ", column %s: \"%s\"",
 					   cstate->cur_relname,
-					   (unsigned long long) cstate->cur_lineno,
+					   cstate->cur_lineno,
 					   cstate->cur_attname,
 					   attval);
 			pfree(attval);
@@ -292,9 +292,9 @@ CopyFromErrorCallback(void *arg)
 		else if (cstate->cur_attname)
 		{
 			/* error is relevant to a particular column, value is NULL */
-			errcontext("COPY %s, line %llu, column %s: null input",
+			errcontext("COPY %s, line %" PRIu64 ", column %s: null input",
 					   cstate->cur_relname,
-					   (unsigned long long) cstate->cur_lineno,
+					   cstate->cur_lineno,
 					   cstate->cur_attname);
 		}
 		else
@@ -309,16 +309,16 @@ CopyFromErrorCallback(void *arg)
 				char	   *lineval;
 
 				lineval = CopyLimitPrintoutLength(cstate->line_buf.data);
-				errcontext("COPY %s, line %llu: \"%s\"",
+				errcontext("COPY %s, line %" PRIu64 ": \"%s\"",
 						   cstate->cur_relname,
-						   (unsigned long long) cstate->cur_lineno, lineval);
+						   cstate->cur_lineno, lineval);
 				pfree(lineval);
 			}
 			else
 			{
-				errcontext("COPY %s, line %llu",
+				errcontext("COPY %s, line %" PRIu64,
 						   cstate->cur_relname,
-						   (unsigned long long) cstate->cur_lineno);
+						   cstate->cur_lineno);
 			}
 		}
 	}
@@ -1168,8 +1168,8 @@ CopyFrom(CopyFromState cstate)
 				cstate->num_errors > cstate->opts.reject_limit)
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
-						 errmsg("skipped more than REJECT_LIMIT (%lld) rows due to data type incompatibility",
-								(long long) cstate->opts.reject_limit)));
+						 errmsg("skipped more than REJECT_LIMIT (%" PRId64 ") rows due to data type incompatibility",
+								cstate->opts.reject_limit)));
 
 			/* Repeat NextCopyFrom() until no soft error occurs */
 			continue;
@@ -1471,10 +1471,10 @@ CopyFrom(CopyFromState cstate)
 		cstate->num_errors > 0 &&
 		cstate->opts.log_verbosity >= COPY_LOG_VERBOSITY_DEFAULT)
 		ereport(NOTICE,
-				errmsg_plural("%llu row was skipped due to data type incompatibility",
-							  "%llu rows were skipped due to data type incompatibility",
-							  (unsigned long long) cstate->num_errors,
-							  (unsigned long long) cstate->num_errors));
+				errmsg_plural("%" PRIu64 " row was skipped due to data type incompatibility",
+							  "%" PRIu64 " rows were skipped due to data type incompatibility",
+							  cstate->num_errors,
+							  cstate->num_errors));
 
 	if (bistate != NULL)
 		FreeBulkInsertState(bistate);
diff --git a/src/backend/commands/copyfromparse.c b/src/backend/commands/copyfromparse.c
index e8128f85e6b..f5fc346e201 100644
--- a/src/backend/commands/copyfromparse.c
+++ b/src/backend/commands/copyfromparse.c
@@ -1053,16 +1053,16 @@ CopyFromTextLikeOneRow(CopyFromState cstate, ExprContext *econtext,
 
 					attval = CopyLimitPrintoutLength(cstate->cur_attval);
 					ereport(NOTICE,
-							errmsg("skipping row due to data type incompatibility at line %llu for column \"%s\": \"%s\"",
-								   (unsigned long long) cstate->cur_lineno,
+							errmsg("skipping row due to data type incompatibility at line %" PRIu64 " for column \"%s\": \"%s\"",
+								   cstate->cur_lineno,
 								   cstate->cur_attname,
 								   attval));
 					pfree(attval);
 				}
 				else
 					ereport(NOTICE,
-							errmsg("skipping row due to data type incompatibility at line %llu for column \"%s\": null input",
-								   (unsigned long long) cstate->cur_lineno,
+							errmsg("skipping row due to data type incompatibility at line %" PRIu64 " for column \"%s\": null input",
+								   cstate->cur_lineno,
 								   cstate->cur_attname));
 
 				/* reset relname_only */
diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index d8a7232cedb..93cb2768bc6 100644
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -4080,17 +4080,17 @@ show_buffer_usage(ExplainState *es, const BufferUsage *usage)
 			{
 				appendStringInfoString(es->str, " shared");
 				if (usage->shared_blks_hit > 0)
-					appendStringInfo(es->str, " hit=%lld",
-									 (long long) usage->shared_blks_hit);
+					appendStringInfo(es->str, " hit=%" PRId64,
+									 usage->shared_blks_hit);
 				if (usage->shared_blks_read > 0)
-					appendStringInfo(es->str, " read=%lld",
-									 (long long) usage->shared_blks_read);
+					appendStringInfo(es->str, " read=%" PRId64,
+									 usage->shared_blks_read);
 				if (usage->shared_blks_dirtied > 0)
-					appendStringInfo(es->str, " dirtied=%lld",
-									 (long long) usage->shared_blks_dirtied);
+					appendStringInfo(es->str, " dirtied=%" PRId64,
+									 usage->shared_blks_dirtied);
 				if (usage->shared_blks_written > 0)
-					appendStringInfo(es->str, " written=%lld",
-									 (long long) usage->shared_blks_written);
+					appendStringInfo(es->str, " written=%" PRId64,
+									 usage->shared_blks_written);
 				if (has_local || has_temp)
 					appendStringInfoChar(es->str, ',');
 			}
@@ -4098,17 +4098,17 @@ show_buffer_usage(ExplainState *es, const BufferUsage *usage)
 			{
 				appendStringInfoString(es->str, " local");
 				if (usage->local_blks_hit > 0)
-					appendStringInfo(es->str, " hit=%lld",
-									 (long long) usage->local_blks_hit);
+					appendStringInfo(es->str, " hit=%" PRId64,
+									 usage->local_blks_hit);
 				if (usage->local_blks_read > 0)
-					appendStringInfo(es->str, " read=%lld",
-									 (long long) usage->local_blks_read);
+					appendStringInfo(es->str, " read=%" PRId64,
+									 usage->local_blks_read);
 				if (usage->local_blks_dirtied > 0)
-					appendStringInfo(es->str, " dirtied=%lld",
-									 (long long) usage->local_blks_dirtied);
+					appendStringInfo(es->str, " dirtied=%" PRId64,
+									 usage->local_blks_dirtied);
 				if (usage->local_blks_written > 0)
-					appendStringInfo(es->str, " written=%lld",
-									 (long long) usage->local_blks_written);
+					appendStringInfo(es->str, " written=%" PRId64,
+									 usage->local_blks_written);
 				if (has_temp)
 					appendStringInfoChar(es->str, ',');
 			}
@@ -4116,11 +4116,11 @@ show_buffer_usage(ExplainState *es, const BufferUsage *usage)
 			{
 				appendStringInfoString(es->str, " temp");
 				if (usage->temp_blks_read > 0)
-					appendStringInfo(es->str, " read=%lld",
-									 (long long) usage->temp_blks_read);
+					appendStringInfo(es->str, " read=%" PRId64,
+									 usage->temp_blks_read);
 				if (usage->temp_blks_written > 0)
-					appendStringInfo(es->str, " written=%lld",
-									 (long long) usage->temp_blks_written);
+					appendStringInfo(es->str, " written=%" PRId64,
+									 usage->temp_blks_written);
 			}
 			appendStringInfoChar(es->str, '\n');
 		}
@@ -4230,17 +4230,17 @@ show_wal_usage(ExplainState *es, const WalUsage *usage)
 			appendStringInfoString(es->str, "WAL:");
 
 			if (usage->wal_records > 0)
-				appendStringInfo(es->str, " records=%lld",
-								 (long long) usage->wal_records);
+				appendStringInfo(es->str, " records=%" PRId64,
+								 usage->wal_records);
 			if (usage->wal_fpi > 0)
-				appendStringInfo(es->str, " fpi=%lld",
-								 (long long) usage->wal_fpi);
+				appendStringInfo(es->str, " fpi=%" PRId64,
+								 usage->wal_fpi);
 			if (usage->wal_bytes > 0)
-				appendStringInfo(es->str, " bytes=" UINT64_FORMAT,
+				appendStringInfo(es->str, " bytes=%" PRIu64,
 								 usage->wal_bytes);
 			if (usage->wal_buffers_full > 0)
-				appendStringInfo(es->str, " buffers full=%lld",
-								 (long long) usage->wal_buffers_full);
+				appendStringInfo(es->str, " buffers full=%" PRId64,
+								 usage->wal_buffers_full);
 			appendStringInfoChar(es->str, '\n');
 		}
 	}
diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c
index 4b7c5113aab..451ae6f7f69 100644
--- a/src/backend/commands/sequence.c
+++ b/src/backend/commands/sequence.c
@@ -745,9 +745,9 @@ nextval_internal(Oid relid, bool check_permissions)
 				if (!cycle)
 					ereport(ERROR,
 							(errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
-							 errmsg("nextval: reached maximum value of sequence \"%s\" (%lld)",
+							 errmsg("nextval: reached maximum value of sequence \"%s\" (%" PRId64 ")",
 									RelationGetRelationName(seqrel),
-									(long long) maxv)));
+									maxv)));
 				next = minv;
 			}
 			else
@@ -764,9 +764,9 @@ nextval_internal(Oid relid, bool check_permissions)
 				if (!cycle)
 					ereport(ERROR,
 							(errcode(ERRCODE_SEQUENCE_GENERATOR_LIMIT_EXCEEDED),
-							 errmsg("nextval: reached minimum value of sequence \"%s\" (%lld)",
+							 errmsg("nextval: reached minimum value of sequence \"%s\" (%" PRId64 ")",
 									RelationGetRelationName(seqrel),
-									(long long) minv)));
+									minv)));
 				next = maxv;
 			}
 			else
@@ -988,9 +988,9 @@ do_setval(Oid relid, int64 next, bool iscalled)
 	if ((next < minv) || (next > maxv))
 		ereport(ERROR,
 				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
-				 errmsg("setval: value %lld is out of bounds for sequence \"%s\" (%lld..%lld)",
-						(long long) next, RelationGetRelationName(seqrel),
-						(long long) minv, (long long) maxv)));
+				 errmsg("setval: value %" PRId64 " is out of bounds for sequence \"%s\" (%" PRId64 "..%" PRId64 ")",
+						next, RelationGetRelationName(seqrel),
+						minv, maxv)));
 
 	/* Set the currval() state only if iscalled = true */
 	if (iscalled)
@@ -1463,8 +1463,8 @@ init_params(ParseState *pstate, List *options, bool for_identity,
 		|| (seqform->seqtypid == INT4OID && (seqform->seqmax < PG_INT32_MIN || seqform->seqmax > PG_INT32_MAX)))
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("MAXVALUE (%lld) is out of range for sequence data type %s",
-						(long long) seqform->seqmax,
+				 errmsg("MAXVALUE (%" PRId64 ") is out of range for sequence data type %s",
+						seqform->seqmax,
 						format_type_be(seqform->seqtypid))));
 
 	/* MINVALUE (null arg means NO MINVALUE) */
@@ -1495,17 +1495,17 @@ init_params(ParseState *pstate, List *options, bool for_identity,
 		|| (seqform->seqtypid == INT4OID && (seqform->seqmin < PG_INT32_MIN || seqform->seqmin > PG_INT32_MAX)))
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("MINVALUE (%lld) is out of range for sequence data type %s",
-						(long long) seqform->seqmin,
+				 errmsg("MINVALUE (%" PRId64 ") is out of range for sequence data type %s",
+						seqform->seqmin,
 						format_type_be(seqform->seqtypid))));
 
 	/* crosscheck min/max */
 	if (seqform->seqmin >= seqform->seqmax)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("MINVALUE (%lld) must be less than MAXVALUE (%lld)",
-						(long long) seqform->seqmin,
-						(long long) seqform->seqmax)));
+				 errmsg("MINVALUE (%" PRId64 ") must be less than MAXVALUE (%" PRId64 ")",
+						seqform->seqmin,
+						seqform->seqmax)));
 
 	/* START WITH */
 	if (start_value != NULL)
@@ -1524,15 +1524,15 @@ init_params(ParseState *pstate, List *options, bool for_identity,
 	if (seqform->seqstart < seqform->seqmin)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("START value (%lld) cannot be less than MINVALUE (%lld)",
-						(long long) seqform->seqstart,
-						(long long) seqform->seqmin)));
+				 errmsg("START value (%" PRId64 ") cannot be less than MINVALUE (%" PRId64 ")",
+						seqform->seqstart,
+						seqform->seqmin)));
 	if (seqform->seqstart > seqform->seqmax)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("START value (%lld) cannot be greater than MAXVALUE (%lld)",
-						(long long) seqform->seqstart,
-						(long long) seqform->seqmax)));
+				 errmsg("START value (%" PRId64 ") cannot be greater than MAXVALUE (%" PRId64 ")",
+						seqform->seqstart,
+						seqform->seqmax)));
 
 	/* RESTART [WITH] */
 	if (restart_value != NULL)
@@ -1554,15 +1554,15 @@ init_params(ParseState *pstate, List *options, bool for_identity,
 	if (seqdataform->last_value < seqform->seqmin)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("RESTART value (%lld) cannot be less than MINVALUE (%lld)",
-						(long long) seqdataform->last_value,
-						(long long) seqform->seqmin)));
+				 errmsg("RESTART value (%" PRId64 ") cannot be less than MINVALUE (%" PRId64 ")",
+						seqdataform->last_value,
+						seqform->seqmin)));
 	if (seqdataform->last_value > seqform->seqmax)
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("RESTART value (%lld) cannot be greater than MAXVALUE (%lld)",
-						(long long) seqdataform->last_value,
-						(long long) seqform->seqmax)));
+				 errmsg("RESTART value (%" PRId64 ") cannot be greater than MAXVALUE (%" PRId64 ")",
+						seqdataform->last_value,
+						seqform->seqmax)));
 
 	/* CACHE */
 	if (cache_value != NULL)
@@ -1571,8 +1571,8 @@ init_params(ParseState *pstate, List *options, bool for_identity,
 		if (seqform->seqcache <= 0)
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-					 errmsg("CACHE (%lld) must be greater than zero",
-							(long long) seqform->seqcache)));
+					 errmsg("CACHE (%" PRId64 ") must be greater than zero",
+							seqform->seqcache)));
 		seqdataform->log_cnt = 0;
 	}
 	else if (isInit)
diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index 0239d9bae65..aa7beb04aa4 100644
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -2599,9 +2599,9 @@ vac_bulkdel_one_index(IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat,
 							  dead_items);
 
 	ereport(ivinfo->message_level,
-			(errmsg("scanned index \"%s\" to remove %lld row versions",
+			(errmsg("scanned index \"%s\" to remove %" PRId64 " row versions",
 					RelationGetRelationName(ivinfo->index),
-					(long long) dead_items_info->num_items)));
+					dead_items_info->num_items)));
 
 	return istat;
 }
diff --git a/src/backend/replication/logical/logical.c b/src/backend/replication/logical/logical.c
index 8ea846bfc3b..a8d2e024d34 100644
--- a/src/backend/replication/logical/logical.c
+++ b/src/backend/replication/logical/logical.c
@@ -1921,16 +1921,16 @@ UpdateDecodingStats(LogicalDecodingContext *ctx)
 	if (rb->spillBytes <= 0 && rb->streamBytes <= 0 && rb->totalBytes <= 0)
 		return;
 
-	elog(DEBUG2, "UpdateDecodingStats: updating stats %p %lld %lld %lld %lld %lld %lld %lld %lld",
+	elog(DEBUG2, "UpdateDecodingStats: updating stats %p %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64 " %" PRId64,
 		 rb,
-		 (long long) rb->spillTxns,
-		 (long long) rb->spillCount,
-		 (long long) rb->spillBytes,
-		 (long long) rb->streamTxns,
-		 (long long) rb->streamCount,
-		 (long long) rb->streamBytes,
-		 (long long) rb->totalTxns,
-		 (long long) rb->totalBytes);
+		 rb->spillTxns,
+		 rb->spillCount,
+		 rb->spillBytes,
+		 rb->streamTxns,
+		 rb->streamCount,
+		 rb->streamBytes,
+		 rb->totalTxns,
+		 rb->totalBytes);
 
 	repSlotStat.spill_txns = rb->spillTxns;
 	repSlotStat.spill_count = rb->spillCount;
diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c
index 719e531eb90..f52a2c0fa8f 100644
--- a/src/backend/replication/slot.c
+++ b/src/backend/replication/slot.c
@@ -1544,11 +1544,11 @@ ReportSlotInvalidation(ReplicationSlotInvalidationCause cause,
 	{
 		case RS_INVAL_WAL_REMOVED:
 			{
-				unsigned long long ex = oldestLSN - restart_lsn;
+				uint64		ex = oldestLSN - restart_lsn;
 
 				appendStringInfo(&err_detail,
-								 ngettext("The slot's restart_lsn %X/%X exceeds the limit by %llu byte.",
-										  "The slot's restart_lsn %X/%X exceeds the limit by %llu bytes.",
+								 ngettext("The slot's restart_lsn %X/%X exceeds the limit by %" PRIu64 " byte.",
+										  "The slot's restart_lsn %X/%X exceeds the limit by %" PRIu64 " bytes.",
 										  ex),
 								 LSN_FORMAT_ARGS(restart_lsn),
 								 ex);
diff --git a/src/backend/replication/walreceiver.c b/src/backend/replication/walreceiver.c
index 82f7302ff9f..99a1d7d606c 100644
--- a/src/backend/replication/walreceiver.c
+++ b/src/backend/replication/walreceiver.c
@@ -387,8 +387,8 @@ WalReceiverMain(const void *startup_data, size_t startup_data_len)
 		if (is_temp_slot)
 		{
 			snprintf(slotname, sizeof(slotname),
-					 "pg_walreceiver_%lld",
-					 (long long int) walrcv_get_backend_pid(wrconn));
+					 "pg_walreceiver_%" PRId64,
+					 (int64) walrcv_get_backend_pid(wrconn));
 
 			walrcv_create_slot(wrconn, slotname, true, false, false, 0, NULL);
 
diff --git a/src/backend/storage/ipc/ipc.c b/src/backend/storage/ipc/ipc.c
index e4d5b944e12..2704e80b3a7 100644
--- a/src/backend/storage/ipc/ipc.c
+++ b/src/backend/storage/ipc/ipc.c
@@ -399,8 +399,8 @@ cancel_before_shmem_exit(pg_on_exit_callback function, Datum arg)
 		before_shmem_exit_list[before_shmem_exit_index - 1].arg == arg)
 		--before_shmem_exit_index;
 	else
-		elog(ERROR, "before_shmem_exit callback (%p,0x%llx) is not the latest entry",
-			 function, (long long) arg);
+		elog(ERROR, "before_shmem_exit callback (%p,0x%" PRIx64 ") is not the latest entry",
+			 function, arg);
 }
 
 /* ----------------------------------------------------------------
diff --git a/src/backend/storage/ipc/signalfuncs.c b/src/backend/storage/ipc/signalfuncs.c
index bebc97ecffd..a3a670ba247 100644
--- a/src/backend/storage/ipc/signalfuncs.c
+++ b/src/backend/storage/ipc/signalfuncs.c
@@ -215,10 +215,10 @@ pg_wait_until_termination(int pid, int64 timeout)
 	} while (remainingtime > 0);
 
 	ereport(WARNING,
-			(errmsg_plural("backend with PID %d did not terminate within %lld millisecond",
-						   "backend with PID %d did not terminate within %lld milliseconds",
+			(errmsg_plural("backend with PID %d did not terminate within %" PRId64 " millisecond",
+						   "backend with PID %d did not terminate within %" PRId64 " milliseconds",
 						   timeout,
-						   pid, (long long int) timeout)));
+						   pid, timeout)));
 
 	return false;
 }
diff --git a/src/backend/utils/activity/pgstat.c b/src/backend/utils/activity/pgstat.c
index 3168b825e25..7c8e274f082 100644
--- a/src/backend/utils/activity/pgstat.c
+++ b/src/backend/utils/activity/pgstat.c
@@ -1684,9 +1684,9 @@ pgstat_write_statsfile(XLogRecPtr redo)
 		 */
 		if (!pgstat_is_kind_valid(ps->key.kind))
 		{
-			elog(WARNING, "found unknown stats entry %u/%u/%llu",
+			elog(WARNING, "found unknown stats entry %u/%u/%" PRIu64,
 				 ps->key.kind, ps->key.dboid,
-				 (unsigned long long) ps->key.objid);
+				 ps->key.objid);
 			continue;
 		}
 
@@ -1926,9 +1926,9 @@ pgstat_read_statsfile(XLogRecPtr redo)
 
 						if (!pgstat_is_kind_valid(key.kind))
 						{
-							elog(WARNING, "invalid stats kind for entry %u/%u/%llu of type %c",
+							elog(WARNING, "invalid stats kind for entry %u/%u/%" PRIu64 " of type %c",
 								 key.kind, key.dboid,
-								 (unsigned long long) key.objid, t);
+								 key.objid, t);
 							goto error;
 						}
 					}
@@ -1999,9 +1999,9 @@ pgstat_read_statsfile(XLogRecPtr redo)
 					if (found)
 					{
 						dshash_release_lock(pgStatLocal.shared_hash, p);
-						elog(WARNING, "found duplicate stats entry %u/%u/%llu of type %c",
+						elog(WARNING, "found duplicate stats entry %u/%u/%" PRIu64 " of type %c",
 							 key.kind, key.dboid,
-							 (unsigned long long) key.objid, t);
+							 key.objid, t);
 						goto error;
 					}
 
@@ -2012,9 +2012,9 @@ pgstat_read_statsfile(XLogRecPtr redo)
 									pgstat_get_entry_data(key.kind, header),
 									pgstat_get_entry_len(key.kind)))
 					{
-						elog(WARNING, "could not read data for entry %u/%u/%llu of type %c",
+						elog(WARNING, "could not read data for entry %u/%u/%" PRIu64 " of type %c",
 							 key.kind, key.dboid,
-							 (unsigned long long) key.objid, t);
+							 key.objid, t);
 						goto error;
 					}
 
diff --git a/src/backend/utils/activity/pgstat_replslot.c b/src/backend/utils/activity/pgstat_replslot.c
index cd56cb32861..ccfb11c49bf 100644
--- a/src/backend/utils/activity/pgstat_replslot.c
+++ b/src/backend/utils/activity/pgstat_replslot.c
@@ -194,8 +194,8 @@ pgstat_replslot_to_serialized_name_cb(const PgStat_HashKey *key, const PgStatSha
 	 * at the offset.
 	 */
 	if (!ReplicationSlotName(key->objid, name))
-		elog(ERROR, "could not find name for replication slot index %llu",
-			 (unsigned long long) key->objid);
+		elog(ERROR, "could not find name for replication slot index %" PRIu64,
+			 key->objid);
 }
 
 bool
diff --git a/src/backend/utils/activity/pgstat_shmem.c b/src/backend/utils/activity/pgstat_shmem.c
index 770d62425c5..5cd24303755 100644
--- a/src/backend/utils/activity/pgstat_shmem.c
+++ b/src/backend/utils/activity/pgstat_shmem.c
@@ -864,10 +864,10 @@ pgstat_drop_entry_internal(PgStatShared_HashEntry *shent,
 	 */
 	if (shent->dropped)
 		elog(ERROR,
-			 "trying to drop stats entry already dropped: kind=%s dboid=%u objid=%llu refcount=%u",
+			 "trying to drop stats entry already dropped: kind=%s dboid=%u objid=%" PRIu64 " refcount=%u",
 			 pgstat_get_kind_info(shent->key.kind)->name,
 			 shent->key.dboid,
-			 (unsigned long long) shent->key.objid,
+			 shent->key.objid,
 			 pg_atomic_read_u32(&shent->refcount));
 	shent->dropped = true;
 
diff --git a/src/backend/utils/activity/pgstat_xact.c b/src/backend/utils/activity/pgstat_xact.c
index 76a4f24aa82..bc9864bd8d9 100644
--- a/src/backend/utils/activity/pgstat_xact.c
+++ b/src/backend/utils/activity/pgstat_xact.c
@@ -363,9 +363,9 @@ pgstat_create_transactional(PgStat_Kind kind, Oid dboid, uint64 objid)
 	if (pgstat_get_entry_ref(kind, dboid, objid, false, NULL))
 	{
 		ereport(WARNING,
-				errmsg("resetting existing statistics for kind %s, db=%u, oid=%llu",
+				errmsg("resetting existing statistics for kind %s, db=%u, oid=%" PRIu64,
 					   (pgstat_get_kind_info(kind))->name, dboid,
-					   (unsigned long long) objid));
+					   objid));
 
 		pgstat_reset(kind, dboid, objid);
 	}
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 5d893cff50c..793d8a9adcc 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4630,7 +4630,7 @@ AddISO8601IntPart(char *cp, int64 value, char units)
 {
 	if (value == 0)
 		return cp;
-	sprintf(cp, "%lld%c", (long long) value, units);
+	sprintf(cp, "%" PRId64 "%c", value, units);
 	return cp + strlen(cp);
 }
 
@@ -4641,10 +4641,10 @@ AddPostgresIntPart(char *cp, int64 value, const char *units,
 {
 	if (value == 0)
 		return cp;
-	sprintf(cp, "%s%s%lld %s%s",
+	sprintf(cp, "%s%s%" PRId64 " %s%s",
 			(!*is_zero) ? " " : "",
 			(*is_before && value > 0) ? "+" : "",
-			(long long) value,
+			value,
 			units,
 			(value != 1) ? "s" : "");
 
@@ -4672,7 +4672,7 @@ AddVerboseIntPart(char *cp, int64 value, const char *units,
 	}
 	else if (*is_before)
 		value = -value;
-	sprintf(cp, " %lld %s%s", (long long) value, units, (value == 1) ? "" : "s");
+	sprintf(cp, " %" PRId64 " %s%s", value, units, (value == 1) ? "" : "s");
 	*is_zero = false;
 	return cp + strlen(cp);
 }
@@ -4767,10 +4767,10 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
 					char		sec_sign = (hour < 0 || min < 0 ||
 											sec < 0 || fsec < 0) ? '-' : '+';
 
-					sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+					sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
 							year_sign, abs(year), abs(mon),
-							day_sign, (long long) i64abs(mday),
-							sec_sign, (long long) i64abs(hour), abs(min));
+							day_sign, i64abs(mday),
+							sec_sign, i64abs(hour), abs(min));
 					cp += strlen(cp);
 					cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
 					*cp = '\0';
@@ -4781,15 +4781,15 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
 				}
 				else if (has_day)
 				{
-					sprintf(cp, "%lld %lld:%02d:",
-							(long long) mday, (long long) hour, min);
+					sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+							mday, hour, min);
 					cp += strlen(cp);
 					cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
 					*cp = '\0';
 				}
 				else
 				{
-					sprintf(cp, "%lld:%02d:", (long long) hour, min);
+					sprintf(cp, "%" PRId64 ":%02d:", hour, min);
 					cp += strlen(cp);
 					cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
 					*cp = '\0';
@@ -4839,10 +4839,10 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
 			{
 				bool		minus = (hour < 0 || min < 0 || sec < 0 || fsec < 0);
 
-				sprintf(cp, "%s%s%02lld:%02d:",
+				sprintf(cp, "%s%s%02" PRId64 ":%02d:",
 						is_zero ? "" : " ",
 						(minus ? "-" : (is_before ? "+" : "")),
-						(long long) i64abs(hour), abs(min));
+						i64abs(hour), abs(min));
 				cp += strlen(cp);
 				cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
 				*cp = '\0';
diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c
index e4556571703..d65fd9f7189 100644
--- a/src/backend/utils/adt/varlena.c
+++ b/src/backend/utils/adt/varlena.c
@@ -3296,8 +3296,8 @@ byteaGetBit(PG_FUNCTION_ARGS)
 	if (n < 0 || n >= (int64) len * 8)
 		ereport(ERROR,
 				(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
-				 errmsg("index %lld out of valid range, 0..%lld",
-						(long long) n, (long long) len * 8 - 1)));
+				 errmsg("index %" PRId64 " out of valid range, 0..%" PRId64,
+						n, (int64) len * 8 - 1)));
 
 	/* n/8 is now known < len, so safe to cast to int */
 	byteNo = (int) (n / 8);
@@ -3368,8 +3368,8 @@ byteaSetBit(PG_FUNCTION_ARGS)
 	if (n < 0 || n >= (int64) len * 8)
 		ereport(ERROR,
 				(errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR),
-				 errmsg("index %lld out of valid range, 0..%lld",
-						(long long) n, (long long) len * 8 - 1)));
+				 errmsg("index %" PRId64 " out of valid range, 0..%" PRId64,
+						n, (int64) len * 8 - 1)));
 
 	/* n/8 is now known < len, so safe to cast to int */
 	byteNo = (int) (n / 8);
diff --git a/src/backend/utils/adt/xid8funcs.c b/src/backend/utils/adt/xid8funcs.c
index 88d798fbf4b..1da3964ca6f 100644
--- a/src/backend/utils/adt/xid8funcs.c
+++ b/src/backend/utils/adt/xid8funcs.c
@@ -117,8 +117,8 @@ TransactionIdInRecentPast(FullTransactionId fxid, TransactionId *extracted_xid)
 	if (!FullTransactionIdPrecedes(fxid, now_fullxid))
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("transaction ID %llu is in the future",
-						(unsigned long long) U64FromFullTransactionId(fxid))));
+				 errmsg("transaction ID %" PRIu64 " is in the future",
+						U64FromFullTransactionId(fxid))));
 
 	/*
 	 * TransamVariables->oldestClogXid is protected by XactTruncationLock, but
diff --git a/src/backend/utils/error/csvlog.c b/src/backend/utils/error/csvlog.c
index 8e9fbcb999b..fdac3c048e3 100644
--- a/src/backend/utils/error/csvlog.c
+++ b/src/backend/utils/error/csvlog.c
@@ -248,7 +248,7 @@ write_csvlog(ErrorData *edata)
 	appendStringInfoChar(&buf, ',');
 
 	/* query id */
-	appendStringInfo(&buf, "%lld", (long long) pgstat_get_my_query_id());
+	appendStringInfo(&buf, "%" PRId64, pgstat_get_my_query_id());
 
 	appendStringInfoChar(&buf, '\n');
 
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 860bbd40d42..a377565ac35 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -3148,11 +3148,11 @@ log_status_format(StringInfo buf, const char *format, ErrorData *edata)
 				break;
 			case 'Q':
 				if (padding != 0)
-					appendStringInfo(buf, "%*lld", padding,
-									 (long long) pgstat_get_my_query_id());
+					appendStringInfo(buf, "%*" PRId64, padding,
+									 pgstat_get_my_query_id());
 				else
-					appendStringInfo(buf, "%lld",
-									 (long long) pgstat_get_my_query_id());
+					appendStringInfo(buf, "%" PRId64,
+									 pgstat_get_my_query_id());
 				break;
 			default:
 				/* format error - ignore it */
diff --git a/src/backend/utils/error/jsonlog.c b/src/backend/utils/error/jsonlog.c
index 549e0f48ee8..519eacf17f8 100644
--- a/src/backend/utils/error/jsonlog.c
+++ b/src/backend/utils/error/jsonlog.c
@@ -284,8 +284,8 @@ write_jsonlog(ErrorData *edata)
 	}
 
 	/* query id */
-	appendJSONKeyValueFmt(&buf, "query_id", false, "%lld",
-						  (long long) pgstat_get_my_query_id());
+	appendJSONKeyValueFmt(&buf, "query_id", false, "%" PRId64,
+						  pgstat_get_my_query_id());
 
 	/* Finish string */
 	appendStringInfoChar(&buf, '}');
diff --git a/src/backend/utils/mmgr/mcxt.c b/src/backend/utils/mmgr/mcxt.c
index aa6da0d0352..885a26930d1 100644
--- a/src/backend/utils/mmgr/mcxt.c
+++ b/src/backend/utils/mmgr/mcxt.c
@@ -285,31 +285,31 @@ MemoryContextTraverseNext(MemoryContext curr, MemoryContext top)
 static void
 BogusFree(void *pointer)
 {
-	elog(ERROR, "pfree called with invalid pointer %p (header 0x%016llx)",
-		 pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
+	elog(ERROR, "pfree called with invalid pointer %p (header 0x%016" PRIx64 ")",
+		 pointer, GetMemoryChunkHeader(pointer));
 }
 
 static void *
 BogusRealloc(void *pointer, Size size, int flags)
 {
-	elog(ERROR, "repalloc called with invalid pointer %p (header 0x%016llx)",
-		 pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
+	elog(ERROR, "repalloc called with invalid pointer %p (header 0x%016" PRIx64 ")",
+		 pointer, GetMemoryChunkHeader(pointer));
 	return NULL;				/* keep compiler quiet */
 }
 
 static MemoryContext
 BogusGetChunkContext(void *pointer)
 {
-	elog(ERROR, "GetMemoryChunkContext called with invalid pointer %p (header 0x%016llx)",
-		 pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
+	elog(ERROR, "GetMemoryChunkContext called with invalid pointer %p (header 0x%016" PRIx64 ")",
+		 pointer, GetMemoryChunkHeader(pointer));
 	return NULL;				/* keep compiler quiet */
 }
 
 static Size
 BogusGetChunkSpace(void *pointer)
 {
-	elog(ERROR, "GetMemoryChunkSpace called with invalid pointer %p (header 0x%016llx)",
-		 pointer, (unsigned long long) GetMemoryChunkHeader(pointer));
+	elog(ERROR, "GetMemoryChunkSpace called with invalid pointer %p (header 0x%016" PRIx64 ")",
+		 pointer, GetMemoryChunkHeader(pointer));
 	return 0;					/* keep compiler quiet */
 }
 
diff --git a/src/backend/utils/sort/logtape.c b/src/backend/utils/sort/logtape.c
index 47e601ef62c..7ee2bdde556 100644
--- a/src/backend/utils/sort/logtape.c
+++ b/src/backend/utils/sort/logtape.c
@@ -263,8 +263,8 @@ ltsWriteBlock(LogicalTapeSet *lts, int64 blocknum, const void *buffer)
 	if (BufFileSeekBlock(lts->pfile, blocknum) != 0)
 		ereport(ERROR,
 				(errcode_for_file_access(),
-				 errmsg("could not seek to block %lld of temporary file",
-						(long long) blocknum)));
+				 errmsg("could not seek to block %" PRId64 " of temporary file",
+						blocknum)));
 	BufFileWrite(lts->pfile, buffer, BLCKSZ);
 
 	/* Update nBlocksWritten, if we extended the file */
@@ -284,8 +284,8 @@ ltsReadBlock(LogicalTapeSet *lts, int64 blocknum, void *buffer)
 	if (BufFileSeekBlock(lts->pfile, blocknum) != 0)
 		ereport(ERROR,
 				(errcode_for_file_access(),
-				 errmsg("could not seek to block %lld of temporary file",
-						(long long) blocknum)));
+				 errmsg("could not seek to block %" PRId64 " of temporary file",
+						blocknum)));
 	BufFileReadExact(lts->pfile, buffer, BLCKSZ);
 }
 
@@ -1100,10 +1100,10 @@ LogicalTapeBackspace(LogicalTape *lt, size_t size)
 		ltsReadBlock(lt->tapeSet, prev, lt->buffer);
 
 		if (TapeBlockGetTrailer(lt->buffer)->next != lt->curBlockNumber)
-			elog(ERROR, "broken tape, next of block %lld is %lld, expected %lld",
-				 (long long) prev,
-				 (long long) (TapeBlockGetTrailer(lt->buffer)->next),
-				 (long long) lt->curBlockNumber);
+			elog(ERROR, "broken tape, next of block %" PRId64 " is %" PRId64 ", expected %" PRId64,
+				 prev,
+				 (TapeBlockGetTrailer(lt->buffer)->next),
+				 lt->curBlockNumber);
 
 		lt->nbytes = TapeBlockPayloadSize;
 		lt->curBlockNumber = prev;
diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 2ef32d53a43..65ab83fff8b 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -918,13 +918,13 @@ tuplesort_free(Tuplesortstate *state)
 	if (trace_sort)
 	{
 		if (state->tapeset)
-			elog(LOG, "%s of worker %d ended, %lld disk blocks used: %s",
+			elog(LOG, "%s of worker %d ended, %" PRId64 " disk blocks used: %s",
 				 SERIAL(state) ? "external sort" : "parallel external sort",
-				 state->worker, (long long) spaceUsed, pg_rusage_show(&state->ru_start));
+				 state->worker, spaceUsed, pg_rusage_show(&state->ru_start));
 		else
-			elog(LOG, "%s of worker %d ended, %lld KB used: %s",
+			elog(LOG, "%s of worker %d ended, %" PRId64 " KB used: %s",
 				 SERIAL(state) ? "internal sort" : "unperformed parallel sort",
-				 state->worker, (long long) spaceUsed, pg_rusage_show(&state->ru_start));
+				 state->worker, spaceUsed, pg_rusage_show(&state->ru_start));
 	}
 
 	TRACE_POSTGRESQL_SORT_DONE(state->tapeset != NULL, spaceUsed);
diff --git a/src/bin/pg_basebackup/pg_createsubscriber.c b/src/bin/pg_basebackup/pg_createsubscriber.c
index a5a2d61165d..c4b96b6a160 100644
--- a/src/bin/pg_basebackup/pg_createsubscriber.c
+++ b/src/bin/pg_basebackup/pg_createsubscriber.c
@@ -598,8 +598,7 @@ get_primary_sysid(const char *conninfo)
 
 	sysid = strtou64(PQgetvalue(res, 0, 0), NULL, 10);
 
-	pg_log_info("system identifier is %llu on publisher",
-				(unsigned long long) sysid);
+	pg_log_info("system identifier is %" PRIu64 " on publisher", sysid);
 
 	PQclear(res);
 	disconnect_database(conn, false);
@@ -627,8 +626,7 @@ get_standby_sysid(const char *datadir)
 
 	sysid = cf->system_identifier;
 
-	pg_log_info("system identifier is %llu on subscriber",
-				(unsigned long long) sysid);
+	pg_log_info("system identifier is %" PRIu64 " on subscriber", sysid);
 
 	pg_free(cf);
 
@@ -668,8 +666,8 @@ modify_subscriber_sysid(const struct CreateSubscriberOptions *opt)
 	if (!dry_run)
 		update_controlfile(subscriber_dir, cf, true);
 
-	pg_log_info("system identifier is %llu on subscriber",
-				(unsigned long long) cf->system_identifier);
+	pg_log_info("system identifier is %" PRIu64 " on subscriber",
+				cf->system_identifier);
 
 	pg_log_info("running pg_resetwal on the subscriber");
 
diff --git a/src/bin/pg_basebackup/pg_receivewal.c b/src/bin/pg_basebackup/pg_receivewal.c
index de3584018b0..f8e091c72a1 100644
--- a/src/bin/pg_basebackup/pg_receivewal.c
+++ b/src/bin/pg_basebackup/pg_receivewal.c
@@ -320,8 +320,8 @@ FindStreamingStart(uint32 *tli)
 
 			if (statbuf.st_size != WalSegSz)
 			{
-				pg_log_warning("segment file \"%s\" has incorrect size %lld, skipping",
-							   dirent->d_name, (long long int) statbuf.st_size);
+				pg_log_warning("segment file \"%s\" has incorrect size %" PRId64 ", skipping",
+							   dirent->d_name, (pgoff_t) statbuf.st_size);
 				continue;
 			}
 		}
diff --git a/src/bin/pg_combinebackup/load_manifest.c b/src/bin/pg_combinebackup/load_manifest.c
index 485fe518e41..c7c0591c703 100644
--- a/src/bin/pg_combinebackup/load_manifest.c
+++ b/src/bin/pg_combinebackup/load_manifest.c
@@ -160,8 +160,8 @@ load_backup_manifest(char *backup_directory)
 			if (rc < 0)
 				pg_fatal("could not read file \"%s\": %m", pathname);
 			else
-				pg_fatal("could not read file \"%s\": read %d of %lld",
-						 pathname, rc, (long long int) statbuf.st_size);
+				pg_fatal("could not read file \"%s\": read %d of %" PRId64,
+						 pathname, rc, (pgoff_t) statbuf.st_size);
 		}
 
 		/* Close the manifest file. */
@@ -198,10 +198,10 @@ load_backup_manifest(char *backup_directory)
 				if (rc < 0)
 					pg_fatal("could not read file \"%s\": %m", pathname);
 				else
-					pg_fatal("could not read file \"%s\": read %lld of %lld",
+					pg_fatal("could not read file \"%s\": read %" PRId64 " of %" PRId64,
 							 pathname,
-							 (long long int) (statbuf.st_size + rc - bytes_left),
-							 (long long int) statbuf.st_size);
+							 (pgoff_t) (statbuf.st_size + rc - bytes_left),
+							 (pgoff_t) statbuf.st_size);
 			}
 			bytes_left -= rc;
 			json_parse_manifest_incremental_chunk(inc_state, buffer, rc, bytes_left == 0);
diff --git a/src/bin/pg_combinebackup/pg_combinebackup.c b/src/bin/pg_combinebackup/pg_combinebackup.c
index 5864ec574fb..a0eb3f686d6 100644
--- a/src/bin/pg_combinebackup/pg_combinebackup.c
+++ b/src/bin/pg_combinebackup/pg_combinebackup.c
@@ -298,10 +298,10 @@ main(int argc, char *argv[])
 
 			controlpath = psprintf("%s/%s", prior_backup_dirs[i], "global/pg_control");
 
-			pg_fatal("%s: manifest system identifier is %llu, but control file has %llu",
+			pg_fatal("%s: manifest system identifier is %" PRIu64 ", but control file has %" PRIu64,
 					 controlpath,
-					 (unsigned long long) manifests[i]->system_identifier,
-					 (unsigned long long) system_identifier);
+					 manifests[i]->system_identifier,
+					 system_identifier);
 		}
 	}
 
@@ -622,9 +622,9 @@ check_control_files(int n_backups, char **backup_dirs)
 		if (i == n_backups - 1)
 			system_identifier = control_file->system_identifier;
 		else if (system_identifier != control_file->system_identifier)
-			pg_fatal("%s: expected system identifier %llu, but found %llu",
-					 controlpath, (unsigned long long) system_identifier,
-					 (unsigned long long) control_file->system_identifier);
+			pg_fatal("%s: expected system identifier %" PRIu64 ", but found %" PRIu64,
+					 controlpath, system_identifier,
+					 control_file->system_identifier);
 
 		/*
 		 * Detect checksum mismatches, but only if the last backup in the
@@ -645,8 +645,7 @@ check_control_files(int n_backups, char **backup_dirs)
 	 * If debug output is enabled, make a note of the system identifier that
 	 * we found in all of the relevant control files.
 	 */
-	pg_log_debug("system identifier is %llu",
-				 (unsigned long long) system_identifier);
+	pg_log_debug("system identifier is %" PRIu64, system_identifier);
 
 	/*
 	 * Warn the user if not all backups are in the same state with regards to
@@ -1399,8 +1398,8 @@ slurp_file(int fd, char *filename, StringInfo buf, int maxlen)
 		if (rb < 0)
 			pg_fatal("could not read file \"%s\": %m", filename);
 		else
-			pg_fatal("could not read file \"%s\": read %zd of %lld",
-					 filename, rb, (long long int) st.st_size);
+			pg_fatal("could not read file \"%s\": read %zd of %" PRId64,
+					 filename, rb, (pgoff_t) st.st_size);
 	}
 
 	/* Adjust buffer length for new data and restore trailing-\0 invariant */
diff --git a/src/bin/pg_combinebackup/reconstruct.c b/src/bin/pg_combinebackup/reconstruct.c
index 8acaa54ff38..94e9e9d1620 100644
--- a/src/bin/pg_combinebackup/reconstruct.c
+++ b/src/bin/pg_combinebackup/reconstruct.c
@@ -420,10 +420,10 @@ debug_reconstruction(int n_source, rfile **sources, bool dry_run)
 			if (fstat(s->fd, &sb) < 0)
 				pg_fatal("could not stat file \"%s\": %m", s->filename);
 			if (sb.st_size < s->highest_offset_read)
-				pg_fatal("file \"%s\" is too short: expected %llu, found %llu",
+				pg_fatal("file \"%s\" is too short: expected %" PRIu64 ", found %" PRIu64,
 						 s->filename,
-						 (unsigned long long) s->highest_offset_read,
-						 (unsigned long long) sb.st_size);
+						 (pgoff_t) s->highest_offset_read,
+						 (pgoff_t) sb.st_size);
 		}
 	}
 }
@@ -783,7 +783,7 @@ read_block(rfile *s, off_t off, uint8 *buffer)
 		if (rb < 0)
 			pg_fatal("could not read from file \"%s\": %m", s->filename);
 		else
-			pg_fatal("could not read from file \"%s\", offset %llu: read %d of %d",
-					 s->filename, (unsigned long long) off, rb, BLCKSZ);
+			pg_fatal("could not read from file \"%s\", offset %" PRIu64 ": read %d of %d",
+					 s->filename, (uint64) off, rb, BLCKSZ);
 	}
 }
diff --git a/src/bin/pg_combinebackup/write_manifest.c b/src/bin/pg_combinebackup/write_manifest.c
index 44879b3f3e8..313f8929df5 100644
--- a/src/bin/pg_combinebackup/write_manifest.c
+++ b/src/bin/pg_combinebackup/write_manifest.c
@@ -104,8 +104,7 @@ add_file_to_manifest(manifest_writer *mwriter, const char *manifest_path,
 		appendStringInfoString(&mwriter->buf, "\", ");
 	}
 
-	appendStringInfo(&mwriter->buf, "\"Size\": %llu, ",
-					 (unsigned long long) size);
+	appendStringInfo(&mwriter->buf, "\"Size\": %" PRIu64 ", ", size);
 
 	appendStringInfoString(&mwriter->buf, "\"Last-Modified\": \"");
 	enlargeStringInfo(&mwriter->buf, 128);
diff --git a/src/bin/pg_controldata/pg_controldata.c b/src/bin/pg_controldata/pg_controldata.c
index bea779eef94..9901a2bae51 100644
--- a/src/bin/pg_controldata/pg_controldata.c
+++ b/src/bin/pg_controldata/pg_controldata.c
@@ -239,8 +239,8 @@ main(int argc, char *argv[])
 		   ControlFile->pg_control_version);
 	printf(_("Catalog version number:               %u\n"),
 		   ControlFile->catalog_version_no);
-	printf(_("Database system identifier:           %llu\n"),
-		   (unsigned long long) ControlFile->system_identifier);
+	printf(_("Database system identifier:           %" PRIu64 "\n"),
+		   ControlFile->system_identifier);
 	printf(_("Database cluster state:               %s\n"),
 		   dbState(ControlFile->state));
 	printf(_("pg_control last modified:             %s\n"),
diff --git a/src/bin/pg_dump/pg_backup_tar.c b/src/bin/pg_dump/pg_backup_tar.c
index b5ba3b46dd9..22a991bce6d 100644
--- a/src/bin/pg_dump/pg_backup_tar.c
+++ b/src/bin/pg_dump/pg_backup_tar.c
@@ -1048,8 +1048,8 @@ _tarAddFile(ArchiveHandle *AH, TAR_MEMBER *th)
 		pg_fatal("could not close temporary file: %m");
 
 	if (len != th->fileLen)
-		pg_fatal("actual file length (%lld) does not match expected (%lld)",
-				 (long long) len, (long long) th->fileLen);
+		pg_fatal("actual file length (%" PRId64 ") does not match expected (%" PRId64 ")",
+				 len, th->fileLen);
 
 	pad = tarPaddingBytesRequired(len);
 	for (i = 0; i < pad; i++)
@@ -1079,14 +1079,14 @@ _tarPositionTo(ArchiveHandle *AH, const char *filename)
 	/* Go to end of current file, if any */
 	if (ctx->tarFHpos != 0)
 	{
-		pg_log_debug("moving from position %lld to next member at file position %lld",
-					 (long long) ctx->tarFHpos, (long long) ctx->tarNextMember);
+		pg_log_debug("moving from position %" PRId64 " to next member at file position %" PRId64,
+					 ctx->tarFHpos, ctx->tarNextMember);
 
 		while (ctx->tarFHpos < ctx->tarNextMember)
 			_tarReadRaw(AH, &c, 1, NULL, ctx->tarFH);
 	}
 
-	pg_log_debug("now at file position %lld", (long long) ctx->tarFHpos);
+	pg_log_debug("now at file position %" PRId64, ctx->tarFHpos);
 
 	/* We are at the start of the file, or at the next member */
 
@@ -1194,12 +1194,12 @@ _tarGetHeader(ArchiveHandle *AH, TAR_MEMBER *th)
 
 	len = read_tar_number(&h[TAR_OFFSET_SIZE], 12);
 
-	pg_log_debug("TOC Entry %s at %llu (length %llu, checksum %d)",
-				 tag, (unsigned long long) hPos, (unsigned long long) len, sum);
+	pg_log_debug("TOC Entry %s at %" PRIu64 " (length %" PRIu64 ", checksum %d)",
+				 tag, hPos, len, sum);
 
 	if (chk != sum)
-		pg_fatal("corrupt tar header found in %s (expected %d, computed %d) file position %llu",
-				 tag, sum, chk, (unsigned long long) ftello(ctx->tarFH));
+		pg_fatal("corrupt tar header found in %s (expected %d, computed %d) file position %" PRIu64,
+				 tag, sum, chk, ftello(ctx->tarFH));
 
 	th->targetFile = pg_strdup(tag);
 	th->fileLen = len;
diff --git a/src/bin/pg_resetwal/pg_resetwal.c b/src/bin/pg_resetwal/pg_resetwal.c
index 31bc0abff16..2ae3702efba 100644
--- a/src/bin/pg_resetwal/pg_resetwal.c
+++ b/src/bin/pg_resetwal/pg_resetwal.c
@@ -746,8 +746,8 @@ PrintControlValues(bool guessed)
 		   ControlFile.pg_control_version);
 	printf(_("Catalog version number:               %u\n"),
 		   ControlFile.catalog_version_no);
-	printf(_("Database system identifier:           %llu\n"),
-		   (unsigned long long) ControlFile.system_identifier);
+	printf(_("Database system identifier:           %" PRIu64 "\n"),
+		   ControlFile.system_identifier);
 	printf(_("Latest checkpoint's TimeLineID:       %u\n"),
 		   ControlFile.checkPointCopy.ThisTimeLineID);
 	printf(_("Latest checkpoint's full_page_writes: %s\n"),
diff --git a/src/bin/pg_rewind/libpq_source.c b/src/bin/pg_rewind/libpq_source.c
index d171839effe..4a6dfb586d3 100644
--- a/src/bin/pg_rewind/libpq_source.c
+++ b/src/bin/pg_rewind/libpq_source.c
@@ -567,8 +567,8 @@ process_queued_fetch_requests(libpq_source *src)
 		}
 		else
 		{
-			pg_log_debug("received chunk for file \"%s\", offset %lld, size %d",
-						 filename, (long long int) chunkoff, chunksize);
+			pg_log_debug("received chunk for file \"%s\", offset %" PRId64 ", size %d",
+						 filename, chunkoff, chunksize);
 
 			if (strcmp(filename, rq->path) != 0)
 			{
@@ -576,8 +576,8 @@ process_queued_fetch_requests(libpq_source *src)
 						 filename, rq->path);
 			}
 			if (chunkoff != rq->offset)
-				pg_fatal("received data at offset %lld of file \"%s\", when requested for offset %lld",
-						 (long long int) chunkoff, rq->path, (long long int) rq->offset);
+				pg_fatal("received data at offset %" PRId64 " of file \"%s\", when requested for offset %" PRId64,
+						 chunkoff, rq->path, (pgoff_t) rq->offset);
 
 			/*
 			 * We should not receive more data than we requested, or
diff --git a/src/bin/pg_verifybackup/astreamer_verify.c b/src/bin/pg_verifybackup/astreamer_verify.c
index 6c3a132ea3a..65c6299bd09 100644
--- a/src/bin/pg_verifybackup/astreamer_verify.c
+++ b/src/bin/pg_verifybackup/astreamer_verify.c
@@ -207,11 +207,11 @@ member_verify_header(astreamer *streamer, astreamer_member *member)
 	if (m->size != member->size)
 	{
 		report_backup_error(mystreamer->context,
-							"\"%s\" has size %llu in \"%s\" but size %llu in the manifest",
+							"\"%s\" has size %" PRId64 " in \"%s\" but size %" PRId64 " in the manifest",
 							member->pathname,
-							(unsigned long long) member->size,
+							member->size,
 							mystreamer->archive_name,
-							(unsigned long long) m->size);
+							m->size);
 		m->bad = true;
 		return;
 	}
@@ -296,10 +296,10 @@ member_verify_checksum(astreamer *streamer)
 	if (mystreamer->checksum_bytes != m->size)
 	{
 		report_backup_error(mystreamer->context,
-							"file \"%s\" in \"%s\" should contain %llu bytes, but read %llu bytes",
+							"file \"%s\" in \"%s\" should contain %" PRId64 " bytes, but read %" PRIu64 " bytes",
 							m->pathname, mystreamer->archive_name,
-							(unsigned long long) m->size,
-							(unsigned long long) mystreamer->checksum_bytes);
+							m->size,
+							mystreamer->checksum_bytes);
 		return;
 	}
 
@@ -408,11 +408,11 @@ member_verify_control_data(astreamer *streamer)
 	/* System identifiers should match. */
 	if (manifest->system_identifier !=
 		mystreamer->control_file.system_identifier)
-		report_fatal_error("%s: %s: manifest system identifier is %llu, but control file has %llu",
+		report_fatal_error("%s: %s: manifest system identifier is %" PRIu64 ", but control file has %" PRIu64,
 						   mystreamer->archive_name,
 						   mystreamer->mfile->pathname,
-						   (unsigned long long) manifest->system_identifier,
-						   (unsigned long long) mystreamer->control_file.system_identifier);
+						   manifest->system_identifier,
+						   mystreamer->control_file.system_identifier);
 }
 
 /*
diff --git a/src/bin/pg_verifybackup/pg_verifybackup.c b/src/bin/pg_verifybackup/pg_verifybackup.c
index 7c720ab98bd..c80f41d8697 100644
--- a/src/bin/pg_verifybackup/pg_verifybackup.c
+++ b/src/bin/pg_verifybackup/pg_verifybackup.c
@@ -438,8 +438,8 @@ parse_manifest_file(char *manifest_path)
 			if (rc < 0)
 				pg_fatal("could not read file \"%s\": %m", manifest_path);
 			else
-				pg_fatal("could not read file \"%s\": read %d of %lld",
-						 manifest_path, rc, (long long int) statbuf.st_size);
+				pg_fatal("could not read file \"%s\": read %d of %" PRId64,
+						 manifest_path, rc, (pgoff_t) statbuf.st_size);
 		}
 
 		/* Close the manifest file. */
@@ -476,10 +476,10 @@ parse_manifest_file(char *manifest_path)
 				if (rc < 0)
 					pg_fatal("could not read file \"%s\": %m", manifest_path);
 				else
-					pg_fatal("could not read file \"%s\": read %lld of %lld",
+					pg_fatal("could not read file \"%s\": read %" PRId64 " of %" PRId64,
 							 manifest_path,
-							 (long long int) (statbuf.st_size + rc - bytes_left),
-							 (long long int) statbuf.st_size);
+							 (pgoff_t) (statbuf.st_size + rc - bytes_left),
+							 (pgoff_t) statbuf.st_size);
 			}
 			bytes_left -= rc;
 			json_parse_manifest_incremental_chunk(inc_state, buffer, rc,
@@ -719,9 +719,9 @@ verify_plain_backup_file(verifier_context *context, char *relpath,
 	if (m->size != sb.st_size)
 	{
 		report_backup_error(context,
-							"\"%s\" has size %llu on disk but size %llu in the manifest",
-							relpath, (unsigned long long) sb.st_size,
-							(unsigned long long) m->size);
+							"\"%s\" has size %" PRId64 " on disk but size %" PRId64 " in the manifest",
+							relpath, (pgoff_t) sb.st_size,
+							m->size);
 		m->bad = true;
 	}
 
@@ -770,10 +770,10 @@ verify_control_file(const char *controlpath, uint64 manifest_system_identifier)
 
 	/* System identifiers should match. */
 	if (manifest_system_identifier != control_file->system_identifier)
-		report_fatal_error("%s: manifest system identifier is %llu, but control file has %llu",
+		report_fatal_error("%s: manifest system identifier is %" PRIu64 ", but control file has %" PRIu64,
 						   controlpath,
-						   (unsigned long long) manifest_system_identifier,
-						   (unsigned long long) control_file->system_identifier);
+						   manifest_system_identifier,
+						   control_file->system_identifier);
 
 	/* Release memory. */
 	pfree(control_file);
@@ -1165,9 +1165,8 @@ verify_file_checksum(verifier_context *context, manifest_file *m,
 	if (bytes_read != m->size)
 	{
 		report_backup_error(context,
-							"file \"%s\" should contain %llu bytes, but read %llu bytes",
-							relpath, (unsigned long long) m->size,
-							(unsigned long long) bytes_read);
+							"file \"%s\" should contain %" PRIu64 " bytes, but read %" PRIu64,
+							relpath, m->size, bytes_read);
 		return;
 	}
 
diff --git a/src/fe_utils/archive.c b/src/fe_utils/archive.c
index 5de3617cb29..a1c82a085c6 100644
--- a/src/fe_utils/archive.c
+++ b/src/fe_utils/archive.c
@@ -66,9 +66,9 @@ RestoreArchivedFile(const char *path, const char *xlogfname,
 		if (stat(xlogpath, &stat_buf) == 0)
 		{
 			if (expectedSize > 0 && stat_buf.st_size != expectedSize)
-				pg_fatal("unexpected file size for \"%s\": %lld instead of %lld",
-						 xlogfname, (long long int) stat_buf.st_size,
-						 (long long int) expectedSize);
+				pg_fatal("unexpected file size for \"%s\": %" PRId64 " instead of %" PRId64,
+						 xlogfname, (pgoff_t) stat_buf.st_size,
+						 (pgoff_t) expectedSize);
 			else
 			{
 				int			xlogfd = open(xlogpath, O_RDONLY | PG_BINARY, 0);
diff --git a/src/fe_utils/print.c b/src/fe_utils/print.c
index 5e5e54e1b75..d66630a1b50 100644
--- a/src/fe_utils/print.c
+++ b/src/fe_utils/print.c
@@ -3185,9 +3185,9 @@ printTableInit(printTableContent *const content, const printTableOpt *opt,
 	/* Catch possible overflow.  Using >= here allows adding 1 below */
 	if (total_cells >= SIZE_MAX / sizeof(*content->cells))
 	{
-		fprintf(stderr, _("Cannot print table contents: number of cells %lld is equal to or exceeds maximum %lld.\n"),
-				(long long int) total_cells,
-				(long long int) (SIZE_MAX / sizeof(*content->cells)));
+		fprintf(stderr, _("Cannot print table contents: number of cells %" PRId64 " is equal to or exceeds maximum %zd.\n"),
+				total_cells,
+				SIZE_MAX / sizeof(*content->cells));
 		exit(EXIT_FAILURE);
 	}
 	content->cells = pg_malloc0((total_cells + 1) * sizeof(*content->cells));
@@ -3269,8 +3269,8 @@ printTableAddCell(printTableContent *const content, char *cell,
 	total_cells = (uint64) content->ncolumns * content->nrows;
 	if (content->cellsadded >= total_cells)
 	{
-		fprintf(stderr, _("Cannot add cell to table content: total cell count of %lld exceeded.\n"),
-				(long long int) total_cells);
+		fprintf(stderr, _("Cannot add cell to table content: total cell count of %" PRIu64 " exceeded.\n"),
+				total_cells);
 		exit(EXIT_FAILURE);
 	}
 
diff --git a/src/include/lib/radixtree.h b/src/include/lib/radixtree.h
index f0abb0df389..a75b77270c4 100644
--- a/src/include/lib/radixtree.h
+++ b/src/include/lib/radixtree.h
@@ -2754,7 +2754,7 @@ RT_SCOPE void
 RT_STATS(RT_RADIX_TREE * tree)
 {
 	fprintf(stderr, "max_val = " UINT64_FORMAT "\n", tree->ctl->max_val);
-	fprintf(stderr, "num_keys = %lld\n", (long long) tree->ctl->num_keys);
+	fprintf(stderr, "num_keys = %" PRId64 "\n", tree->ctl->num_keys);
 
 #ifdef RT_SHMEM
 	fprintf(stderr, "handle = " DSA_POINTER_FORMAT "\n", tree->ctl->handle);
@@ -2766,10 +2766,10 @@ RT_STATS(RT_RADIX_TREE * tree)
 	{
 		RT_SIZE_CLASS_ELEM size_class = RT_SIZE_CLASS_INFO[i];
 
-		fprintf(stderr, ", n%d = %lld", size_class.fanout, (long long) tree->ctl->num_nodes[i]);
+		fprintf(stderr, ", n%d = %" PRId64, size_class.fanout, tree->ctl->num_nodes[i]);
 	}
 
-	fprintf(stderr, ", leaves = %lld", (long long) tree->ctl->num_leaves);
+	fprintf(stderr, ", leaves = %" PRId64, tree->ctl->num_leaves);
 
 	fprintf(stderr, "\n");
 }
diff --git a/src/test/modules/libpq_pipeline/libpq_pipeline.c b/src/test/modules/libpq_pipeline/libpq_pipeline.c
index 7ff18e91e66..177c1e936ad 100644
--- a/src/test/modules/libpq_pipeline/libpq_pipeline.c
+++ b/src/test/modules/libpq_pipeline/libpq_pipeline.c
@@ -1186,7 +1186,7 @@ test_pipelined_insert(PGconn *conn, int n_rows)
 			{
 				snprintf(insert_param_0, MAXINTLEN, "%d", rows_to_send);
 				/* use up some buffer space with a wide value */
-				snprintf(insert_param_1, MAXINT8LEN, "%lld", 1LL << 62);
+				snprintf(insert_param_1, MAXINT8LEN, "%" PRId64, UINT64_C(1) << 62);
 
 				if (PQsendQueryPrepared(conn, "my_insert",
 										2, insert_params, NULL, NULL, 0) == 1)
diff --git a/src/test/modules/test_copy_callbacks/test_copy_callbacks.c b/src/test/modules/test_copy_callbacks/test_copy_callbacks.c
index a83fdbd7cd8..41113a8acdc 100644
--- a/src/test/modules/test_copy_callbacks/test_copy_callbacks.c
+++ b/src/test/modules/test_copy_callbacks/test_copy_callbacks.c
@@ -42,8 +42,8 @@ test_copy_to_callback(PG_FUNCTION_ARGS)
 	processed = DoCopyTo(cstate);
 	EndCopyTo(cstate);
 
-	ereport(NOTICE, (errmsg("COPY TO callback has processed %lld rows",
-							(long long) processed)));
+	ereport(NOTICE, (errmsg("COPY TO callback has processed %" PRId64 " rows",
+							processed)));
 
 	table_close(rel, NoLock);
 
diff --git a/src/test/modules/test_slru/test_slru.c b/src/test/modules/test_slru/test_slru.c
index 3ea5ceb8552..2e4492900af 100644
--- a/src/test/modules/test_slru/test_slru.c
+++ b/src/test/modules/test_slru/test_slru.c
@@ -151,8 +151,8 @@ test_slru_page_sync(PG_FUNCTION_ARGS)
 	ftag.segno = pageno / SLRU_PAGES_PER_SEGMENT;
 	SlruSyncFileTag(TestSlruCtl, &ftag, path);
 
-	elog(NOTICE, "Called SlruSyncFileTag() for segment %lld on path %s",
-		 (long long) ftag.segno, path);
+	elog(NOTICE, "Called SlruSyncFileTag() for segment %" PRId64 " on path %s",
+		 ftag.segno, path);
 
 	PG_RETURN_VOID();
 }
@@ -166,8 +166,8 @@ test_slru_page_delete(PG_FUNCTION_ARGS)
 	ftag.segno = pageno / SLRU_PAGES_PER_SEGMENT;
 	SlruDeleteSegment(TestSlruCtl, ftag.segno);
 
-	elog(NOTICE, "Called SlruDeleteSegment() for segment %lld",
-		 (long long) ftag.segno);
+	elog(NOTICE, "Called SlruDeleteSegment() for segment %" PRId64,
+		 ftag.segno);
 
 	PG_RETURN_VOID();
 }
diff --git a/src/test/modules/xid_wraparound/xid_wraparound.c b/src/test/modules/xid_wraparound/xid_wraparound.c
index af2144d9beb..e27a5fa5769 100644
--- a/src/test/modules/xid_wraparound/xid_wraparound.c
+++ b/src/test/modules/xid_wraparound/xid_wraparound.c
@@ -35,7 +35,7 @@ consume_xids(PG_FUNCTION_ARGS)
 	FullTransactionId lastxid;
 
 	if (nxids < 0)
-		elog(ERROR, "invalid nxids argument: %lld", (long long) nxids);
+		elog(ERROR, "invalid nxids argument: %" PRId64, nxids);
 
 	if (nxids == 0)
 		lastxid = ReadNextFullTransactionId();
@@ -56,8 +56,8 @@ consume_xids_until(PG_FUNCTION_ARGS)
 	FullTransactionId lastxid;
 
 	if (!FullTransactionIdIsNormal(targetxid))
-		elog(ERROR, "targetxid %llu is not normal",
-			 (unsigned long long) U64FromFullTransactionId(targetxid));
+		elog(ERROR, "targetxid %" PRIu64 " is not normal",
+			 U64FromFullTransactionId(targetxid));
 
 	lastxid = consume_xids_common(targetxid, 0);
 
@@ -136,8 +136,8 @@ consume_xids_common(FullTransactionId untilxid, uint64 nxids)
 		if (consumed - last_reported_at >= REPORT_INTERVAL)
 		{
 			if (nxids > 0)
-				elog(NOTICE, "consumed %llu / %llu XIDs, latest %u:%u",
-					 (unsigned long long) consumed, (unsigned long long) nxids,
+				elog(NOTICE, "consumed %" PRIu64 " / %" PRIu64 " XIDs, latest %u:%u",
+					 consumed, nxids,
 					 EpochFromFullTransactionId(lastxid),
 					 XidFromFullTransactionId(lastxid));
 			else
-- 
2.48.1