Add a Configure probe for static inline.

This patch enables Configure to probe for C99-style 'static inline'.
(That is, functions may be inlined, but will not be externally visible.)
The initial idea is that some common code in messy macros inside headers
might be simplified using inline functions.  If the compiler does not
support 'static inline', then a plain 'static' is used instead, along
with the consequent implications of a function call (though the compiler
may optimize away the function call and inline the function anyway).
In either case, you simply use  PERL_STATIC_INLINE.

This patch does not *use* this facility at all yet.  It is merely a
Configure patch to make the facility availble for others to experiment
with.

VMS and Windows files will still need to be manually updated.

Finally, before actually converting anything to inline functions, please
try to carefully evaluate the performance implications of any proposed
changes.  Compilers vary in what they will and will not convert to inline
functions, so it's worth proceeding slowly and carefully.

This patch results from a single new metaconfig unit, d_static_inline.U,
which I will separately upload to the metaconfig repository.

diff --git a/Configure b/Configure
index 4217f8c..94805cb 100755 (executable)
--- a/Configure
+++ b/Configure
@@ -748,6 +748,8 @@ d_sresuproto=''
 d_statblks=''
 d_statfs_f_flags=''
 d_statfs_s=''
+d_static_inline=''
+perl_static_inline=''
 d_fstatvfs=''
 d_statvfs=''
 d_stdio_cnt_lval=''
@@ -17874,6 +17876,112 @@ case "$d_statfs_f_flags" in
 *)              echo "No, it doesn't." ;;
 esac
 
+: see what flavor, if any, of static inline is supported
+echo " "
+echo "Checking to see if your system supports static inline..."
+$cat > try.c <<'EOCP'
+#include <stdlib.h>
+extern int f_via_a(int x);
+extern int f_via_b(int x);
+int main(int argc, char **argv)
+{
+    int y;
+
+    y = f_via_a(0);
+#ifdef USE_B
+    y = f_via_b(0);
+#endif
+    if (y == 42) {
+        return EXIT_SUCCESS;
+    }
+    else {
+        return EXIT_FAILURE;
+    }
+}
+EOCP
+$cat > a.c <<'EOCP'
+static INLINE int f(int x) {
+    int y;
+    y = x + 42;
+    return y;
+}
+
+int f_via_a(int x)
+{
+    return f(x);
+}
+EOCP
+$cat > b.c <<'EOCP'
+extern int f(int x);
+
+int f_via_b(int x)
+{
+    return f(x);
+}
+EOCP
+
+# Respect a hint (or previous) value for perl_static_inline, if there is one.
+case "$perl_static_inline" in
+'')    # Check the various possibilities, and break out on success.
+       # For gcc, prefer __inline__, which will still permit 
+       # cflags.SH to add in -ansi.
+       case "$gccversion" in
+               '') xxx="inline __inline__ __inline _inline";;
+               *)  xxx="__inline__ inline __inline _inline";;
+       esac
+       for inline in $xxx; do
+               set try -DINLINE=$inline a.c
+               if eval $compile && $run ./try; then
+                       # Now make sure there is no external linkage of static
+                       # functions
+                       set try -DINLINE=$inline -DUSE_B a.c b.c
+                       if eval $compile && $run ./try; then
+                               $echo "Your compiler supports static $inline, " >&4
+                               $echo "but it also creates an external definition," >&4
+                               $echo "so I won't use it." >&4
+                               val=$undef
+                       else
+                               $echo "Your compiler supports static $inline." >&4
+                               val=$define
+                               perl_static_inline="static $inline";
+                               break;
+                       fi
+               else
+                       $echo "Your compiler does NOT support static $inline." >&4
+                       val="$undef"
+               fi
+       done
+       ;;
+*inline*) # Some variant of inline exists.
+       echo "Keeping your $hint value of $perl_static_inline."
+       val=$define
+       ;;
+static)  # No inline capabilities
+       echo "Keeping your $hint value of $perl_static_inline."
+       val=$undef
+       ;;
+*)  # Unrecognized previous value -- blindly trust the supplied
+       # value and hope it makes sense.  Use old value for
+       # d_static_inline, if there is one.
+       echo "Keeping your $hint value of $perl_static_inline."
+       case "$d_static_inline" in
+               '') val=$define ;;
+               *)  val=$d_static_inline ;;
+       esac
+       ;;
+esac
+# Fallback to plain 'static' if nothing worked.
+case "$perl_static_inline" in
+'')
+       perl_static_inline="static"
+       val=$undef
+       ;;
+esac
+set d_static_inline
+eval $setvar
+$rm -f a.[co] b.[co]
+$rm_try
+
 : Check stream access
 $cat >&4 <<EOM
 Checking how to access stdio streams by file descriptor number...
@@ -22716,6 +22824,7 @@ d_sresuproto='$d_sresuproto'
 d_statblks='$d_statblks'
 d_statfs_f_flags='$d_statfs_f_flags'
 d_statfs_s='$d_statfs_s'
+d_static_inline='$d_static_inline'
 d_statvfs='$d_statvfs'
 d_stdio_cnt_lval='$d_stdio_cnt_lval'
 d_stdio_ptr_lval='$d_stdio_ptr_lval'
@@ -23112,6 +23221,7 @@ path_sep='$path_sep'
 perl5='$perl5'
 perl='$perl'
 perl_patchlevel='$perl_patchlevel'
+perl_static_inline='$perl_static_inline'
 perladmin='$perladmin'
 perllibs='$perllibs'
 perlpath='$perlpath'

diff --git a/config_h.SH b/config_h.SH
index eedc734..0e4c3a7 100755 (executable)
--- a/config_h.SH
+++ b/config_h.SH
@@ -3137,6 +3137,27 @@ sed <<!GROK!THIS! >$CONFIG_H -e 's!^#undef\(.*/\)\*!/\*#define\1 \*!' -e 's!^#un
 #define Siglongjmp(buf,retval) longjmp((buf),(retval))
 #endif
 
+/* HAS_STATIC_INLINE:
+ *     This symbol, if defined, indicates that the C compiler supports
+ *     C99-style static inline.  That is, the function can't be called
+ *     from another translation unit.
+ */
+/* PERL_STATIC_INLINE:
+ *     This symbol gives the best-guess incantation to use for static
+ *     inline functions.  If HAS_STATIC_INLINE is defined, this will
+ *     give C99-style inline.  If HAS_STATIC_INLINE is not defined,
+ *     this will give a plain 'static'.  It will always be defined
+ *     to something that gives static linkage.
+ *     Possibilities include
+ *             static inline       (c99)
+ *             static __inline__   (gcc -ansi)
+ *             static __inline     (MSVC)
+ *             static _inline      (older MSVC)
+ *             static              (c89 compilers)
+ */
+#$d_static_inline HAS_STATIC_INLINE                            /**/
+#define PERL_STATIC_INLINE $perl_static_inline /**/
+
 /* USE_STDIO_PTR:
  *     This symbol is defined if the _ptr and _cnt fields (or similar)
  *     of the stdio FILE structure can be used to access the stdio buffer

diff --git a/perl.h b/perl.h
index 0d4a891..7fcff2f 100644 (file)
--- a/perl.h
+++ b/perl.h
@@ -140,6 +140,18 @@
 #  define EXTERN_C extern
 #endif
 
+/* Fallback definitions in case we don't have definitions from config.h.
+   This should only matter for systems that don't use Configure and
+   haven't been modified to define PERL_STATIC_INLINE yet.
+*/
+#if !defined(PERL_STATIC_INLINE)
+#  ifdef HAS_STATIC_INLINE
+#    define PERL_STATIC_INLINE static inline
+#  else
+#    define PERL_STATIC_INLINE static
+#  endif
+#endif
+
 #ifdef PERL_GLOBAL_STRUCT
 #  ifndef PERL_GET_VARS
 #    ifdef PERL_GLOBAL_STRUCT_PRIVATE