Shorten pg_attribute_always_inline to pg_always_inline

The pg_attribute_always_inline macro name is so long it forces pgindent
to format the code in strange ways. Which may incentivize patch authors
to either structure the code in strange ways (e.g. reorder prototypes),
use shorter names, etc. Neither is very desirable for code readability.

This shortens the name by removing the _attribute_ part. It also makes
it more consistent with pg_noinline, which does not have the _attribute_
part either.

Backpatched to all supported branches, to prevent conflicts when
backpatching other fixes. The backbranches however keep both the old and
new macro name, so that existing code keeps working.

Author: Andres Freund <andres@anarazel.de>
Reviewed-by: Peter Geoghegan <pg@bowt.ie>
Reviewed-by: Tomas Vondra <tomas@vondra.me>
Discussion: https://postgr.es/m/bqqdehahpoa36igpictuqyn2s2mexk3t3ehidh2ffd2slb35e5@rzgksuiszgbg
Backpatch-through: 14

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index de31a204c9f2a0aa616c501b52902ec8ea3cec50..9cdc221675b2d6818b2919d9c89a4d21ac3d0540 100644 (file)
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -519,7 +519,7 @@ heap_setscanlimits(TableScanDesc sscan, BlockNumber startBlk, BlockNumber numBlk
  * multiple times, with constant arguments for all_visible,
  * check_serializable.
  */
-pg_attribute_always_inline
+pg_always_inline
 static int
 page_collect_tuples(HeapScanDesc scan, Snapshot snapshot,
                                        Page page, Buffer buffer,

diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c
index a8bbf6284a7fd01a42c7bebb3aad9aaa5ff07788..b431a921e4bb7897392832054ada7c8fc5991639 100644 (file)
--- a/src/backend/access/transam/xlog.c
+++ b/src/backend/access/transam/xlog.c
@@ -1143,9 +1143,9 @@ XLogInsertRecord(XLogRecData *rdata,
  *
  * NB: Testing shows that XLogInsertRecord runs faster if this code is inlined;
  * however, because there are two call sites, the compiler is reluctant to
- * inline. We use pg_attribute_always_inline here to try to convince it.
+ * inline. We use pg_always_inline here to try to convince it.
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos,
                                                  XLogRecPtr *PrevPtr)
 {

diff --git a/src/backend/commands/copyfromparse.c b/src/backend/commands/copyfromparse.c
index 65fd5a0ab4f9dd7ae54423b7e499d278bdacc003..500810577adc964b66c51b3a0f3aa8b649c78cb6 100644 (file)
--- a/src/backend/commands/copyfromparse.c
+++ b/src/backend/commands/copyfromparse.c
@@ -144,22 +144,22 @@ static const char BinarySignature[11] = "PGCOPY\n\377\r\n\0";
 
 /* non-export function prototypes */
 static bool CopyReadLine(CopyFromState cstate, bool is_csv);
-static pg_attribute_always_inline bool CopyReadLineText(CopyFromState cstate,
-                                                                                                               bool is_csv);
+static pg_always_inline bool CopyReadLineText(CopyFromState cstate,
+                                                                                         bool is_csv);
 static int     CopyReadAttributesText(CopyFromState cstate);
 static int     CopyReadAttributesCSV(CopyFromState cstate);
 static Datum CopyReadBinaryAttribute(CopyFromState cstate, FmgrInfo *flinfo,
                                                                         Oid typioparam, int32 typmod,
                                                                         bool *isnull);
-static pg_attribute_always_inline bool CopyFromTextLikeOneRow(CopyFromState cstate,
-                                                                                                                         ExprContext *econtext,
-                                                                                                                         Datum *values,
-                                                                                                                         bool *nulls,
-                                                                                                                         bool is_csv);
-static pg_attribute_always_inline bool NextCopyFromRawFieldsInternal(CopyFromState cstate,
-                                                                                                                                        char ***fields,
-                                                                                                                                        int *nfields,
-                                                                                                                                        bool is_csv);
+static pg_always_inline bool CopyFromTextLikeOneRow(CopyFromState cstate,
+                                                                                                       ExprContext *econtext,
+                                                                                                       Datum *values,
+                                                                                                       bool *nulls,
+                                                                                                       bool is_csv);
+static pg_always_inline bool NextCopyFromRawFieldsInternal(CopyFromState cstate,
+                                                                                                                  char ***fields,
+                                                                                                                  int *nfields,
+                                                                                                                  bool is_csv);
 
 
 /* Low-level communications functions */
@@ -769,11 +769,11 @@ NextCopyFromRawFields(CopyFromState cstate, char ***fields, int *nfields)
  *
  * NOTE: force_not_null option are not applied to the returned fields.
  *
- * We use pg_attribute_always_inline to reduce function call overhead
+ * We use pg_always_inline to reduce function call overhead
  * and to help compilers to optimize away the 'is_csv' condition when called
  * by internal functions such as CopyFromTextLikeOneRow().
  */
-static pg_attribute_always_inline bool
+static pg_always_inline bool
 NextCopyFromRawFieldsInternal(CopyFromState cstate, char ***fields, int *nfields, bool is_csv)
 {
        int                     fldct;
@@ -946,10 +946,10 @@ CopyFromCSVOneRow(CopyFromState cstate, ExprContext *econtext, Datum *values,
 /*
  * Workhorse for CopyFromTextOneRow() and CopyFromCSVOneRow().
  *
- * We use pg_attribute_always_inline to reduce function call overhead
+ * We use pg_always_inline to reduce function call overhead
  * and to help compilers to optimize away the 'is_csv' condition.
  */
-static pg_attribute_always_inline bool
+static pg_always_inline bool
 CopyFromTextLikeOneRow(CopyFromState cstate, ExprContext *econtext,
                                           Datum *values, bool *nulls, bool is_csv)
 {
@@ -1463,7 +1463,7 @@ CopyReadLineTextSIMDHelper(CopyFromState cstate, bool is_csv,
 /*
  * CopyReadLineText - inner loop of CopyReadLine for text mode
  */
-static pg_attribute_always_inline bool
+static pg_always_inline bool
 CopyReadLineText(CopyFromState cstate, bool is_csv)
 {
        char       *copy_input_buf;

diff --git a/src/backend/commands/copyto.c b/src/backend/commands/copyto.c
index d3adc752ae30c4dba2b226a7605c185a73814a59..f9bc617ddb1e0100715cec2463ac7bfee49c21a2 100644 (file)
--- a/src/backend/commands/copyto.c
+++ b/src/backend/commands/copyto.c
@@ -294,10 +294,10 @@ CopyToCSVOneRow(CopyToState cstate, TupleTableSlot *slot)
 /*
  * Workhorse for CopyToTextOneRow() and CopyToCSVOneRow().
  *
- * We use pg_attribute_always_inline to reduce function call overhead
+ * We use pg_always_inline to reduce function call overhead
  * and to help compilers to optimize away the 'is_csv' condition.
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 CopyToTextLikeOneRow(CopyToState cstate,
                                         TupleTableSlot *slot,
                                         bool is_csv)

diff --git a/src/backend/executor/execExprInterp.c b/src/backend/executor/execExprInterp.c
index 0634af964a95beb0d8224cb1f906f2c40ebe8be6..d45812c23aa9afcf5cd8170646d85d9182de6161 100644 (file)
--- a/src/backend/executor/execExprInterp.c
+++ b/src/backend/executor/execExprInterp.c
@@ -178,24 +178,24 @@ static Datum ExecJustHashInnerVarVirt(ExprState *state, ExprContext *econtext, b
 static Datum ExecJustHashOuterVarStrict(ExprState *state, ExprContext *econtext, bool *isnull);
 
 /* execution helper functions */
-static pg_attribute_always_inline void ExecEvalArrayCompareInternal(FunctionCallInfo fcinfo,
-                                                                                                                                       ArrayType *arr,
-                                                                                                                                       int16 typlen,
-                                                                                                                                       bool typbyval,
-                                                                                                                                       char typalign,
-                                                                                                                                       bool useOr,
-                                                                                                                                       Datum *result,
-                                                                                                                                       bool *resultnull);
-static pg_attribute_always_inline void ExecAggPlainTransByVal(AggState *aggstate,
-                                                                                                                         AggStatePerTrans pertrans,
-                                                                                                                         AggStatePerGroup pergroup,
-                                                                                                                         ExprContext *aggcontext,
-                                                                                                                         int setno);
-static pg_attribute_always_inline void ExecAggPlainTransByRef(AggState *aggstate,
-                                                                                                                         AggStatePerTrans pertrans,
-                                                                                                                         AggStatePerGroup pergroup,
-                                                                                                                         ExprContext *aggcontext,
-                                                                                                                         int setno);
+static pg_always_inline void ExecEvalArrayCompareInternal(FunctionCallInfo fcinfo,
+                                                                                                                 ArrayType *arr,
+                                                                                                                 int16 typlen,
+                                                                                                                 bool typbyval,
+                                                                                                                 char typalign,
+                                                                                                                 bool useOr,
+                                                                                                                 Datum *result,
+                                                                                                                 bool *resultnull);
+static pg_always_inline void ExecAggPlainTransByVal(AggState *aggstate,
+                                                                                                       AggStatePerTrans pertrans,
+                                                                                                       AggStatePerGroup pergroup,
+                                                                                                       ExprContext *aggcontext,
+                                                                                                       int setno);
+static pg_always_inline void ExecAggPlainTransByRef(AggState *aggstate,
+                                                                                                       AggStatePerTrans pertrans,
+                                                                                                       AggStatePerGroup pergroup,
+                                                                                                       ExprContext *aggcontext,
+                                                                                                       int setno);
 static char *ExecGetJsonValueItemString(JsonbValue *item, bool *resnull);
 
 /*
@@ -2552,7 +2552,7 @@ get_cached_rowtype(Oid type_id, int32 typmod,
  */
 
 /* implementation of ExecJust(Inner|Outer|Scan)Var */
-static pg_attribute_always_inline Datum
+static pg_always_inline Datum
 ExecJustVarImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
 {
        ExprEvalStep *op = &state->steps[1];
@@ -2590,7 +2590,7 @@ ExecJustScanVar(ExprState *state, ExprContext *econtext, bool *isnull)
 }
 
 /* implementation of ExecJustAssign(Inner|Outer|Scan)Var */
-static pg_attribute_always_inline Datum
+static pg_always_inline Datum
 ExecJustAssignVarImpl(ExprState *state, TupleTableSlot *inslot, bool *isnull)
 {
        ExprEvalStep *op = &state->steps[1];
@@ -2685,7 +2685,7 @@ ExecJustConst(ExprState *state, ExprContext *econtext, bool *isnull)
 }
 
 /* implementation of ExecJust(Inner|Outer|Scan)VarVirt */
-static pg_attribute_always_inline Datum
+static pg_always_inline Datum
 ExecJustVarVirtImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
 {
        ExprEvalStep *op = &state->steps[0];
@@ -2728,7 +2728,7 @@ ExecJustScanVarVirt(ExprState *state, ExprContext *econtext, bool *isnull)
 }
 
 /* implementation of ExecJustAssign(Inner|Outer|Scan)VarVirt */
-static pg_attribute_always_inline Datum
+static pg_always_inline Datum
 ExecJustAssignVarVirtImpl(ExprState *state, TupleTableSlot *inslot, bool *isnull)
 {
        ExprEvalStep *op = &state->steps[0];
@@ -2807,7 +2807,7 @@ ExecJustHashInnerVarWithIV(ExprState *state, ExprContext *econtext,
 }
 
 /* implementation of ExecJustHash(Inner|Outer)Var */
-static pg_attribute_always_inline Datum
+static pg_always_inline Datum
 ExecJustHashVarImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
 {
        ExprEvalStep *fetchop = &state->steps[0];
@@ -2845,7 +2845,7 @@ ExecJustHashInnerVar(ExprState *state, ExprContext *econtext, bool *isnull)
 }
 
 /* implementation of ExecJustHash(Inner|Outer)VarVirt */
-static pg_attribute_always_inline Datum
+static pg_always_inline Datum
 ExecJustHashVarVirtImpl(ExprState *state, TupleTableSlot *slot, bool *isnull)
 {
        ExprEvalStep *var = &state->steps[0];
@@ -4107,7 +4107,7 @@ ExecEvalScalarArrayOp(ExprState *state, ExprEvalStep *op)
  * Callers must handle the strict LHS-is-NULL; return NULL fast path prior to
  * calling this.
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 ExecEvalArrayCompareInternal(FunctionCallInfo fcinfo, ArrayType *arr,
                                                         int16 typlen, bool typbyval, char typalign,
                                                         bool useOr, Datum *result, bool *resultnull)
@@ -5906,7 +5906,7 @@ ExecEvalAggOrderedTransTuple(ExprState *state, ExprEvalStep *op,
 }
 
 /* implementation of transition function invocation for byval types */
-static pg_attribute_always_inline void
+static pg_always_inline void
 ExecAggPlainTransByVal(AggState *aggstate, AggStatePerTrans pertrans,
                                           AggStatePerGroup pergroup,
                                           ExprContext *aggcontext, int setno)
@@ -5938,7 +5938,7 @@ ExecAggPlainTransByVal(AggState *aggstate, AggStatePerTrans pertrans,
 }
 
 /* implementation of transition function invocation for byref types */
-static pg_attribute_always_inline void
+static pg_always_inline void
 ExecAggPlainTransByRef(AggState *aggstate, AggStatePerTrans pertrans,
                                           AggStatePerGroup pergroup,
                                           ExprContext *aggcontext, int setno)

diff --git a/src/backend/executor/execTuples.c b/src/backend/executor/execTuples.c
index 7f4ebf954328436b684df1d682e5b3e11ebb3292..97ae019d10a7ae551d04ea6264d2b4a5c510db25 100644 (file)
--- a/src/backend/executor/execTuples.c
+++ b/src/backend/executor/execTuples.c
@@ -72,8 +72,8 @@
 
 static TupleDesc ExecTypeFromTLInternal(List *targetList,
                                                                                bool skipjunk);
-static pg_attribute_always_inline void slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp,
-                                                                                                                         int reqnatts, bool support_cstring);
+static pg_always_inline void slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp,
+                                                                                                       int reqnatts, bool support_cstring);
 static inline void tts_buffer_heap_store_tuple(TupleTableSlot *slot,
                                                                                           HeapTuple tuple,
                                                                                           Buffer buffer,
@@ -1013,7 +1013,7 @@ tts_buffer_heap_store_tuple(TupleTableSlot *slot, HeapTuple tuple,
  * emit code during inlining for cstring deforming when it's required.
  * cstrings can exist in MinimalTuples, but not in HeapTuples.
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 slot_deform_heap_tuple(TupleTableSlot *slot, HeapTuple tuple, uint32 *offp,
                                           int reqnatts, bool support_cstring)
 {

diff --git a/src/backend/executor/nodeHashjoin.c b/src/backend/executor/nodeHashjoin.c
index 0b365d5b4751e2897017e8630ca065081796d09f..202dd866251d8ece655e9a58210f09a921ff2c63 100644 (file)
--- a/src/backend/executor/nodeHashjoin.c
+++ b/src/backend/executor/nodeHashjoin.c
@@ -221,7 +221,7 @@ static void ExecParallelHashJoinPartitionOuter(HashJoinState *hjstate);
  *                       the other one is "outer".
  * ----------------------------------------------------------------
  */
-static pg_attribute_always_inline TupleTableSlot *
+static pg_always_inline TupleTableSlot *
 ExecHashJoinImpl(PlanState *pstate, bool parallel)
 {
        HashJoinState *node = castNode(HashJoinState, pstate);

diff --git a/src/backend/executor/nodeSeqscan.c b/src/backend/executor/nodeSeqscan.c
index 5bcb0a861d74e339ab5146a9658729daa0063231..b8c528ca089ff0ae6f578006b8ca772142f1de8b 100644 (file)
--- a/src/backend/executor/nodeSeqscan.c
+++ b/src/backend/executor/nodeSeqscan.c
@@ -48,7 +48,7 @@ static TupleTableSlot *SeqNext(SeqScanState *node);
  *             This is a workhorse for ExecSeqScan
  * ----------------------------------------------------------------
  */
-static pg_attribute_always_inline TupleTableSlot *
+static pg_always_inline TupleTableSlot *
 SeqNext(SeqScanState *node)
 {
        TableScanDesc scandesc;
@@ -95,7 +95,7 @@ SeqNext(SeqScanState *node)
 /*
  * SeqRecheck -- access method routine to recheck a tuple in EvalPlanQual
  */
-static pg_attribute_always_inline bool
+static pg_always_inline bool
 SeqRecheck(SeqScanState *node, TupleTableSlot *slot)
 {
        /*

diff --git a/src/backend/nodes/queryjumblefuncs.c b/src/backend/nodes/queryjumblefuncs.c
index 7c63766a51c5d0760f05f303b2e602ef78436600..2ce27b9e552a113f229314576cabaee984d31f9c 100644 (file)
--- a/src/backend/nodes/queryjumblefuncs.c
+++ b/src/backend/nodes/queryjumblefuncs.c
@@ -232,7 +232,7 @@ DoJumble(JumbleState *jstate, Node *node)
  *
  * Note: Callers must ensure that size > 0.
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 AppendJumbleInternal(JumbleState *jstate, const unsigned char *item,
                                         Size size)
 {
@@ -308,7 +308,7 @@ AppendJumble(JumbleState *jstate, const unsigned char *value, Size size)
  * AppendJumbleNull
  *             For jumbling NULL pointers
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 AppendJumbleNull(JumbleState *jstate)
 {
        jstate->pending_nulls++;
@@ -375,7 +375,7 @@ AppendJumble64(JumbleState *jstate, const unsigned char *value)
  *
  * Note: Callers must ensure that there's at least 1 pending NULL.
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 FlushPendingNulls(JumbleState *jstate)
 {
        Assert(jstate->pending_nulls > 0);

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 9ab282a76d1af210dec9491781838b978de23553..3908529872a319d00a315decc72a5c3b1dd34b88 100644 (file)
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -649,10 +649,10 @@ static inline BufferDesc *BufferAlloc(SMgrRelation smgr,
 static bool AsyncReadBuffers(ReadBuffersOperation *operation, int *nblocks_progress);
 static void CheckReadBuffersOperation(ReadBuffersOperation *operation, bool is_complete);
 
-static pg_attribute_always_inline void TrackBufferHit(IOObject io_object,
-                                                                                                         IOContext io_context,
-                                                                                                         Relation rel, char persistence, SMgrRelation smgr,
-                                                                                                         ForkNumber forknum, BlockNumber blocknum);
+static pg_always_inline void TrackBufferHit(IOObject io_object,
+                                                                                       IOContext io_context,
+                                                                                       Relation rel, char persistence, SMgrRelation smgr,
+                                                                                       ForkNumber forknum, BlockNumber blocknum);
 static Buffer GetVictimBuffer(BufferAccessStrategy strategy, IOContext io_context);
 static void FlushUnlockedBuffer(BufferDesc *buf, SMgrRelation reln,
                                                                IOObject io_object, IOContext io_context);
@@ -1219,7 +1219,7 @@ ZeroAndLockBuffer(Buffer buffer, ReadBufferMode mode, bool already_valid)
  * already present, or false if more work is required to either read it in or
  * zero it.
  */
-static pg_attribute_always_inline Buffer
+static pg_always_inline Buffer
 PinBufferForBlock(Relation rel,
                                  SMgrRelation smgr,
                                  char persistence,
@@ -1272,7 +1272,7 @@ PinBufferForBlock(Relation rel,
  *
  * smgr is required, rel is optional unless using P_NEW.
  */
-static pg_attribute_always_inline Buffer
+static pg_always_inline Buffer
 ReadBuffer_common(Relation rel, SMgrRelation smgr, char smgr_persistence,
                                  ForkNumber forkNum,
                                  BlockNumber blockNum, ReadBufferMode mode,
@@ -1367,7 +1367,7 @@ ReadBuffer_common(Relation rel, SMgrRelation smgr, char smgr_persistence,
        return buffer;
 }
 
-static pg_attribute_always_inline bool
+static pg_always_inline bool
 StartReadBuffersImpl(ReadBuffersOperation *operation,
                                         Buffer *buffers,
                                         BlockNumber blockNum,
@@ -1679,7 +1679,7 @@ CheckReadBuffersOperation(ReadBuffersOperation *operation, bool is_complete)
  * We track various stats related to buffer hits. Because this is done in a
  * few separate places, this helper exists for convenience.
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 TrackBufferHit(IOObject io_object, IOContext io_context,
                           Relation rel, char persistence, SMgrRelation smgr,
                           ForkNumber forknum, BlockNumber blocknum)
@@ -2193,7 +2193,7 @@ AsyncReadBuffers(ReadBuffersOperation *operation, int *nblocks_progress)
  *
  * No locks are held either at entry or exit.
  */
-static pg_attribute_always_inline BufferDesc *
+static pg_always_inline BufferDesc *
 BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
                        BlockNumber blockNum,
                        BufferAccessStrategy strategy,
@@ -8326,7 +8326,7 @@ MarkDirtyAllUnpinnedBuffers(int32 *buffers_dirtied,
  * part of error handling, which in turn could lead to the buffer being
  * replaced while IO is ongoing.
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 buffer_stage_common(PgAioHandle *ioh, bool is_write, bool is_temp)
 {
        uint64     *io_data;
@@ -8570,7 +8570,7 @@ buffer_readv_encode_error(PgAioResult *result,
  * Helper for AIO readv completion callbacks, supporting both shared and temp
  * buffers. Gets called once for each buffer in a multi-page read.
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 buffer_readv_complete_one(PgAioTargetData *td, uint8 buf_off, Buffer buffer,
                                                  uint8 flags, bool failed, bool is_temp,
                                                  bool *buffer_invalid,
@@ -8721,7 +8721,7 @@ buffer_readv_complete_one(PgAioTargetData *td, uint8 buf_off, Buffer buffer,
  *
  * Shared between shared and local buffers, to reduce code duplication.
  */
-static pg_attribute_always_inline PgAioResult
+static pg_always_inline PgAioResult
 buffer_readv_complete(PgAioHandle *ioh, PgAioResult prior_result,
                                          uint8 cb_data, bool is_temp)
 {

diff --git a/src/backend/utils/adt/json.c b/src/backend/utils/adt/json.c
index ba3cc2309528c317e29a8f0ecaae3ac5196d9c84..28e5f3cf9c051be4dee2c22e3009b421d68fef25 100644 (file)
--- a/src/backend/utils/adt/json.c
+++ b/src/backend/utils/adt/json.c
@@ -1528,7 +1528,7 @@ json_object_two_arg(PG_FUNCTION_ARGS)
  * escape_json_char
  *             Inline helper function for escape_json* functions
  */
-static pg_attribute_always_inline void
+static pg_always_inline void
 escape_json_char(StringInfo buf, char c)
 {
        switch (c)

diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index 6fb35dedf95e9a0a5d354526ea9252ca54f2a506..0c8955fc61af7f0f338cd74386ab10bb19a28f73 100644 (file)
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -1091,7 +1091,7 @@ RehashCatCacheLists(CatCache *cp)
  *
  * Call CatalogCacheInitializeCache() if not yet done.
  */
-pg_attribute_always_inline
+pg_always_inline
 static void
 ConditionalCatalogCacheInitializeCache(CatCache *cache)
 {

diff --git a/src/include/c.h b/src/include/c.h
index 0e4aea5d5a395d19e041938cbec3a452d9ca6f27..0e8053d1fe3d2fa6a39c3bca0e80d83c61dbab59 100644 (file)
--- a/src/include/c.h
+++ b/src/include/c.h
@@ -348,20 +348,20 @@ extern "C++"
 #endif
 
 /*
- * Use "pg_attribute_always_inline" in place of "inline" for functions that
+ * Use "pg_always_inline" in place of "inline" for functions that
  * we wish to force inlining of, even when the compiler's heuristics would
  * choose not to.  But, if possible, don't force inlining in unoptimized
  * debug builds.
  */
 #if defined(__GNUC__) && defined(__OPTIMIZE__)
 /* GCC supports always_inline via __attribute__ */
-#define pg_attribute_always_inline __attribute__((always_inline)) inline
+#define pg_always_inline __attribute__((always_inline)) inline
 #elif defined(_MSC_VER)
 /* MSVC has a special keyword for this */
-#define pg_attribute_always_inline __forceinline
+#define pg_always_inline __forceinline
 #else
 /* Otherwise, the best we can do is to say "inline" */
-#define pg_attribute_always_inline inline
+#define pg_always_inline inline
 #endif
 
 /*

diff --git a/src/include/executor/execScan.h b/src/include/executor/execScan.h
index 18b03235c3c4a2b4a62e0149485beb8c375bf2bc..25efc622f88aa5ec37849275ca4a9f5ba1059689 100644 (file)
--- a/src/include/executor/execScan.h
+++ b/src/include/executor/execScan.h
@@ -24,12 +24,12 @@
  * This routine substitutes a test tuple if inside an EvalPlanQual recheck.
  * Otherwise, it simply executes the access method's next-tuple routine.
  *
- * The pg_attribute_always_inline attribute allows the compiler to inline
- * this function into its caller. When EPQState is NULL, the EvalPlanQual
- * logic is completely eliminated at compile time, avoiding unnecessary
- * run-time checks and code for cases where EPQ is not required.
+ * The pg_always_inline attribute allows the compiler to inline this function
+ * into its caller. When EPQState is NULL, the EvalPlanQual logic is completely
+ * eliminated at compile time, avoiding unnecessary run-time checks and code
+ * for cases where EPQ is not required.
  */
-static pg_attribute_always_inline TupleTableSlot *
+static pg_always_inline TupleTableSlot *
 ExecScanFetch(ScanState *node,
                          EPQState *epqstate,
                          ExecScanAccessMtd accessMtd,
@@ -145,9 +145,9 @@ ExecScanFetch(ScanState *node,
  * conditions enforced by the access method.
  *
  * This function is an alternative to ExecScan, used when callers may omit
- * 'qual' or 'projInfo'. The pg_attribute_always_inline attribute allows the
- * compiler to eliminate non-relevant branches at compile time, avoiding
- * run-time checks in those cases.
+ * 'qual' or 'projInfo'. The pg_always_inline attribute allows the compiler
+ * to eliminate non-relevant branches at compile time, avoiding run-time
+ * checks in those cases.
  *
  * Conditions:
  *     -- The AMI "cursor" is positioned at the previously returned tuple.
@@ -157,7 +157,7 @@ ExecScanFetch(ScanState *node,
  *     positioned before the first qualifying tuple.
  * ----------------------------------------------------------------
  */
-static pg_attribute_always_inline TupleTableSlot *
+static pg_always_inline TupleTableSlot *
 ExecScanExtended(ScanState *node,
                                 ExecScanAccessMtd accessMtd,   /* function returning a tuple */
                                 ExecScanRecheckMtd recheckMtd,

diff --git a/src/include/portability/instr_time.h b/src/include/portability/instr_time.h
index 826cc202847fc9c9d4f4196e42603b67158b6855..2b74ce91ecb85a0bcd2a5f630ecbd95e254f19de 100644 (file)
--- a/src/include/portability/instr_time.h
+++ b/src/include/portability/instr_time.h
@@ -376,7 +376,7 @@ pg_rdtscp(void)
  * only inlining the function partially.
  * See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=124795
  */
-static pg_attribute_always_inline instr_time
+static pg_always_inline instr_time
 pg_get_ticks(void)
 {
        if (likely(timing_tsc_enabled))
@@ -390,7 +390,7 @@ pg_get_ticks(void)
        return pg_get_ticks_system();
 }
 
-static pg_attribute_always_inline instr_time
+static pg_always_inline instr_time
 pg_get_ticks_fast(void)
 {
        if (likely(timing_tsc_enabled))
@@ -406,13 +406,13 @@ pg_get_ticks_fast(void)
 
 #else
 
-static pg_attribute_always_inline instr_time
+static pg_always_inline instr_time
 pg_get_ticks(void)
 {
        return pg_get_ticks_system();
 }
 
-static pg_attribute_always_inline instr_time
+static pg_always_inline instr_time
 pg_get_ticks_fast(void)
 {
        return pg_get_ticks_system();