Rely on inline functions even if that causes warnings in older compilers.

So far we have worked around the fact that some very old compilers do
not support 'inline' functions by only using inline functions
conditionally (or not at all). Since such compilers are very rare by
now, we have decided to rely on inline functions from 9.6 onwards.

To avoid breaking these old compilers inline is defined away when not
supported. That'll cause "function x defined but not used" type of
warnings, but since nobody develops on such compilers anymore that's
ok.

This change in policy will allow us to more easily employ inline
functions.

I chose to remove code previously conditional on PG_USE_INLINE as it
seemed confusing to have code dependent on a define that's always
defined.

Blacklisting of compilers, like in c53f73879f, now has to be done
differently. A platform template can define PG_FORCE_DISABLE_INLINE to
force inline to be defined empty.

Discussion: 20150701161447.GB30708@awork2.anarazel.de

config/c-compiler.m4

@@ -17,40 +17,6 @@ fi])# PGAC_C_SIGNED
 
 
 
-# PGAC_C_INLINE
-# -------------
-# Check if the C compiler understands inline functions without being
-# noisy about unused static inline functions. Some older compilers
-# understand inline functions (as tested by AC_C_INLINE) but warn about
-# them if they aren't used in a translation unit.
-#
-# This test used to just define an inline function, but some compilers
-# (notably clang) got too smart and now warn about unused static
-# inline functions when defined inside a .c file, but not when defined
-# in an included header. Since the latter is what we want to use, test
-# to see if the warning appears when the function is in a header file.
-# Not pretty, but it works.
-#
-# Defines: inline, PG_USE_INLINE
-AC_DEFUN([PGAC_C_INLINE],
-[AC_C_INLINE
-AC_CACHE_CHECK([for quiet inline (no complaint if unreferenced)], pgac_cv_c_inline_quietly,
-  [pgac_cv_c_inline_quietly=no
-  if test "$ac_cv_c_inline" != no; then
-    pgac_c_inline_save_werror=$ac_c_werror_flag
-    ac_c_werror_flag=yes
-    AC_LINK_IFELSE([AC_LANG_PROGRAM([#include "$srcdir/config/test_quiet_include.h"],[])],
-                   [pgac_cv_c_inline_quietly=yes])
-    ac_c_werror_flag=$pgac_c_inline_save_werror
-  fi])
-if test "$pgac_cv_c_inline_quietly" != no; then
-  AC_DEFINE_UNQUOTED([PG_USE_INLINE], 1,
-    [Define to 1 if "static inline" works without unwanted warnings from ]
-    [compilations where static inline functions are defined but not called.])
-fi
-])# PGAC_C_INLINE
-
-
 # PGAC_C_PRINTF_ARCHETYPE
 # -----------------------
 # Set the format archetype used by gcc to check printf type functions.  We

config/test_quiet_include.h

@@ -1,18 +0,0 @@
-/*
- * For the raison d'etre of this file, check the comment above the definition
- * of the PGAC_C_INLINE macro in config/c-compiler.m4.
- */
-static inline int
-fun()
-{
-	return 0;
-}
-
-/*
- * "IBM XL C/C++ for AIX, V12.1" miscompiles, for 32-bit, some inline
- * expansions of ginCompareItemPointers() "long long" arithmetic.  To take
- * advantage of inlining, build a 64-bit PostgreSQL.
- */
-#if defined(__ILP32__) && defined(__IBMC__)
-#error "known inlining bug"
-#endif

configure

@@ -11006,44 +11006,6 @@ _ACEOF
     ;;
 esac
 
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for quiet inline (no complaint if unreferenced)" >&5
-$as_echo_n "checking for quiet inline (no complaint if unreferenced)... " >&6; }
-if ${pgac_cv_c_inline_quietly+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  pgac_cv_c_inline_quietly=no
-  if test "$ac_cv_c_inline" != no; then
-    pgac_c_inline_save_werror=$ac_c_werror_flag
-    ac_c_werror_flag=yes
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include "$srcdir/config/test_quiet_include.h"
-int
-main ()
-{
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
-  pgac_cv_c_inline_quietly=yes
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-    ac_c_werror_flag=$pgac_c_inline_save_werror
-  fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $pgac_cv_c_inline_quietly" >&5
-$as_echo "$pgac_cv_c_inline_quietly" >&6; }
-if test "$pgac_cv_c_inline_quietly" != no; then
-
-cat >>confdefs.h <<_ACEOF
-#define PG_USE_INLINE 1
-_ACEOF
-
-fi
-
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for printf format archetype" >&5
 $as_echo_n "checking for printf format archetype... " >&6; }
 if ${pgac_cv_printf_archetype+:} false; then :

configure.in

@@ -1309,7 +1309,7 @@ fi
 
 m4_defun([AC_PROG_CC_STDC], []) dnl We don't want that.
 AC_C_BIGENDIAN
-PGAC_C_INLINE
+AC_C_INLINE
 PGAC_PRINTF_ARCHETYPE
 AC_C_FLEXIBLE_ARRAY_MEMBER
 PGAC_C_SIGNED

src/backend/lib/ilist.c

@@ -18,9 +18,6 @@
  */
 #include "postgres.h"
 
-/* See ilist.h */
-#define ILIST_INCLUDE_DEFINITIONS
-
 #include "lib/ilist.h"
 
 /*

src/backend/nodes/list.c

@@ -15,9 +15,6 @@
  */
 #include "postgres.h"
 
-/* see pg_list.h */
-#define PG_LIST_INCLUDE_DEFINITIONS
-
 #include "nodes/pg_list.h"
 
 

src/backend/port/atomics.c

@@ -13,13 +13,6 @@
  */
 #include "postgres.h"
 
-/*
- * We want the functions below to be inline; but if the compiler doesn't
- * support that, fall back on providing them as regular functions.  See
- * STATIC_IF_INLINE in c.h.
- */
-#define ATOMICS_INCLUDE_DEFINITIONS
-
 #include "miscadmin.h"
 #include "port/atomics.h"
 #include "storage/spin.h"

src/backend/utils/adt/arrayfuncs.c

@@ -20,9 +20,6 @@
 #endif
 #include <math.h>
 
-/* See arrayaccess.h */
-#define ARRAYACCESS_INCLUDE_DEFINITIONS
-
 #include "access/htup_details.h"
 #include "catalog/pg_type.h"
 #include "funcapi.h"

src/backend/utils/mmgr/mcxt.c

@@ -19,9 +19,6 @@
  *-------------------------------------------------------------------------
  */
 
-/* see palloc.h.  Must be before postgres.h */
-#define MCXT_INCLUDE_DEFINITIONS
-
 #include "postgres.h"
 
 #include "miscadmin.h"

src/backend/utils/sort/sortsupport.c

@@ -15,9 +15,6 @@
 
 #include "postgres.h"
 
-/* See sortsupport.h */
-#define SORTSUPPORT_INCLUDE_DEFINITIONS
-
 #include "access/nbtree.h"
 #include "fmgr.h"
 #include "utils/lsyscache.h"

src/include/access/gin_private.h

@@ -952,11 +952,8 @@ extern ItemPointer ginMergeItemPointers(ItemPointerData *a, uint32 na,
 
 /*
  * Merging the results of several gin scans compares item pointers a lot,
- * so we want this to be inlined. But if the compiler doesn't support that,
+ * so we want this to be inlined.
- * fall back on the non-inline version from itemptr.c. See STATIC_IF_INLINE in
- * c.h.
  */
-#ifdef PG_USE_INLINE
 static inline int
 ginCompareItemPointers(ItemPointer a, ItemPointer b)
 {
@@ -970,8 +967,5 @@ ginCompareItemPointers(ItemPointer a, ItemPointer b)
 	else
 		return -1;
 }
-#else
-#define ginCompareItemPointers(a, b) ItemPointerCompare(a, b)
-#endif   /* PG_USE_INLINE */
 
 #endif   /* GIN_PRIVATE_H */

src/include/c.h

@@ -53,6 +53,20 @@
 #include "pg_config.h"
 #include "pg_config_manual.h"	/* must be after pg_config.h */
 
+/*
+ * Force disable inlining if PG_FORCE_DISABLE_INLINE is defined. This is used
+ * to work around compiler bugs and might also be useful for investigatory
+ * purposes.
+ *
+ * This is done early (in slightly the wrong section) for two reasons: a) we
+ * don't want to include headers with different settings of this b)
+ * functionality later in this file might want to rely on inline functions.
+ */
+#ifdef PG_FORCE_DISABLE_INLINE
+#undef inline
+#define inline
+#endif
+
 /*
  * We always rely on the WIN32 macro being set by our build system,
  * but _WIN32 is the compiler pre-defined macro. So make sure we define
@@ -920,34 +934,6 @@ typedef NameData *Name;
 #endif
 
 
-/*
- * Function inlining support -- Allow modules to define functions that may be
- * inlined, if the compiler supports it.
- *
- * The function bodies must be defined in the module header prefixed by
- * STATIC_IF_INLINE, protected by a cpp symbol that the module's .c file must
- * define.  If the compiler doesn't support inline functions, the function
- * definitions are pulled in by the .c file as regular (not inline) symbols.
- *
- * The header must also declare the functions' prototypes, protected by
- * !PG_USE_INLINE.
- */
-
-/* declarations which are only visible when not inlining and in the .c file */
-#ifdef PG_USE_INLINE
-#define STATIC_IF_INLINE static inline
-#else
-#define STATIC_IF_INLINE
-#endif   /* PG_USE_INLINE */
-
-/* declarations which are marked inline when inlining, extern otherwise */
-#ifdef PG_USE_INLINE
-#define STATIC_IF_INLINE_DECLARE static inline
-#else
-#define STATIC_IF_INLINE_DECLARE extern
-#endif   /* PG_USE_INLINE */
-
-
 /* ----------------------------------------------------------------
  *				Section 8:	random stuff
  * ----------------------------------------------------------------

src/include/lib/ilist.h

@@ -268,40 +268,13 @@ extern void slist_check(slist_head *head);
 #define slist_check(head)	((void) (head))
 #endif   /* ILIST_DEBUG */
 
+/* doubly linked list implementation */
 
-/*
- * We want the functions below to be inline; but if the compiler doesn't
- * support that, fall back on providing them as regular functions.  See
- * STATIC_IF_INLINE in c.h.
- */
-#ifndef PG_USE_INLINE
-extern void dlist_init(dlist_head *head);
-extern bool dlist_is_empty(dlist_head *head);
-extern void dlist_push_head(dlist_head *head, dlist_node *node);
-extern void dlist_push_tail(dlist_head *head, dlist_node *node);
-extern void dlist_insert_after(dlist_node *after, dlist_node *node);
-extern void dlist_insert_before(dlist_node *before, dlist_node *node);
-extern void dlist_delete(dlist_node *node);
-extern dlist_node *dlist_pop_head_node(dlist_head *head);
-extern void dlist_move_head(dlist_head *head, dlist_node *node);
-extern bool dlist_has_next(dlist_head *head, dlist_node *node);
-extern bool dlist_has_prev(dlist_head *head, dlist_node *node);
-extern dlist_node *dlist_next_node(dlist_head *head, dlist_node *node);
-extern dlist_node *dlist_prev_node(dlist_head *head, dlist_node *node);
-extern dlist_node *dlist_head_node(dlist_head *head);
-extern dlist_node *dlist_tail_node(dlist_head *head);
-
-/* dlist macro support functions */
-extern void *dlist_tail_element_off(dlist_head *head, size_t off);
-extern void *dlist_head_element_off(dlist_head *head, size_t off);
-#endif   /* !PG_USE_INLINE */
-
-#if defined(PG_USE_INLINE) || defined(ILIST_INCLUDE_DEFINITIONS)
 /*
  * Initialize a doubly linked list.
  * Previous state will be thrown away without any cleanup.
  */
-STATIC_IF_INLINE void
+static inline void
 dlist_init(dlist_head *head)
 {
 	head->head.next = head->head.prev = &head->head;
@@ -312,7 +285,7 @@ dlist_init(dlist_head *head)
  *
  * An empty list has either its first 'next' pointer set to NULL, or to itself.
  */
-STATIC_IF_INLINE bool
+static inline bool
 dlist_is_empty(dlist_head *head)
 {
 	dlist_check(head);
@@ -323,7 +296,7 @@ dlist_is_empty(dlist_head *head)
 /*
  * Insert a node at the beginning of the list.
  */
-STATIC_IF_INLINE void
+static inline void
 dlist_push_head(dlist_head *head, dlist_node *node)
 {
 	if (head->head.next == NULL)	/* convert NULL header to circular */
@@ -340,7 +313,7 @@ dlist_push_head(dlist_head *head, dlist_node *node)
 /*
  * Insert a node at the end of the list.
  */
-STATIC_IF_INLINE void
+static inline void
 dlist_push_tail(dlist_head *head, dlist_node *node)
 {
 	if (head->head.next == NULL)	/* convert NULL header to circular */
@@ -357,7 +330,7 @@ dlist_push_tail(dlist_head *head, dlist_node *node)
 /*
  * Insert a node after another *in the same list*
  */
-STATIC_IF_INLINE void
+static inline void
 dlist_insert_after(dlist_node *after, dlist_node *node)
 {
 	node->prev = after;
@@ -369,7 +342,7 @@ dlist_insert_after(dlist_node *after, dlist_node *node)
 /*
  * Insert a node before another *in the same list*
  */
-STATIC_IF_INLINE void
+static inline void
 dlist_insert_before(dlist_node *before, dlist_node *node)
 {
 	node->prev = before->prev;
@@ -381,7 +354,7 @@ dlist_insert_before(dlist_node *before, dlist_node *node)
 /*
  * Delete 'node' from its list (it must be in one).
  */
-STATIC_IF_INLINE void
+static inline void
 dlist_delete(dlist_node *node)
 {
 	node->prev->next = node->next;
@@ -391,7 +364,7 @@ dlist_delete(dlist_node *node)
 /*
  * Remove and return the first node from a list (there must be one).
  */
-STATIC_IF_INLINE dlist_node *
+static inline dlist_node *
 dlist_pop_head_node(dlist_head *head)
 {
 	dlist_node *node;
@@ -408,7 +381,7 @@ dlist_pop_head_node(dlist_head *head)
  *
  * Undefined behaviour if 'node' is not already part of the list.
  */
-STATIC_IF_INLINE void
+static inline void
 dlist_move_head(dlist_head *head, dlist_node *node)
 {
 	/* fast path if it's already at the head */
@@ -425,7 +398,7 @@ dlist_move_head(dlist_head *head, dlist_node *node)
  * Check whether 'node' has a following node.
  * Caution: unreliable if 'node' is not in the list.
  */
-STATIC_IF_INLINE bool
+static inline bool
 dlist_has_next(dlist_head *head, dlist_node *node)
 {
 	return node->next != &head->head;
@@ -435,7 +408,7 @@ dlist_has_next(dlist_head *head, dlist_node *node)
  * Check whether 'node' has a preceding node.
  * Caution: unreliable if 'node' is not in the list.
  */
-STATIC_IF_INLINE bool
+static inline bool
 dlist_has_prev(dlist_head *head, dlist_node *node)
 {
 	return node->prev != &head->head;
@@ -444,7 +417,7 @@ dlist_has_prev(dlist_head *head, dlist_node *node)
 /*
  * Return the next node in the list (there must be one).
  */
-STATIC_IF_INLINE dlist_node *
+static inline dlist_node *
 dlist_next_node(dlist_head *head, dlist_node *node)
 {
 	Assert(dlist_has_next(head, node));
@@ -454,7 +427,7 @@ dlist_next_node(dlist_head *head, dlist_node *node)
 /*
  * Return previous node in the list (there must be one).
  */
-STATIC_IF_INLINE dlist_node *
+static inline dlist_node *
 dlist_prev_node(dlist_head *head, dlist_node *node)
 {
 	Assert(dlist_has_prev(head, node));
@@ -462,7 +435,7 @@ dlist_prev_node(dlist_head *head, dlist_node *node)
 }
 
 /* internal support function to get address of head element's struct */
-STATIC_IF_INLINE void *
+static inline void *
 dlist_head_element_off(dlist_head *head, size_t off)
 {
 	Assert(!dlist_is_empty(head));
@@ -472,14 +445,14 @@ dlist_head_element_off(dlist_head *head, size_t off)
 /*
  * Return the first node in the list (there must be one).
  */
-STATIC_IF_INLINE dlist_node *
+static inline dlist_node *
 dlist_head_node(dlist_head *head)
 {
 	return (dlist_node *) dlist_head_element_off(head, 0);
 }
 
 /* internal support function to get address of tail element's struct */
-STATIC_IF_INLINE void *
+static inline void *
 dlist_tail_element_off(dlist_head *head, size_t off)
 {
 	Assert(!dlist_is_empty(head));
@@ -489,12 +462,11 @@ dlist_tail_element_off(dlist_head *head, size_t off)
 /*
  * Return the last node in the list (there must be one).
  */
-STATIC_IF_INLINE dlist_node *
+static inline dlist_node *
 dlist_tail_node(dlist_head *head)
 {
 	return (dlist_node *) dlist_tail_element_off(head, 0);
 }
-#endif   /* PG_USE_INLINE || ILIST_INCLUDE_DEFINITIONS */
 
 /*
  * Return the containing struct of 'type' where 'membername' is the dlist_node
@@ -572,32 +544,13 @@ dlist_tail_node(dlist_head *head)
 		 (iter).cur = (iter).cur->prev)
 
 
-/*
+/* singly linked list implementation */
- * We want the functions below to be inline; but if the compiler doesn't
- * support that, fall back on providing them as regular functions.  See
- * STATIC_IF_INLINE in c.h.
- */
-#ifndef PG_USE_INLINE
-extern void slist_init(slist_head *head);
-extern bool slist_is_empty(slist_head *head);
-extern void slist_push_head(slist_head *head, slist_node *node);
-extern void slist_insert_after(slist_node *after, slist_node *node);
-extern slist_node *slist_pop_head_node(slist_head *head);
-extern bool slist_has_next(slist_head *head, slist_node *node);
-extern slist_node *slist_next_node(slist_head *head, slist_node *node);
-extern slist_node *slist_head_node(slist_head *head);
-extern void slist_delete_current(slist_mutable_iter *iter);
-
-/* slist macro support function */
-extern void *slist_head_element_off(slist_head *head, size_t off);
-#endif
 
-#if defined(PG_USE_INLINE) || defined(ILIST_INCLUDE_DEFINITIONS)
 /*
  * Initialize a singly linked list.
  * Previous state will be thrown away without any cleanup.
  */
-STATIC_IF_INLINE void
+static inline void
 slist_init(slist_head *head)
 {
 	head->head.next = NULL;
@@ -606,7 +559,7 @@ slist_init(slist_head *head)
 /*
  * Is the list empty?
  */
-STATIC_IF_INLINE bool
+static inline bool
 slist_is_empty(slist_head *head)
 {
 	slist_check(head);
@@ -617,7 +570,7 @@ slist_is_empty(slist_head *head)
 /*
  * Insert a node at the beginning of the list.
  */
-STATIC_IF_INLINE void
+static inline void
 slist_push_head(slist_head *head, slist_node *node)
 {
 	node->next = head->head.next;
@@ -629,7 +582,7 @@ slist_push_head(slist_head *head, slist_node *node)
 /*
  * Insert a node after another *in the same list*
  */
-STATIC_IF_INLINE void
+static inline void
 slist_insert_after(slist_node *after, slist_node *node)
 {
 	node->next = after->next;
@@ -639,7 +592,7 @@ slist_insert_after(slist_node *after, slist_node *node)
 /*
  * Remove and return the first node from a list (there must be one).
  */
-STATIC_IF_INLINE slist_node *
+static inline slist_node *
 slist_pop_head_node(slist_head *head)
 {
 	slist_node *node;
@@ -654,7 +607,7 @@ slist_pop_head_node(slist_head *head)
 /*
  * Check whether 'node' has a following node.
  */
-STATIC_IF_INLINE bool
+static inline bool
 slist_has_next(slist_head *head, slist_node *node)
 {
 	slist_check(head);
@@ -665,7 +618,7 @@ slist_has_next(slist_head *head, slist_node *node)
 /*
  * Return the next node in the list (there must be one).
  */
-STATIC_IF_INLINE slist_node *
+static inline slist_node *
 slist_next_node(slist_head *head, slist_node *node)
 {
 	Assert(slist_has_next(head, node));
@@ -673,7 +626,7 @@ slist_next_node(slist_head *head, slist_node *node)
 }
 
 /* internal support function to get address of head element's struct */
-STATIC_IF_INLINE void *
+static inline void *
 slist_head_element_off(slist_head *head, size_t off)
 {
 	Assert(!slist_is_empty(head));
@@ -683,7 +636,7 @@ slist_head_element_off(slist_head *head, size_t off)
 /*
  * Return the first node in the list (there must be one).
  */
-STATIC_IF_INLINE slist_node *
+static inline slist_node *
 slist_head_node(slist_head *head)
 {
 	return (slist_node *) slist_head_element_off(head, 0);
@@ -695,7 +648,7 @@ slist_head_node(slist_head *head)
  * Caution: this modifies iter->cur, so don't use that again in the current
  * loop iteration.
  */
-STATIC_IF_INLINE void
+static inline void
 slist_delete_current(slist_mutable_iter *iter)
 {
 	/*
@@ -711,7 +664,6 @@ slist_delete_current(slist_mutable_iter *iter)
 	 */
 	iter->cur = iter->prev;
 }
-#endif   /* PG_USE_INLINE || ILIST_INCLUDE_DEFINITIONS */
 
 /*
  * Return the containing struct of 'type' where 'membername' is the slist_node

src/include/nodes/pg_list.h

@@ -71,34 +71,25 @@ struct ListCell
 /*
  * These routines are used frequently. However, we can't implement
  * them as macros, since we want to avoid double-evaluation of macro
- * arguments. Therefore, we implement them using static inline functions
+ * arguments.
- * if supported by the compiler, or as regular functions otherwise.
- * See STATIC_IF_INLINE in c.h.
  */
-#ifndef PG_USE_INLINE
+static inline ListCell *
-extern ListCell *list_head(const List *l);
-extern ListCell *list_tail(List *l);
-extern int	list_length(const List *l);
-#endif   /* PG_USE_INLINE */
-#if defined(PG_USE_INLINE) || defined(PG_LIST_INCLUDE_DEFINITIONS)
-STATIC_IF_INLINE ListCell *
 list_head(const List *l)
 {
 	return l ? l->head : NULL;
 }
 
-STATIC_IF_INLINE ListCell *
+static inline ListCell *
 list_tail(List *l)
 {
 	return l ? l->tail : NULL;
 }
 
-STATIC_IF_INLINE int
+static inline int
 list_length(const List *l)
 {
 	return l ? l->length : 0;
 }
-#endif   /*-- PG_USE_INLINE || PG_LIST_INCLUDE_DEFINITIONS */
 
 /*
  * NB: There is an unfortunate legacy from a previous incarnation of

src/include/pg_config.h.in

@@ -733,10 +733,6 @@
 /* Define to gnu_printf if compiler supports it, else printf. */
 #undef PG_PRINTF_ATTRIBUTE
 
-/* Define to 1 if "static inline" works without unwanted warnings from
-   compilations where static inline functions are defined but not called. */
-#undef PG_USE_INLINE
-
 /* PostgreSQL version as a string */
 #undef PG_VERSION
 

src/include/pg_config.h.win32

@@ -6,7 +6,7 @@
  *
  * HAVE_CBRT, HAVE_FUNCNAME_FUNC, HAVE_GETOPT, HAVE_GETOPT_H, HAVE_INTTYPES_H,
  * HAVE_GETOPT_LONG, HAVE_LOCALE_T, HAVE_RINT, HAVE_STRINGS_H, HAVE_STRTOLL,
- * HAVE_STRTOULL, HAVE_STRUCT_OPTION, ENABLE_THREAD_SAFETY, PG_USE_INLINE,
+ * HAVE_STRTOULL, HAVE_STRUCT_OPTION, ENABLE_THREAD_SAFETY,
  * inline, USE_SSE42_CRC32C_WITH_RUNTIME_CHECK
  */
 
@@ -622,10 +622,6 @@
 /* Define to 1 to build with Bonjour support. (--with-bonjour) */
 /* #undef USE_BONJOUR */
 
-/* Define to 1 if "static inline" works without unwanted warnings from
-   compilations where static inline functions are defined but not called. */
-#define PG_USE_INLINE 1
-
 /* Define to 1 if you want 64-bit integer timestamp and interval support.
    (--enable-integer-datetimes) */
 /* #undef USE_INTEGER_DATETIMES */

src/include/port/atomics.h

@@ -118,46 +118,6 @@
  */
 #include "port/atomics/generic.h"
 
-/*
- * Provide declarations for all functions here - on most platforms static
- * inlines are used and these aren't necessary, but when static inline is
- * unsupported these will be external functions.
- */
-STATIC_IF_INLINE_DECLARE void pg_atomic_init_flag(volatile pg_atomic_flag *ptr);
-STATIC_IF_INLINE_DECLARE bool pg_atomic_test_set_flag(volatile pg_atomic_flag *ptr);
-STATIC_IF_INLINE_DECLARE bool pg_atomic_unlocked_test_flag(volatile pg_atomic_flag *ptr);
-STATIC_IF_INLINE_DECLARE void pg_atomic_clear_flag(volatile pg_atomic_flag *ptr);
-
-STATIC_IF_INLINE_DECLARE void pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val);
-STATIC_IF_INLINE_DECLARE uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr);
-STATIC_IF_INLINE_DECLARE void pg_atomic_write_u32(volatile pg_atomic_uint32 *ptr, uint32 val);
-STATIC_IF_INLINE_DECLARE uint32 pg_atomic_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 newval);
-STATIC_IF_INLINE_DECLARE bool pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr,
-							   uint32 *expected, uint32 newval);
-STATIC_IF_INLINE_DECLARE uint32 pg_atomic_fetch_add_u32(volatile pg_atomic_uint32 *ptr, int32 add_);
-STATIC_IF_INLINE_DECLARE uint32 pg_atomic_fetch_sub_u32(volatile pg_atomic_uint32 *ptr, int32 sub_);
-STATIC_IF_INLINE_DECLARE uint32 pg_atomic_fetch_and_u32(volatile pg_atomic_uint32 *ptr, uint32 and_);
-STATIC_IF_INLINE_DECLARE uint32 pg_atomic_fetch_or_u32(volatile pg_atomic_uint32 *ptr, uint32 or_);
-STATIC_IF_INLINE_DECLARE uint32 pg_atomic_add_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 add_);
-STATIC_IF_INLINE_DECLARE uint32 pg_atomic_sub_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 sub_);
-
-#ifdef PG_HAVE_ATOMIC_U64_SUPPORT
-
-STATIC_IF_INLINE_DECLARE void pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val_);
-STATIC_IF_INLINE_DECLARE uint64 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr);
-STATIC_IF_INLINE_DECLARE void pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val);
-STATIC_IF_INLINE_DECLARE uint64 pg_atomic_exchange_u64(volatile pg_atomic_uint64 *ptr, uint64 newval);
-STATIC_IF_INLINE_DECLARE bool pg_atomic_compare_exchange_u64(volatile pg_atomic_uint64 *ptr,
-							   uint64 *expected, uint64 newval);
-STATIC_IF_INLINE_DECLARE uint64 pg_atomic_fetch_add_u64(volatile pg_atomic_uint64 *ptr, int64 add_);
-STATIC_IF_INLINE_DECLARE uint64 pg_atomic_fetch_sub_u64(volatile pg_atomic_uint64 *ptr, int64 sub_);
-STATIC_IF_INLINE_DECLARE uint64 pg_atomic_fetch_and_u64(volatile pg_atomic_uint64 *ptr, uint64 and_);
-STATIC_IF_INLINE_DECLARE uint64 pg_atomic_fetch_or_u64(volatile pg_atomic_uint64 *ptr, uint64 or_);
-STATIC_IF_INLINE_DECLARE uint64 pg_atomic_add_fetch_u64(volatile pg_atomic_uint64 *ptr, int64 add_);
-STATIC_IF_INLINE_DECLARE uint64 pg_atomic_sub_fetch_u64(volatile pg_atomic_uint64 *ptr, int64 sub_);
-
-#endif   /* PG_HAVE_64_BIT_ATOMICS */
-
 
 /*
  * pg_compiler_barrier - prevent the compiler from moving code across
@@ -201,18 +161,12 @@ STATIC_IF_INLINE_DECLARE uint64 pg_atomic_sub_fetch_u64(volatile pg_atomic_uint6
  */
 #define pg_spin_delay() pg_spin_delay_impl()
 
-/*
- * The following functions are wrapper functions around the platform specific
- * implementation of the atomic operations performing common checks.
- */
-#if defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS)
-
 /*
  * pg_atomic_init_flag - initialize atomic flag.
  *
  * No barrier semantics.
  */
-STATIC_IF_INLINE_DECLARE void
+static inline void
 pg_atomic_init_flag(volatile pg_atomic_flag *ptr)
 {
 	AssertPointerAlignment(ptr, sizeof(*ptr));
@@ -227,7 +181,7 @@ pg_atomic_init_flag(volatile pg_atomic_flag *ptr)
  *
  * Acquire (including read barrier) semantics.
  */
-STATIC_IF_INLINE_DECLARE bool
+static inline bool
 pg_atomic_test_set_flag(volatile pg_atomic_flag *ptr)
 {
 	AssertPointerAlignment(ptr, sizeof(*ptr));
@@ -242,7 +196,7 @@ pg_atomic_test_set_flag(volatile pg_atomic_flag *ptr)
  *
  * No barrier semantics.
  */
-STATIC_IF_INLINE_DECLARE bool
+static inline bool
 pg_atomic_unlocked_test_flag(volatile pg_atomic_flag *ptr)
 {
 	AssertPointerAlignment(ptr, sizeof(*ptr));
@@ -255,7 +209,7 @@ pg_atomic_unlocked_test_flag(volatile pg_atomic_flag *ptr)
  *
  * Release (including write barrier) semantics.
  */
-STATIC_IF_INLINE_DECLARE void
+static inline void
 pg_atomic_clear_flag(volatile pg_atomic_flag *ptr)
 {
 	AssertPointerAlignment(ptr, sizeof(*ptr));
@@ -271,7 +225,7 @@ pg_atomic_clear_flag(volatile pg_atomic_flag *ptr)
  *
  * No barrier semantics.
  */
-STATIC_IF_INLINE_DECLARE void
+static inline void
 pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
 {
 	AssertPointerAlignment(ptr, 4);
@@ -289,7 +243,7 @@ pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
  *
  * No barrier semantics.
  */
-STATIC_IF_INLINE uint32
+static inline uint32
 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
 {
 	AssertPointerAlignment(ptr, 4);
@@ -304,7 +258,7 @@ pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
  *
  * No barrier semantics.
  */
-STATIC_IF_INLINE_DECLARE void
+static inline void
 pg_atomic_write_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
 {
 	AssertPointerAlignment(ptr, 4);
@@ -319,7 +273,7 @@ pg_atomic_write_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
  *
  * Full barrier semantics.
  */
-STATIC_IF_INLINE uint32
+static inline uint32
 pg_atomic_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 newval)
 {
 	AssertPointerAlignment(ptr, 4);
@@ -338,7 +292,7 @@ pg_atomic_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 newval)
  *
  * Full barrier semantics.
  */
-STATIC_IF_INLINE bool
+static inline bool
 pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr,
 							   uint32 *expected, uint32 newval)
 {
@@ -355,7 +309,7 @@ pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr,
  *
  * Full barrier semantics.
  */
-STATIC_IF_INLINE uint32
+static inline uint32
 pg_atomic_fetch_add_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
 {
 	AssertPointerAlignment(ptr, 4);
@@ -370,7 +324,7 @@ pg_atomic_fetch_add_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
  *
  * Full barrier semantics.
  */
-STATIC_IF_INLINE uint32
+static inline uint32
 pg_atomic_fetch_sub_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
 {
 	AssertPointerAlignment(ptr, 4);
@@ -385,7 +339,7 @@ pg_atomic_fetch_sub_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
  *
  * Full barrier semantics.
  */
-STATIC_IF_INLINE uint32
+static inline uint32
 pg_atomic_fetch_and_u32(volatile pg_atomic_uint32 *ptr, uint32 and_)
 {
 	AssertPointerAlignment(ptr, 4);
@@ -399,7 +353,7 @@ pg_atomic_fetch_and_u32(volatile pg_atomic_uint32 *ptr, uint32 and_)
  *
  * Full barrier semantics.
  */
-STATIC_IF_INLINE uint32
+static inline uint32
 pg_atomic_fetch_or_u32(volatile pg_atomic_uint32 *ptr, uint32 or_)
 {
 	AssertPointerAlignment(ptr, 4);
@@ -413,7 +367,7 @@ pg_atomic_fetch_or_u32(volatile pg_atomic_uint32 *ptr, uint32 or_)
  *
  * Full barrier semantics.
  */
-STATIC_IF_INLINE uint32
+static inline uint32
 pg_atomic_add_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
 {
 	AssertPointerAlignment(ptr, 4);
@@ -428,7 +382,7 @@ pg_atomic_add_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
  *
  * Full barrier semantics.
  */
-STATIC_IF_INLINE uint32
+static inline uint32
 pg_atomic_sub_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
 {
 	AssertPointerAlignment(ptr, 4);
@@ -444,7 +398,7 @@ pg_atomic_sub_fetch_u32(volatile pg_atomic_uint32 *ptr, int32 sub_)
  */
 #ifdef PG_HAVE_ATOMIC_U64_SUPPORT
 
-STATIC_IF_INLINE_DECLARE void
+static inline void
 pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
 {
 	AssertPointerAlignment(ptr, 8);
@@ -452,21 +406,21 @@ pg_atomic_init_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
 	pg_atomic_init_u64_impl(ptr, val);
 }
 
-STATIC_IF_INLINE uint64
+static inline uint64
 pg_atomic_read_u64(volatile pg_atomic_uint64 *ptr)
 {
 	AssertPointerAlignment(ptr, 8);
 	return pg_atomic_read_u64_impl(ptr);
 }
 
-STATIC_IF_INLINE void
+static inline void
 pg_atomic_write_u64(volatile pg_atomic_uint64 *ptr, uint64 val)
 {
 	AssertPointerAlignment(ptr, 8);
 	pg_atomic_write_u64_impl(ptr, val);
 }
 
-STATIC_IF_INLINE uint64
+static inline uint64
 pg_atomic_exchange_u64(volatile pg_atomic_uint64 *ptr, uint64 newval)
 {
 	AssertPointerAlignment(ptr, 8);
@@ -474,7 +428,7 @@ pg_atomic_exchange_u64(volatile pg_atomic_uint64 *ptr, uint64 newval)
 	return pg_atomic_exchange_u64_impl(ptr, newval);
 }
 
-STATIC_IF_INLINE bool
+static inline bool
 pg_atomic_compare_exchange_u64(volatile pg_atomic_uint64 *ptr,
 							   uint64 *expected, uint64 newval)
 {
@@ -483,14 +437,14 @@ pg_atomic_compare_exchange_u64(volatile pg_atomic_uint64 *ptr,
 	return pg_atomic_compare_exchange_u64_impl(ptr, expected, newval);
 }
 
-STATIC_IF_INLINE uint64
+static inline uint64
 pg_atomic_fetch_add_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
 {
 	AssertPointerAlignment(ptr, 8);
 	return pg_atomic_fetch_add_u64_impl(ptr, add_);
 }
 
-STATIC_IF_INLINE uint64
+static inline uint64
 pg_atomic_fetch_sub_u64(volatile pg_atomic_uint64 *ptr, int64 sub_)
 {
 	AssertPointerAlignment(ptr, 8);
@@ -498,28 +452,28 @@ pg_atomic_fetch_sub_u64(volatile pg_atomic_uint64 *ptr, int64 sub_)
 	return pg_atomic_fetch_sub_u64_impl(ptr, sub_);
 }
 
-STATIC_IF_INLINE uint64
+static inline uint64
 pg_atomic_fetch_and_u64(volatile pg_atomic_uint64 *ptr, uint64 and_)
 {
 	AssertPointerAlignment(ptr, 8);
 	return pg_atomic_fetch_and_u64_impl(ptr, and_);
 }
 
-STATIC_IF_INLINE uint64
+static inline uint64
 pg_atomic_fetch_or_u64(volatile pg_atomic_uint64 *ptr, uint64 or_)
 {
 	AssertPointerAlignment(ptr, 8);
 	return pg_atomic_fetch_or_u64_impl(ptr, or_);
 }
 
-STATIC_IF_INLINE uint64
+static inline uint64
 pg_atomic_add_fetch_u64(volatile pg_atomic_uint64 *ptr, int64 add_)
 {
 	AssertPointerAlignment(ptr, 8);
 	return pg_atomic_add_fetch_u64_impl(ptr, add_);
 }
 
-STATIC_IF_INLINE uint64
+static inline uint64
 pg_atomic_sub_fetch_u64(volatile pg_atomic_uint64 *ptr, int64 sub_)
 {
 	AssertPointerAlignment(ptr, 8);
@@ -529,9 +483,6 @@ pg_atomic_sub_fetch_u64(volatile pg_atomic_uint64 *ptr, int64 sub_)
 
 #endif   /* PG_HAVE_64_BIT_ATOMICS */
 
-#endif   /* defined(PG_USE_INLINE) ||
-								 * defined(ATOMICS_INCLUDE_DEFINITIONS) */
-
 #undef INSIDE_ATOMICS_H
 
 #endif   /* ATOMICS_H */

src/include/port/atomics/arch-x86.h

@@ -82,8 +82,6 @@ typedef struct pg_atomic_uint64
 
 #endif /* defined(__GNUC__) && !defined(__INTEL_COMPILER) */
 
-#if defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS)
-
 #if !defined(PG_HAVE_SPIN_DELAY)
 /*
  * This sequence is equivalent to the PAUSE instruction ("rep" is
@@ -251,5 +249,3 @@ pg_atomic_fetch_add_u64_impl(volatile pg_atomic_uint64 *ptr, int64 add_)
 #endif /* defined(__GNUC__) && !defined(__INTEL_COMPILER) */
 
 #endif /* HAVE_ATOMICS */
-
-#endif /* defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS) */

src/include/port/atomics/fallback.h

@@ -102,8 +102,6 @@ typedef struct pg_atomic_uint32
 
 #endif /* PG_HAVE_ATOMIC_U32_SUPPORT */
 
-#if defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS)
-
 #ifdef PG_HAVE_ATOMIC_FLAG_SIMULATION
 
 #define PG_HAVE_ATOMIC_INIT_FLAG
@@ -143,6 +141,3 @@ extern bool pg_atomic_compare_exchange_u32_impl(volatile pg_atomic_uint32 *ptr,
 extern uint32 pg_atomic_fetch_add_u32_impl(volatile pg_atomic_uint32 *ptr, int32 add_);
 
 #endif /* PG_HAVE_ATOMIC_U32_SIMULATION */
-
-
-#endif /* defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS) */

src/include/port/atomics/generic-acc.h

@@ -49,18 +49,12 @@ typedef struct pg_atomic_uint64
 	volatile uint64 value;
 } pg_atomic_uint64;
 
-#endif /* defined(HAVE_ATOMICS) */
-
-
-#if defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS)
-
-#if defined(HAVE_ATOMICS)
 
 #define MINOR_FENCE (_Asm_fence) (_UP_CALL_FENCE | _UP_SYS_FENCE | \
 								 _DOWN_CALL_FENCE | _DOWN_SYS_FENCE )
 
 #define PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32
-STATIC_IF_INLINE bool
+static inline bool
 pg_atomic_compare_exchange_u32_impl(volatile pg_atomic_uint32 *ptr,
 									uint32 *expected, uint32 newval)
 {
@@ -88,7 +82,7 @@ pg_atomic_compare_exchange_u32_impl(volatile pg_atomic_uint32 *ptr,
 
 
 #define PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U64
-STATIC_IF_INLINE bool
+static inline bool
 pg_atomic_compare_exchange_u64_impl(volatile pg_atomic_uint64 *ptr,
 									uint64 *expected, uint64 newval)
 {
@@ -110,5 +104,3 @@ pg_atomic_compare_exchange_u64_impl(volatile pg_atomic_uint64 *ptr,
 #undef MINOR_FENCE
 
 #endif /* defined(HAVE_ATOMICS) */
-
-#endif /* defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS) */

src/include/port/atomics/generic-gcc.h

@@ -57,6 +57,7 @@
 #		define pg_write_barrier_impl()		__atomic_thread_fence(__ATOMIC_RELEASE)
 #endif
 
+
 #ifdef HAVE_ATOMICS
 
 /* generic gcc based atomic flag implementation */
@@ -103,11 +104,6 @@ typedef struct pg_atomic_uint64
 
 #endif /* defined(HAVE_GCC__ATOMIC_INT64_CAS) || defined(HAVE_GCC__SYNC_INT64_CAS) */
 
-/*
- * Implementation follows. Inlined or directly included from atomics.c
- */
-#if defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS)
-
 #ifdef PG_HAVE_ATOMIC_FLAG_SUPPORT
 
 #if defined(HAVE_GCC__SYNC_CHAR_TAS) || defined(HAVE_GCC__SYNC_INT32_TAS)
@@ -231,6 +227,4 @@ pg_atomic_fetch_add_u64_impl(volatile pg_atomic_uint64 *ptr, int64 add_)
 
 #endif /* !defined(PG_DISABLE_64_BIT_ATOMICS) */
 
-#endif /* defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS) */
-
 #endif /* defined(HAVE_ATOMICS) */

src/include/port/atomics/generic-msvc.h

@@ -46,12 +46,6 @@ typedef struct __declspec(align(8)) pg_atomic_uint64
 	volatile uint64 value;
 } pg_atomic_uint64;
 
-#endif /* defined(HAVE_ATOMICS) */
-
-
-#if defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS)
-
-#if defined(HAVE_ATOMICS)
 
 #define PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32
 static inline bool
@@ -107,5 +101,3 @@ pg_atomic_fetch_add_u64_impl(volatile pg_atomic_uint64 *ptr, int64 add_)
 #endif /* _WIN64 */
 
 #endif /* HAVE_ATOMICS */
-
-#endif /* defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS) */

src/include/port/atomics/generic-sunpro.h

@@ -69,8 +69,6 @@ typedef struct pg_atomic_uint64
 #endif /* defined(HAVE_ATOMICS) */
 
 
-#if defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS)
-
 #if defined(HAVE_ATOMICS)
 
 #ifdef HAVE_ATOMIC_H
@@ -106,5 +104,3 @@ pg_atomic_compare_exchange_u64_impl(volatile pg_atomic_uint64 *ptr,
 #endif /* HAVE_ATOMIC_H */
 
 #endif /* defined(HAVE_ATOMICS) */
-
-#endif /* defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS) */

src/include/port/atomics/generic-xlc.h

@@ -35,12 +35,6 @@ typedef struct pg_atomic_uint64
 
 #endif /* __64BIT__ */
 
-#endif /* defined(HAVE_ATOMICS) */
-
-#if defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS)
-
-#if defined(HAVE_ATOMICS)
-
 #define PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32
 static inline bool
 pg_atomic_compare_exchange_u32_impl(volatile pg_atomic_uint32 *ptr,
@@ -91,5 +85,3 @@ pg_atomic_fetch_add_u64_impl(volatile pg_atomic_uint64 *ptr, int64 add_)
 #endif /* PG_HAVE_ATOMIC_U64_SUPPORT */
 
 #endif /* defined(HAVE_ATOMICS) */
-
-#endif /* defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS) */

src/include/port/atomics/generic.h

@@ -40,8 +40,6 @@
 typedef pg_atomic_uint32 pg_atomic_flag;
 #endif
 
-#if defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS)
-
 #ifndef PG_HAVE_ATOMIC_READ_U32
 #define PG_HAVE_ATOMIC_READ_U32
 static inline uint32
@@ -383,5 +381,3 @@ pg_atomic_sub_fetch_u64_impl(volatile pg_atomic_uint64 *ptr, int64 sub_)
 #endif
 
 #endif /* PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U64 */
-
-#endif /* defined(PG_USE_INLINE) || defined(ATOMICS_INCLUDE_DEFINITIONS) */

src/include/utils/arrayaccess.h

@@ -44,20 +44,8 @@ typedef struct array_iter
 	int			bitmask;		/* mask for current bit in nulls bitmap */
 } array_iter;
 
-/*
- * We want the functions below to be inline; but if the compiler doesn't
- * support that, fall back on providing them as regular functions.  See
- * STATIC_IF_INLINE in c.h.
- */
-#ifndef PG_USE_INLINE
-extern void array_iter_setup(array_iter *it, AnyArrayType *a);
-extern Datum array_iter_next(array_iter *it, bool *isnull, int i,
-				int elmlen, bool elmbyval, char elmalign);
-#endif   /* !PG_USE_INLINE */
 
-#if defined(PG_USE_INLINE) || defined(ARRAYACCESS_INCLUDE_DEFINITIONS)
+static inline void
-
-STATIC_IF_INLINE void
 array_iter_setup(array_iter *it, AnyArrayType *a)
 {
 	if (VARATT_IS_EXPANDED_HEADER(a))
@@ -89,7 +77,7 @@ array_iter_setup(array_iter *it, AnyArrayType *a)
 	it->bitmask = 1;
 }
 
-STATIC_IF_INLINE Datum
+static inline Datum
 array_iter_next(array_iter *it, bool *isnull, int i,
 				int elmlen, bool elmbyval, char elmalign)
 {
@@ -127,7 +115,4 @@ array_iter_next(array_iter *it, bool *isnull, int i,
 	return ret;
 }
 
-#endif   /* defined(PG_USE_INLINE) ||
-								 * defined(ARRAYACCESS_INCLUDE_DEFINITIONS) */
-
 #endif   /* ARRAYACCESS_H */

src/include/utils/palloc.h

@@ -98,10 +98,6 @@ extern void *MemoryContextAllocHuge(MemoryContext context, Size size);
 extern void *repalloc_huge(void *pointer, Size size);
 
 /*
- * MemoryContextSwitchTo can't be a macro in standard C compilers.
- * But we can make it an inline function if the compiler supports it.
- * See STATIC_IF_INLINE in c.h.
- *
  * Although this header file is nominally backend-only, certain frontend
  * programs like pg_controldata include it via postgres.h.  For some compilers
  * it's necessary to hide the inline definition of MemoryContextSwitchTo in
@@ -109,11 +105,7 @@ extern void *repalloc_huge(void *pointer, Size size);
  */
 
 #ifndef FRONTEND
-#ifndef PG_USE_INLINE
+static inline MemoryContext
-extern MemoryContext MemoryContextSwitchTo(MemoryContext context);
-#endif   /* !PG_USE_INLINE */
-#if defined(PG_USE_INLINE) || defined(MCXT_INCLUDE_DEFINITIONS)
-STATIC_IF_INLINE MemoryContext
 MemoryContextSwitchTo(MemoryContext context)
 {
 	MemoryContext old = CurrentMemoryContext;
@@ -121,7 +113,6 @@ MemoryContextSwitchTo(MemoryContext context)
 	CurrentMemoryContext = context;
 	return old;
 }
-#endif   /* PG_USE_INLINE || MCXT_INCLUDE_DEFINITIONS */
 #endif   /* FRONTEND */
 
 /* Registration of memory context reset/delete callbacks */

src/include/utils/sortsupport.h

@@ -192,24 +192,11 @@ typedef struct SortSupportData
 } SortSupportData;
 
 
-/*
- * ApplySortComparator should be inlined if possible.  See STATIC_IF_INLINE
- * in c.h.
- */
-#ifndef PG_USE_INLINE
-extern int ApplySortComparator(Datum datum1, bool isNull1,
-					Datum datum2, bool isNull2,
-					SortSupport ssup);
-extern int ApplySortAbbrevFullComparator(Datum datum1, bool isNull1,
-							  Datum datum2, bool isNull2,
-							  SortSupport ssup);
-#endif   /* !PG_USE_INLINE */
-#if defined(PG_USE_INLINE) || defined(SORTSUPPORT_INCLUDE_DEFINITIONS)
 /*
  * Apply a sort comparator function and return a 3-way comparison result.
  * This takes care of handling reverse-sort and NULLs-ordering properly.
  */
-STATIC_IF_INLINE int
+static inline int
 ApplySortComparator(Datum datum1, bool isNull1,
 					Datum datum2, bool isNull2,
 					SortSupport ssup)
@@ -247,7 +234,7 @@ ApplySortComparator(Datum datum1, bool isNull1,
  * authoritative comparator.  This takes care of handling reverse-sort and
  * NULLs-ordering properly.
  */
-STATIC_IF_INLINE int
+static inline int
 ApplySortAbbrevFullComparator(Datum datum1, bool isNull1,
 							  Datum datum2, bool isNull2,
 							  SortSupport ssup)
@@ -279,7 +266,6 @@ ApplySortAbbrevFullComparator(Datum datum1, bool isNull1,
 
 	return compare;
 }
-#endif   /*-- PG_USE_INLINE || SORTSUPPORT_INCLUDE_DEFINITIONS */
 
 /* Other functions in utils/sort/sortsupport.c */
 extern void PrepareSortSupportComparisonShim(Oid cmpFunc, SortSupport ssup);

src/template/aix

@@ -12,6 +12,14 @@ if test "$GCC" != yes ; then
   esac
 fi
 
+# "IBM XL C/C++ for AIX, V12.1" miscompiles, for 32-bit, some inline
+# expansions of ginCompareItemPointers() "long long" arithmetic.  To
+# take advantage of inlining, build a 64-bit PostgreSQL.
+test "$GCC" != yes -a $(getconf HARDWARE_BITMODE) == '32'; then
+  echo "$as_me: WARNING: disabling inlining on 32 bit aix due to a bug in xlc" 2>&1
+  CPPFLAGS="$CPPFLAGS -DPG_FORCE_DISABLE_INLINE"
+fi
+
 # Native memset() is faster, tested on:
 # 	AIX 5.1 and 5.2, XLC 6.0 (IBM's cc)
 # 	AIX 5.3 ML3, gcc 4.0.1