v2-0001-Use-pg_attribute_always_inline-for-static-inline-.patch

From 1ab2df5f4fb800a1a58d2f049d4903bf2b4921b2 Mon Sep 17 00:00:00 2001
From: Maxim Orlov <orlovmg@gmail.com>
Date: Fri, 31 Jan 2025 16:16:10 +0300
Subject: [PATCH v2] Use pg_attribute_always_inline for static inline functions
 (htup_details.h, itup.h)

---
 src/include/access/htup_details.h | 110 +++++++++++++++---------------
 1 file changed, 55 insertions(+), 55 deletions(-)

diff --git a/src/include/access/htup_details.h b/src/include/access/htup_details.h
index 6cd4b95bfd..cce0df4c82 100644
--- a/src/include/access/htup_details.h
+++ b/src/include/access/htup_details.h
@@ -226,7 +226,7 @@ struct HeapTupleHeaderData
  * See also HeapTupleHeaderIsOnlyLocked, which also checks for a possible
  * aborted updater transaction.
  */
-static inline bool
+static pg_attribute_always_inline bool
 HEAP_XMAX_IS_LOCKED_ONLY(uint16 infomask)
 {
 	return (infomask & HEAP_XMAX_LOCK_ONLY) ||
@@ -251,7 +251,7 @@ HEAP_XMAX_IS_LOCKED_ONLY(uint16 infomask)
  * bogus, regardless of where they stand with respect to the current valid
  * multixact range.
  */
-static inline bool
+static pg_attribute_always_inline bool
 HEAP_LOCKED_UPGRADED(uint16 infomask)
 {
 	return
@@ -263,19 +263,19 @@ HEAP_LOCKED_UPGRADED(uint16 infomask)
 /*
  * Use these to test whether a particular lock is applied to a tuple
  */
-static inline bool
+static pg_attribute_always_inline bool
 HEAP_XMAX_IS_SHR_LOCKED(int16 infomask)
 {
 	return (infomask & HEAP_LOCK_MASK) == HEAP_XMAX_SHR_LOCK;
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HEAP_XMAX_IS_EXCL_LOCKED(int16 infomask)
 {
 	return (infomask & HEAP_LOCK_MASK) == HEAP_XMAX_EXCL_LOCK;
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HEAP_XMAX_IS_KEYSHR_LOCKED(int16 infomask)
 {
 	return (infomask & HEAP_LOCK_MASK) == HEAP_XMAX_KEYSHR_LOCK;
@@ -319,72 +319,72 @@ static bool HeapTupleHeaderXminFrozen(const HeapTupleHeaderData *tup);
  * the xmin to FrozenTransactionId, and that value may still be encountered
  * on disk.
  */
-static inline TransactionId
+static pg_attribute_always_inline TransactionId
 HeapTupleHeaderGetRawXmin(const HeapTupleHeaderData *tup)
 {
 	return tup->t_choice.t_heap.t_xmin;
 }
 
-static inline TransactionId
+static pg_attribute_always_inline TransactionId
 HeapTupleHeaderGetXmin(const HeapTupleHeaderData *tup)
 {
 	return HeapTupleHeaderXminFrozen(tup) ?
 		FrozenTransactionId : HeapTupleHeaderGetRawXmin(tup);
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetXmin(HeapTupleHeaderData *tup, TransactionId xid)
 {
 	tup->t_choice.t_heap.t_xmin = xid;
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHeaderXminCommitted(const HeapTupleHeaderData *tup)
 {
 	return (tup->t_infomask & HEAP_XMIN_COMMITTED) != 0;
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHeaderXminInvalid(const HeapTupleHeaderData *tup) \
 {
 	return (tup->t_infomask & (HEAP_XMIN_COMMITTED | HEAP_XMIN_INVALID)) ==
 		HEAP_XMIN_INVALID;
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHeaderXminFrozen(const HeapTupleHeaderData *tup)
 {
 	return (tup->t_infomask & HEAP_XMIN_FROZEN) == HEAP_XMIN_FROZEN;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetXminCommitted(HeapTupleHeaderData *tup)
 {
 	Assert(!HeapTupleHeaderXminInvalid(tup));
 	tup->t_infomask |= HEAP_XMIN_COMMITTED;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetXminInvalid(HeapTupleHeaderData *tup)
 {
 	Assert(!HeapTupleHeaderXminCommitted(tup));
 	tup->t_infomask |= HEAP_XMIN_INVALID;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetXminFrozen(HeapTupleHeaderData *tup)
 {
 	Assert(!HeapTupleHeaderXminInvalid(tup));
 	tup->t_infomask |= HEAP_XMIN_FROZEN;
 }
 
-static inline TransactionId
+static pg_attribute_always_inline TransactionId
 HeapTupleHeaderGetRawXmax(const HeapTupleHeaderData *tup)
 {
 	return tup->t_choice.t_heap.t_xmax;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetXmax(HeapTupleHeaderData *tup, TransactionId xid)
 {
 	tup->t_choice.t_heap.t_xmax = xid;
@@ -398,7 +398,7 @@ HeapTupleHeaderSetXmax(HeapTupleHeaderData *tup, TransactionId xid)
  * to resolve the MultiXactId if necessary.  This might involve multixact I/O,
  * so it should only be used if absolutely necessary.
  */
-static inline TransactionId
+static pg_attribute_always_inline TransactionId
 HeapTupleHeaderGetUpdateXid(const HeapTupleHeaderData *tup)
 {
 	if (!((tup)->t_infomask & HEAP_XMAX_INVALID) &&
@@ -416,14 +416,14 @@ HeapTupleHeaderGetUpdateXid(const HeapTupleHeaderData *tup)
  * HeapTupleHeaderGetCmax instead, but note that those Assert that you can
  * get a legitimate result, ie you are in the originating transaction!
  */
-static inline CommandId
+static pg_attribute_always_inline CommandId
 HeapTupleHeaderGetRawCommandId(const HeapTupleHeaderData *tup)
 {
 	return tup->t_choice.t_heap.t_field3.t_cid;
 }
 
 /* SetCmin is reasonably simple since we never need a combo CID */
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetCmin(HeapTupleHeaderData *tup, CommandId cid)
 {
 	Assert(!(tup->t_infomask & HEAP_MOVED));
@@ -432,7 +432,7 @@ HeapTupleHeaderSetCmin(HeapTupleHeaderData *tup, CommandId cid)
 }
 
 /* SetCmax must be used after HeapTupleHeaderAdjustCmax; see combocid.c */
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetCmax(HeapTupleHeaderData *tup, CommandId cid, bool iscombo)
 {
 	Assert(!((tup)->t_infomask & HEAP_MOVED));
@@ -443,7 +443,7 @@ HeapTupleHeaderSetCmax(HeapTupleHeaderData *tup, CommandId cid, bool iscombo)
 		tup->t_infomask &= ~HEAP_COMBOCID;
 }
 
-static inline TransactionId
+static pg_attribute_always_inline TransactionId
 HeapTupleHeaderGetXvac(const HeapTupleHeaderData *tup)
 {
 	if (tup->t_infomask & HEAP_MOVED)
@@ -452,7 +452,7 @@ HeapTupleHeaderGetXvac(const HeapTupleHeaderData *tup)
 		return InvalidTransactionId;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetXvac(HeapTupleHeaderData *tup, TransactionId xid)
 {
 	Assert(tup->t_infomask & HEAP_MOVED);
@@ -462,68 +462,68 @@ HeapTupleHeaderSetXvac(HeapTupleHeaderData *tup, TransactionId xid)
 StaticAssertDecl(MaxOffsetNumber < SpecTokenOffsetNumber,
 				 "invalid speculative token constant");
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHeaderIsSpeculative(const HeapTupleHeaderData *tup)
 {
 	return ItemPointerGetOffsetNumberNoCheck(&tup->t_ctid) == SpecTokenOffsetNumber;
 }
 
-static inline BlockNumber
+static pg_attribute_always_inline BlockNumber
 HeapTupleHeaderGetSpeculativeToken(const HeapTupleHeaderData *tup)
 {
 	Assert(HeapTupleHeaderIsSpeculative(tup));
 	return ItemPointerGetBlockNumber(&tup->t_ctid);
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetSpeculativeToken(HeapTupleHeaderData *tup, BlockNumber token)
 {
 	ItemPointerSet(&tup->t_ctid, token, SpecTokenOffsetNumber);
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHeaderIndicatesMovedPartitions(const HeapTupleHeaderData *tup)
 {
 	return ItemPointerIndicatesMovedPartitions(&tup->t_ctid);
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetMovedPartitions(HeapTupleHeaderData *tup)
 {
 	ItemPointerSetMovedPartitions(&tup->t_ctid);
 }
 
-static inline uint32
+static pg_attribute_always_inline uint32
 HeapTupleHeaderGetDatumLength(const HeapTupleHeaderData *tup)
 {
 	return VARSIZE(tup);
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetDatumLength(HeapTupleHeaderData *tup, uint32 len)
 {
 	SET_VARSIZE(tup, len);
 }
 
-static inline Oid
+static pg_attribute_always_inline Oid
 HeapTupleHeaderGetTypeId(const HeapTupleHeaderData *tup)
 {
 	return tup->t_choice.t_datum.datum_typeid;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetTypeId(HeapTupleHeaderData *tup, Oid datum_typeid)
 {
 	tup->t_choice.t_datum.datum_typeid = datum_typeid;
 }
 
-static inline int32
+static pg_attribute_always_inline int32
 HeapTupleHeaderGetTypMod(const HeapTupleHeaderData *tup)
 {
 	return tup->t_choice.t_datum.datum_typmod;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetTypMod(HeapTupleHeaderData *tup, int32 typmod)
 {
 	tup->t_choice.t_datum.datum_typmod = typmod;
@@ -535,7 +535,7 @@ HeapTupleHeaderSetTypMod(HeapTupleHeaderData *tup, int32 typmod)
  * efficiency, check tuple visibility before using this function, so that the
  * INVALID bits will be as up to date as possible.
  */
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHeaderIsHotUpdated(const HeapTupleHeaderData *tup)
 {
 	return
@@ -544,31 +544,31 @@ HeapTupleHeaderIsHotUpdated(const HeapTupleHeaderData *tup)
 		!HeapTupleHeaderXminInvalid(tup);
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetHotUpdated(HeapTupleHeaderData *tup)
 {
 	tup->t_infomask2 |= HEAP_HOT_UPDATED;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderClearHotUpdated(HeapTupleHeaderData *tup)
 {
 	tup->t_infomask2 &= ~HEAP_HOT_UPDATED;
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHeaderIsHeapOnly(const HeapTupleHeaderData *tup) \
 {
 	return (tup->t_infomask2 & HEAP_ONLY_TUPLE) != 0;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetHeapOnly(HeapTupleHeaderData *tup)
 {
 	tup->t_infomask2 |= HEAP_ONLY_TUPLE;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderClearHeapOnly(HeapTupleHeaderData *tup)
 {
 	tup->t_infomask2 &= ~HEAP_ONLY_TUPLE;
@@ -595,7 +595,7 @@ HeapTupleHeaderClearHeapOnly(HeapTupleHeaderData *tup)
  * BITMAPLEN(NATTS) -
  *		Computes size of null bitmap given number of data columns.
  */
-static inline int
+static pg_attribute_always_inline int
 BITMAPLEN(int NATTS)
 {
 	return (NATTS + 7) / 8;
@@ -707,19 +707,19 @@ struct MinimalTupleData
  * MinimalTuple accessor functions
  */
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHeaderHasMatch(const MinimalTupleData *tup)
 {
 	return (tup->t_infomask2 & HEAP_TUPLE_HAS_MATCH) != 0;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderSetMatch(MinimalTupleData *tup)
 {
 	tup->t_infomask2 |= HEAP_TUPLE_HAS_MATCH;
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleHeaderClearMatch(MinimalTupleData *tup)
 {
 	tup->t_infomask2 &= ~HEAP_TUPLE_HAS_MATCH;
@@ -729,7 +729,7 @@ HeapTupleHeaderClearMatch(MinimalTupleData *tup)
 /*
  * GETSTRUCT - given a HeapTuple pointer, return address of the user data
  */
-static inline void *
+static pg_attribute_always_inline void *
 GETSTRUCT(const HeapTupleData *tuple)
 {
 	return ((char *) (tuple->t_data) + tuple->t_data->t_hoff);
@@ -739,67 +739,67 @@ GETSTRUCT(const HeapTupleData *tuple)
  * Accessor functions to be used with HeapTuple pointers.
  */
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHasNulls(const HeapTupleData *tuple)
 {
 	return (tuple->t_data->t_infomask & HEAP_HASNULL) != 0;
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleNoNulls(const HeapTupleData *tuple)
 {
 	return !HeapTupleHasNulls(tuple);
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHasVarWidth(const HeapTupleData *tuple)
 {
 	return (tuple->t_data->t_infomask & HEAP_HASVARWIDTH) != 0;
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleAllFixed(const HeapTupleData *tuple)
 {
 	return !HeapTupleHasVarWidth(tuple);
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleHasExternal(const HeapTupleData *tuple)
 {
 	return (tuple->t_data->t_infomask & HEAP_HASEXTERNAL) != 0;
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleIsHotUpdated(const HeapTupleData *tuple)
 {
 	return HeapTupleHeaderIsHotUpdated(tuple->t_data);
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleSetHotUpdated(const HeapTupleData *tuple)
 {
 	HeapTupleHeaderSetHotUpdated(tuple->t_data);
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleClearHotUpdated(const HeapTupleData *tuple)
 {
 	HeapTupleHeaderClearHotUpdated(tuple->t_data);
 }
 
-static inline bool
+static pg_attribute_always_inline bool
 HeapTupleIsHeapOnly(const HeapTupleData *tuple)
 {
 	return HeapTupleHeaderIsHeapOnly(tuple->t_data);
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleSetHeapOnly(const HeapTupleData *tuple)
 {
 	HeapTupleHeaderSetHeapOnly(tuple->t_data);
 }
 
-static inline void
+static pg_attribute_always_inline void
 HeapTupleClearHeapOnly(const HeapTupleData *tuple)
 {
 	HeapTupleHeaderClearHeapOnly(tuple->t_data);
-- 
2.43.0