diff options
Diffstat (limited to 'configure.ac')
| -rw-r--r-- | configure.ac | 4889 |
1 files changed, 4889 insertions, 0 deletions
diff --git a/configure.ac b/configure.ac new file mode 100644 index 0000000000..2de91209d6 --- /dev/null +++ b/configure.ac @@ -0,0 +1,4889 @@ +dnl Process this file with autoconf to produce a configure script. +AC_INIT +{ +AC_CONFIG_AUX_DIR(tool) + +AC_PREREQ(2.67) + +tooldir="$srcdir/tool" + +AC_DISABLE_OPTION_CHECKING + +m4_define([RUBY_M4_INCLUDED], [])dnl +AC_DEFUN([RUBY_M4_INCLUDE], [m4_include([tool/m4/$1])dnl + m4_append([RUBY_M4_INCLUDED], [ \ + $(tooldir)/m4/$1])dnl +]) +RUBY_M4_INCLUDE([_colorize_result_prepare.m4])dnl +RUBY_M4_INCLUDE([ac_msg_result.m4])dnl +RUBY_M4_INCLUDE([colorize_result.m4])dnl +RUBY_M4_INCLUDE([ruby_append_option.m4])dnl +RUBY_M4_INCLUDE([ruby_append_options.m4])dnl +RUBY_M4_INCLUDE([ruby_check_builtin_func.m4])dnl +RUBY_M4_INCLUDE([ruby_check_builtin_overflow.m4])dnl +RUBY_M4_INCLUDE([ruby_check_builtin_setjmp.m4])dnl +RUBY_M4_INCLUDE([ruby_check_header.m4])dnl +RUBY_M4_INCLUDE([ruby_check_printf_prefix.m4])dnl +RUBY_M4_INCLUDE([ruby_check_setjmp.m4])dnl +RUBY_M4_INCLUDE([ruby_check_signedness.m4])dnl +RUBY_M4_INCLUDE([ruby_check_sizeof.m4])dnl +RUBY_M4_INCLUDE([ruby_check_sysconf.m4])dnl +RUBY_M4_INCLUDE([ruby_cppoutfile.m4])dnl +RUBY_M4_INCLUDE([ruby_decl_attribute.m4])dnl +RUBY_M4_INCLUDE([ruby_default_arch.m4])dnl +RUBY_M4_INCLUDE([ruby_define_if.m4])dnl +RUBY_M4_INCLUDE([ruby_defint.m4])dnl +RUBY_M4_INCLUDE([ruby_dtrace_available.m4])dnl +RUBY_M4_INCLUDE([ruby_dtrace_postprocess.m4])dnl +RUBY_M4_INCLUDE([ruby_func_attribute.m4])dnl +RUBY_M4_INCLUDE([ruby_mingw32.m4])dnl +RUBY_M4_INCLUDE([ruby_prepend_option.m4])dnl +RUBY_M4_INCLUDE([ruby_prog_gnu_ld.m4])dnl +RUBY_M4_INCLUDE([ruby_prog_makedirs.m4])dnl +RUBY_M4_INCLUDE([ruby_replace_funcs.m4])dnl +RUBY_M4_INCLUDE([ruby_replace_type.m4])dnl +RUBY_M4_INCLUDE([ruby_require_funcs.m4])dnl +RUBY_M4_INCLUDE([ruby_rm_recursive.m4])dnl +RUBY_M4_INCLUDE([ruby_setjmp_type.m4])dnl +RUBY_M4_INCLUDE([ruby_modular_gc.m4])dnl +RUBY_M4_INCLUDE([ruby_stack_grow_direction.m4])dnl +RUBY_M4_INCLUDE([ruby_thread.m4])dnl +RUBY_M4_INCLUDE([ruby_try_cflags.m4])dnl +RUBY_M4_INCLUDE([ruby_try_cxxflags.m4])dnl +RUBY_M4_INCLUDE([ruby_try_ldflags.m4])dnl +RUBY_M4_INCLUDE([ruby_universal_arch.m4])dnl +RUBY_M4_INCLUDE([ruby_wasm_tools.m4])dnl +RUBY_M4_INCLUDE([ruby_werror_flag.m4])dnl + +AS_IF([test "x${GITHUB_ACTIONS}" = xtrue], +[AC_REQUIRE([_COLORIZE_RESULT_PREPARE])dnl +dnl 93(bright yellow) is copied from .github/workflows/mingw.yml + begin_group() { AS_ECHO(["::group::@<:@93m$[]1@<:@m"]);} + end_group() { AS_ECHO(["::endgroup::"]);} +], +[dnl + begin_group() { :;} + end_group() { :;} +]) + +AC_ARG_VAR([cflags], [additional CFLAGS (ignored when CFLAGS is given)])dnl +AC_ARG_VAR([cppflags], [additional CPPFLAGS (ignored when CPPFLAGS is given)])dnl +AC_ARG_VAR([cxxflags], [additional CXXFLAGS (ignored when CXXFLAGS is given)])dnl +AC_ARG_VAR([rustc_flags], [additional RUSTC_FLAGS])dnl + +[begin]_group "environment section" && { +HAVE_BASERUBY=yes +BASERUBY_VERSION= +AC_ARG_WITH(baseruby, + AS_HELP_STRING([--with-baseruby=RUBY], [use RUBY as baseruby; RUBY is the pathname of ruby]), + [AS_CASE(["$withval"], + [*ruby*],[BASERUBY=$withval], + [no],[HAVE_BASERUBY=no], + [AC_MSG_ERROR(need ruby)]) + ], + [ + AC_PATH_PROG([BASERUBY], [ruby], [false]) + HAVE_BASERUBY= + ]) +AS_IF([test "$HAVE_BASERUBY" = no], [ + # --without-baseruby +], [error=`RUBYOPT=- $BASERUBY --disable=gems "${tooldir}/missing-baseruby.bat" --verbose 2>&1`], [ + HAVE_BASERUBY=yes +], [test "$HAVE_BASERUBY" = ""], [ # no --with-baseruby option + AC_MSG_WARN($error) # just warn and continue + HAVE_BASERUBY=no +], [ # the ruby given by --with-baseruby is too old + AC_MSG_ERROR($error) # bail out +]) +AS_IF([test "${HAVE_BASERUBY:=no}" != no], [ + AS_CASE(["$build_os"], [mingw*], [ + # Can MSys shell run a command with a drive letter? + RUBYOPT=- `cygpath -ma "$BASERUBY"` --disable=gems -e exit 2>/dev/null || HAVE_BASERUBY=no + ]) + RUBY_APPEND_OPTION(BASERUBY, "--disable=gems") + BASERUBY_VERSION=`$BASERUBY -v` + $BASERUBY -C "$srcdir" tool/downloader.rb -d tool -e gnu config.guess config.sub >&AS_MESSAGE_FD +]) +AS_IF([test "$HAVE_BASERUBY" = no], [ + AS_IF([test "$cross_compiling" = yes], [AC_MSG_ERROR([executable host ruby is required for cross-compiling])]) + BASERUBY=${tooldir}/missing-baseruby.bat +]) +AC_SUBST(BASERUBY) +AC_SUBST(HAVE_BASERUBY) +AS_IF([test "$cross_compiling" = yes], + [X_BUILD_EXEEXT=`$BASERUBY -rrbconfig -e ['puts RbConfig::CONFIG["EXEEXT"]']`], + [X_BUILD_EXEEXT='$(EXEEXT)'] +) +AC_SUBST(X_BUILD_EXEEXT) + +AC_ARG_WITH(dump-ast, + AS_HELP_STRING([--with-dump-ast=DUMP_AST], [use DUMP_AST as dump_ast; for cross-compiling with a host-built dump_ast]), + [DUMP_AST=$withval DUMP_AST_TARGET='$(empty)'], + [AS_IF([test "$cross_compiling" = yes], [ + DUMP_AST='build-tool/dump_ast$(BUILD_EXEEXT)' + ], [ + DUMP_AST='./dump_ast$(BUILD_EXEEXT)' + ]) + DUMP_AST_TARGET='$(DUMP_AST)']) +dnl Without baseruby, .rbinc files cannot be regenerated, so clear the +dnl dependency on dump_ast to avoid rebuilding pre-generated .rbinc files. +AS_IF([test "$HAVE_BASERUBY" = no], [DUMP_AST_TARGET='$(empty)']) +AC_SUBST(X_DUMP_AST, "${DUMP_AST}") +AC_SUBST(X_DUMP_AST_TARGET, "${DUMP_AST_TARGET}") + +: ${GIT=git} +HAVE_GIT=yes +AC_ARG_WITH(git, + AS_HELP_STRING([--without-git], [never use git]), + [AS_CASE([$withval], + [no], [HAVE_GIT=no], + [yes], [], + [GIT=$withval])]) +{ + test x"$HAVE_GIT" = xyes && + command -v "$GIT" > /dev/null && + # `git -C`: 1.8.5 + # `git log --no-show-signature`: 2.10.0 + AS_CASE([`$GIT -C . --version 2> /dev/null | sed 's/.* //'`], + [0.*|1.*|2.@<:@0-9@:>@.*], [false], + [true]) +} || HAVE_GIT=no GIT=never-use +AC_SUBST(GIT) +AC_SUBST(HAVE_GIT) + +eval `sed -n -e ['s/^@%:@define RUBY_[A-Z_]*VERSION_\([A-Z][A-Z][A-Z_0-9]*\) \([0-9][0-9]*\)$/\1=\2/p'] \ + -e ['s/^@%:@define \(RUBY_ABI_VERSION\) \([0-9][0-9]*\).*/\1=\2/p'] \ + -e ['s/^@%:@define \(RUBY_PATCHLEVEL\) \(.*\)/\1=\2/p'] \ + $srcdir/include/ruby/internal/abi.h \ + $srcdir/include/ruby/version.h $srcdir/version.h` +for v in MAJOR MINOR TEENY; do + AS_IF([eval "test \"\$$v\" = ''"], [ + AC_MSG_ERROR(could not determine $v number from version.h) + ]) +done +AC_SUBST(MAJOR) +AC_SUBST(MINOR) +AC_SUBST(TEENY) +AC_SUBST(RUBY_API_VERSION, '$(MAJOR).$(MINOR)') +AC_SUBST(RUBY_PROGRAM_VERSION, '$(MAJOR).$(MINOR).$(TEENY)') +AS_CASE([$RUBY_PATCHLEVEL], [-*], [ + AC_DEFINE_UNQUOTED(RUBY_ABI_VERSION, [${RUBY_ABI_VERSION}]) +], [RUBY_ABI_VERSION=]) + +AS_IF([test "$program_prefix" = NONE], [ + program_prefix= +]) +AS_IF([test "$prefix" -ef .], [ + AC_MSG_ERROR(--prefix cannot be the current working directory.) +]) +RUBY_BASE_NAME=`echo ruby | sed "$program_transform_name"` +RUBYW_BASE_NAME=`echo rubyw | sed "$program_transform_name"` +AC_SUBST(RUBY_BASE_NAME) +AC_SUBST(RUBYW_BASE_NAME) +AC_SUBST(RUBY_VERSION_NAME, '${RUBY_BASE_NAME}-${ruby_version}') + +dnl checks for alternative programs +AC_CANONICAL_BUILD +AC_CANONICAL_HOST +AC_CANONICAL_TARGET +AC_SUBST(config_target, $target) +AS_CASE(["$target_cpu-$target_os"], + [aarch64-darwin*], [ + target_cpu=arm64 + AS_CASE(["$target_vendor"], [unknown], [ + target_vendor=apple + target=${target%%-unknown-*}-apple-${target@%:@*-unknown-} + ]) + target="arm64-${target@%:@aarch64-}" + AS_IF([test -n "$target_alias"], [target_alias="arm64-${target_alias@%:@aarch64-}"]) + ]) + +AC_ARG_PROGRAM +RUBY_RM_RECURSIVE +AC_ARG_WITH(gcc, + AS_HELP_STRING([--without-gcc], [never use gcc]), + [ + AS_CASE([$withval], + [no], [: ${CC=cc}], + [yes], [: ${CC=gcc}], + [CC=$withval])]) +dnl If the user switches compilers, we can't believe the cache +AS_IF([test ! -z "$ac_cv_prog_CC" -a ! -z "$CC" -a "$CC" != "$ac_cv_prog_CC"], [ + AC_MSG_ERROR(cached CC is different -- throw away $cache_file +(it is also a good idea to do 'make clean' before compiling)) +]) + +RUBY_WASM_TOOLS + +AS_CASE(["${build_os}"], +[linux*|cygwin*|msys*], [ + # Naruse prefers GCC on Linux + AC_CHECK_TOOLS([CC], [gcc clang cc]) +], +[solaris*], [ + # Clang on Solaris is largely untested. + # https://bugs.ruby-lang.org/issues/17949 + AC_CHECK_TOOLS([CC], [cc gcc]) +], [ + # OpenBSD wants to prefer cc over gcc. + # See https://github.com/ruby/ruby/pull/2443 + AC_CHECK_TOOLS([CC], [cl.exe clang cc gcc c99 /usr/ucb/cc]) +]) + +AC_ARG_VAR([AR], [Archiver command]) +AC_ARG_VAR([AS], [Assembler command]) +AC_ARG_VAR([CC], [C compiler command]) +AC_ARG_VAR([CXX], [C++ compiler command]) +AC_ARG_VAR([LD], [Linker command]) +AC_ARG_VAR([NM], [Symbol list command]) +AC_ARG_VAR([OBJCOPY], [Objcopy command]) +AC_ARG_VAR([OBJDUMP], [Objdump command]) +AC_ARG_VAR([RANLIB], [Ranlib command]) +AC_ARG_VAR([STRIP], [Strip command]) + +# We don't want to bother things like `ccache gcc`, `clang -shared-libgcc`, ... +set rb_dummy ${CC} +rb_CC=$2 +AC_DEFUN([RUBY_CHECK_PROG_FOR_CC], [ + rb_prog=`echo "${rb_CC}" | sed ["s:$2\([^/]*\)$:$3\1:"]` + AC_CHECK_PROG([$1], [$rb_prog], [$rb_prog]) +]) +AS_CASE(["/${rb_CC} "], +[*@<:@\ /@:>@"cc "*], [ + # Don't try g++/clang++ when CC=cc + AC_CHECK_PROGS([CXX], [cl.exe CC c++]) +], +[*icc*], [ + # Intel C++ has interprocedural optimizations. It tends to come with its + # own linker etc. + RUBY_CHECK_PROG_FOR_CC([AR], [icc], [xiar]) + RUBY_CHECK_PROG_FOR_CC([CXX], [icc], [icpc]) + RUBY_CHECK_PROG_FOR_CC([LD], [icc], [xild]) +], +[*gcc*], [ + # Ditto for GCC. + RUBY_CHECK_PROG_FOR_CC([LD], [gcc], [ld]) + RUBY_CHECK_PROG_FOR_CC([AR], [gcc], [gcc-ar]) + RUBY_CHECK_PROG_FOR_CC([CXX], [gcc], [g++]) + RUBY_CHECK_PROG_FOR_CC([NM], [gcc], [gcc-nm]) + RUBY_CHECK_PROG_FOR_CC([RANLIB], [gcc], [gcc-ranlib]) +], +[*clang*], [ + # Ditto for LLVM. Note however that llvm-as is a LLVM-IR to LLVM bitcode + # assembler that does not target your machine native binary. + + # Xcode has its own version tools that may be incompatible with + # genuine LLVM tools, use the tools in the same directory. + + AS_IF([$rb_CC -E -dM -xc - < /dev/null | grep -F __apple_build_version__ > /dev/null], + [llvm_prefix=], [llvm_prefix=llvm-]) + # AC_PREPROC_IFELSE cannot be used before AC_USE_SYSTEM_EXTENSIONS + + RUBY_CHECK_PROG_FOR_CC([LD], [clang], [ld]) # ... maybe try lld ? + RUBY_CHECK_PROG_FOR_CC([AR], [clang], [${llvm_prefix}ar]) +# RUBY_CHECK_PROG_FOR_CC([AS], [clang], [${llvm_prefix}as]) + RUBY_CHECK_PROG_FOR_CC([CXX], [clang], [clang++]) + RUBY_CHECK_PROG_FOR_CC([NM], [clang], [${llvm_prefix}nm]) + RUBY_CHECK_PROG_FOR_CC([OBJCOPY], [clang], [${llvm_prefix}objcopy]) + RUBY_CHECK_PROG_FOR_CC([OBJDUMP], [clang], [${llvm_prefix}objdump]) + RUBY_CHECK_PROG_FOR_CC([RANLIB], [clang], [${llvm_prefix}ranlib]) + RUBY_CHECK_PROG_FOR_CC([STRIP], [clang], [${llvm_prefix}strip]) + + # These -Wno-* flags silence clang-specific diagnostics that don't exist + # in GCC. GCC silently accepts unknown -Wno-* flags but later emits noisy + # "unrecognized command-line option" notes whenever another warning fires. + clang_warnflags="-Wno-constant-logical-operand -Wno-parentheses-equality -Wno-self-assign" +]) +AS_UNSET(rb_CC) +AS_UNSET(rb_dummy) + +AS_CASE(["${build_os}"], +[solaris*], [ + AC_PATH_TOOL([LD], [ld], [/usr/ccs/bin/ld], [/usr/ccs/bin:$PATH]) +], +[aix*], [ + AC_PATH_TOOL([NM], [nm], [/usr/ccs/bin/nm], [/usr/ccs/bin:$PATH]) +]) +AS_CASE(["${target_os}"], +[cygwin*|msys*|mingw*|darwin*], [ + ac_ct_OBJCOPY=":" + ac_cv_prog_OBJCOPY=":" + ac_cv_prog_ac_ct_OBJCOPY=":" +]) + +rb_test_CFLAGS=${CFLAGS+yes} +rb_test_CXXFLAGS=${CXXFLAGS+yes} + +# BSD's ports and MacPorts prefix GNU binutils with 'g' + +dnl Seems necessarily in order to add -std=gnu99 option for gcc 4.9. +m4_version_prereq([2.70], [AC_PROG_CC], [AC_PROG_CC_C99]) + +AC_PROG_CXX +AC_PROG_CPP +AC_PROG_RANLIB +AC_CHECK_TOOLS([AR], [gar ar]) +AC_CHECK_TOOLS([AS], [gas as]) +AC_CHECK_TOOLS([LD], [gld ld]) # ... try gold ? +AC_CHECK_TOOLS([NM], [gnm nm]) +AC_CHECK_TOOLS([OBJCOPY], [gobjcopy objcopy], [:]) +AC_CHECK_TOOLS([OBJDUMP], [gobjdump objdump]) +AC_CHECK_TOOLS([STRIP], [gstrip strip], [:]) + +FIRSTMAKEFILE="" + +# nm errors with Rust's LLVM bitcode when Rust uses a newer LLVM version than nm. +# In case we're working with llvm-nm, tell it to not worry about the bitcode. +AS_IF([${NM} --help 2>&1 | grep -q 'llvm-bc'], [NM="$NM --no-llvm-bc"]) + +AS_IF([test ! $rb_test_CFLAGS], [AS_UNSET(CFLAGS)]); AS_UNSET(rb_test_CFLAGS) +AS_IF([test ! $rb_test_CXXFLAGS], [AS_UNSET(CXXFLAGS)]); AS_UNSET(rb_save_CXXFLAGS) + +AS_IF([test "${CXX}" = "g++" -a -z "${GXX}"], [ + # AC_PROG_CXX sets $CXX to "g++" when it purposefully finds that there is + # _no_ g++. This brain-damaged design must be worked around. Thankfully, + # similar thing doesn't happen for AC_PROG_CC. + rb_there_is_in_fact_no_gplusplus_but_autoconf_is_cheating_us=true +]) + +test x"$target_alias" = x && +target_os=`echo $target_os | sed 's/linux-gnu$/linux/;s/linux-gnu/linux-/'` +ac_install_sh='' # unusable for extension libraries. + +AC_ARG_WITH(os-version-style, + AS_HELP_STRING([--with-os-version-style=TYPE], + [OS version number for target and target_os [[full]]] + [(full|teeny|minor+0|minor|major+0|major|none)]), + [os_version_style=$withval], + [os_version_style=full + AS_CASE($target_os, [[*[0-9].*]], + [AS_CASE([`/usr/bin/ruby -e 'puts RUBY_PLATFORM' 2>/dev/null`], + [[*-*[0-9].*.0]], [os_version_style=minor+0], + [[*-*[0-9].*.*]], [os_version_style=full], + [[*-*[0-9].0] ], [os_version_style=major+0], + [[*-*[0-9].*] ], [os_version_style=minor], + [[*-*[0-9]] ], [os_version_style=major], + )]) + ]) +os_version_style_transform= +AS_CASE("${os_version_style}", + [full|teeny], [], + [minor+0], [os_version_style_transform=['s/\([0-9]\.[0-9][0-9]*\)\.[0-9][.0-9]*$/\1.0/']], + [minor], [os_version_style_transform=['s/\([0-9]\.[0-9][0-9]*\)\.[0-9][.0-9]*$/\1/']], + [major+0], [os_version_style_transform=['s/\([0-9]\)\.[0-9][.0-9]*$/\1.0/']], + [major], [os_version_style_transform=['s/\([0-9]\)\.[0-9][.0-9]*$/\1/']], + [none], [os_version_style_transform=['s/[0-9]*\.[0-9][.0-9]*$//']], + [AC_MSG_ERROR(unknown --with-os-version-style: $withval)]) +AS_IF([test -z "$target_alias" -a -n "$os_version_style_transform"], + [ + target=`echo ${target} | sed "$os_version_style_transform"` + target_os=`echo ${target_os} | sed "$os_version_style_transform"` + ]) + +AC_ARG_WITH(arch, + AS_HELP_STRING([--with-arch=ARCHS], + [build an Apple/NeXT Multi Architecture Binary (MAB); + ARCHS is a comma-delimited list of architectures for + which to build; if this option is disabled or omitted + entirely, then the package will be built only for the + target platform]), + [target_archs="$withval"], [unset target_archs]) + +AC_ARG_ENABLE(load-relative, + AS_HELP_STRING([--enable-load-relative], [resolve load paths at run time]), + [load_relative=$enableval]) + +# checks for UNIX variants that set C preprocessor variables +AC_USE_SYSTEM_EXTENSIONS + +dnl Checks for programs. + +cflagspat= +test -z "$optflags" || + cflagspat="$cflagspat;s|"`eval echo '"'"${optflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/ *$/ /'`'| |g' +test -z "$debugflags" || + cflagspat="$cflagspat;s|"`eval echo '"'"${debugflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/ *$/ /'`'| |g' +test -z "$warnflags" || + cflagspat="$cflagspat;s|"`eval echo '"'"${warnflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/ *$/ /'`'| |g' +AS_IF([test -z "${CFLAGS+set}"], [ + cflags=`echo " $cflags " | sed "$cflagspat;s/^ *//;s/ *$//"` + orig_cflags="$cflags" + cflags='${hardenflags} '"$cflags "'${optflags} ${debugflags} ${warnflags}' +]) +dnl AS_IF([test -z "${CXXFLAGS+set}"], [ +dnl cxxflags=`echo " $cxxflags " | sed "$cflagspat;s/^ *//;s/ *$//"` +dnl orig_cxxflags="$cxxflags" +dnl cxxflags="$cxxflags "'${optflags} ${debugflags} ${warnflags}' +dnl ]) + +AS_CASE(["$host_os:$build_os"], +[darwin*:darwin*], [ + # Following Apple deployed clang are broken + # clang version 1.0 (http://llvm.org/svn/llvm-project/cfe/tags/Apple/clang-23 exported) + # Apple clang version 2.0 (tags/Apple/clang-137) (based on LLVM 2.9svn) + # Apple clang version 2.1 (tags/Apple/clang-163.7.1) (based on LLVM 3.0svn) + AC_PREPROC_IFELSE( + [AC_LANG_PROGRAM([ + @%:@if defined __APPLE_CC__ && defined __clang_major__ && __clang_major__ < 3 + @%:@error premature clang + @%:@endif + ])], + [], + [AC_MSG_ERROR([clang version 3.0 or later is required])]) +]) + +AS_CASE(["$target_os"], +[darwin*], [ + AC_MSG_CHECKING(if minimum required OS X version is supported) + AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <AvailabilityMacros.h> + @%:@if MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_5 + @%:@error pre OS X 10.5 + [!<===== pre OS X 10.5 =====>] + @%:@endif + ]])], + [AC_MSG_RESULT(yes)], + [AC_MSG_RESULT(no) + AC_MSG_ERROR([Unsupported OS X version is required])]) +]) + +RUBY_MINGW32 +AC_SUBST(GCC) +AC_SUBST(LD) +AS_IF([test "$GCC" = yes], [ + linker_flag=-Wl, + : ${optflags=-O3} + gcc_major=`echo =__GNUC__ | $CC -E -xc - | sed '/^=/!d;s///'` + gcc_minor=`echo =__GNUC_MINOR__ | $CC -E -xc - | sed '/^=/!d;s///'` + test -n "$gcc_major" || gcc_major=0 + test -n "$gcc_minor" || gcc_minor=0 + icc_version=`echo =__ICC | $CC -E -xc - | sed '/^=/!d;s///;/^__ICC/d'` + test -n "$icc_version" || icc_version=0 + # RUBY_APPEND_OPTIONS(XCFLAGS, ["-include ruby/config.h" "-include ruby/missing.h"]) + + AS_IF([test "$gcc_major" -lt 4], [ + AC_MSG_ERROR([too old GCC: $gcc_major.$gcc_minor]) + ]) +], [ + linker_flag= +]) + +RUBY_PROG_GNU_LD +RUBY_CPPOUTFILE + +: ${OUTFLAG='-o '} +: ${COUTFLAG=${OUTFLAG}} +: ${CSRCFLAG=''} +AC_SUBST(OUTFLAG) +AC_SUBST(COUTFLAG) +AC_SUBST(CSRCFLAG) + +AS_CASE(["$build_os"], + [darwin*], [ + # gcc 13 warns duplicate -l options, which are added by the + # default spec. + # Xcode linker warns for deprecated architecture and wrongly + # installed TBD files. + AC_MSG_CHECKING(for $CC linker warning) + suppress_ld_waring=no + echo 'int main(void) {return 0;}' > conftest.c + AS_IF([$CC -framework Foundation -o conftest conftest.c 2>&1 | + grep \ + -e '^ld: warning: ignoring duplicate libraries:' \ + -e '^ld: warning: text-based stub file' \ + -e '^ld: warning: -multiply_defined is obsolete' \ + >/dev/null], [ + suppress_ld_waring=yes + ]) + rm -fr conftest* + test $suppress_ld_waring = yes && warnflags="${warnflags:+${warnflags} }-Wl,-w" + AC_MSG_RESULT($suppress_ld_waring) + ]) +AS_CASE(["$target_os"], + [wasi*], [ + # Clang linker automatically uses wasm-opt with -O if it found. + # https://github.com/llvm/llvm-project/blob/812828984c10857a4cd260eb638c52a4411f9143/clang/lib/Driver/ToolChains/WebAssembly.cpp#L95-L118 + # However optimization before asyncify causes misoptimization, + # so wrap clang to insert our fake wasm-opt, which does nothing, in PATH. + CC_WRAPPER=`cd -P "${tooldir}" && pwd`/wasm-clangw + CC="$CC_WRAPPER $CC" + + FIRSTMAKEFILE=GNUmakefile:wasm/GNUmakefile.in + ]) + +cc_version= +for option in --version -v -V -qversion; do + cc_version_message=`$CC $option 2>&1` + cc_version_status=$? + AS_CASE($cc_version_status, [0], [:], [continue]) + AS_CASE($cc_version_message, [*Warning*], [continue]) + cc_version='$(CC) '$option + break +done +AC_SUBST(CC_VERSION, $cc_version) +AC_SUBST(CC_VERSION_MESSAGE, $cc_version_message) + +: ${DLDFLAGS="$LDFLAGS"} + +RUBY_UNIVERSAL_ARCH +AS_IF([test "$target_cpu" != "$host_cpu" -a "$GCC" = yes -a "${universal_binary:-no}" = no], [ + RUBY_DEFAULT_ARCH($target_cpu) +]) +host_os=$target_os +host_vendor=$target_vendor +host_cpu=$target_cpu +host=$target +host_alias=$target_alias + +AC_CACHE_CHECK([for $AR flags], [rb_cv_arflags], [ + AS_IF([$AR rcD conftest.a > /dev/null 2>&1 && rm conftest.a], + [rb_cv_arflags=rcD], [rb_cv_arflags=rcu]) +]) +AC_SUBST(ARFLAGS, ["$rb_cv_arflags "]) + +AS_CASE(["$target_os"], +[cygwin*|msys*|mingw*], [ + AC_CHECK_TOOL(WINDRES, windres) + AC_CHECK_TOOL(DLLWRAP, dllwrap) + target=`echo $target | sed "s/^$target_cpu-/-/"` + target_alias=`echo $target_alias | sed "s/^$target_cpu-/-/"` + target_cpu=`echo $target_cpu | sed s/i.86/i386/` + AS_CASE(["$target"], [-*], [ target="$target_cpu${target}"]) + AS_CASE(["$target_alias"], [-*], [ target_alias="$target_cpu${target_alias}"]) + # cygwin/GNUmakefile.in is not exclusively for cygwin. + FIRSTMAKEFILE=GNUmakefile:cygwin/GNUmakefile.in + AS_CASE(["$target_os"], + [mingw*], [ + test "$rb_cv_msvcrt" = "" && unset rb_cv_msvcrt + AC_CACHE_CHECK(for mingw32 runtime DLL, rb_cv_msvcrt, [ + AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@include <stdio.h>]], + [[FILE* volatile f = stdin; return 0;]])], + [rb_cv_msvcrt=`$OBJDUMP -p conftest$ac_exeext | + tr A-Z a-z | + sed -n '/^[[ ]]*dll name: \(msvc.*\)\.dll$/{s//\1/p;q;}; + /^[[ ]]*dll name: \(ucrtbase\|api-ms-win-crt-.*\)\.dll$/{s//ucrt/p;q;}'`], + [rb_cv_msvcrt=msvcrt]) + test "$rb_cv_msvcrt" = "" && rb_cv_msvcrt=msvcrt]) + RT_VER=`echo "$rb_cv_msvcrt" | tr -cd [0-9]` + test "$RT_VER" = "" && RT_VER=60 + test "$rb_cv_msvcrt" = "ucrt" && RT_VER=140 + AC_DEFINE_UNQUOTED(RUBY_MSVCRT_VERSION, $RT_VER) + sysconfdir= + ]) + rb_cv_binary_elf=no + : ${enable_shared=yes} + ], +[hiuxmpp*], [AC_DEFINE(__HIUX_MPP__)]) # by TOYODA Eizi <toyoda@npd.kishou.go.jp> + +AC_PROG_LN_S +AC_PROG_MAKE_SET +AC_PROG_INSTALL + +AS_CASE(["$target_os"],[openbsd*],[ + ac_cv_path_mkdir="mkdir" +]) + +RUBY_PROG_MAKEDIRS + +AC_CHECK_PROG([DTRACE], [${ac_tool_prefix}dtrace], [${ac_tool_prefix}dtrace]) +AS_IF([test "$cross_compiling:$ac_cv_prog_DTRACE" = no: -a -n "$ac_tool_prefix"], [ + AC_CHECK_PROG([DTRACE], [dtrace], [dtrace]) +]) + +AC_CHECK_PROGS(DOT, dot) +AC_CHECK_PROGS(DOXYGEN, doxygen) + +tool_warned=$ac_tool_warned ac_tool_warned=no +AC_CHECK_TOOL(PKG_CONFIG, pkg-config) +ac_tool_warned=$tool_warned +AS_IF([test -z "$PKG_CONFIG"], [], +["$PKG_CONFIG" --print-errors --version > /dev/null 2>&1], [], +[ + unset ac_cv_prog_PKG_CONFIG + PKG_CONFIG= + AC_MSG_WARN([$PKG_CONFIG does not work; ignore]) +]) + +AC_MSG_CHECKING([whether it is Android]) +AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + @%:@ifndef __ANDROID__ + @%:@error Not android + @%:@endif +]], [[]])], +[ + AC_MSG_RESULT(yes) + target_os=${target_os}-android + AS_IF([test "x$cross_compiling" = xno], [ + AC_MSG_CHECKING([for Android API version]) + # hacky workaround: https://github.com/termux/termux-packages/issues/6176 + rb_android_api=`getprop ro.build.version.sdk` + AC_MSG_RESULT($rb_android_api) + RUBY_APPEND_OPTIONS(CPPFLAGS, -D__ANDROID_API__=$rb_android_api -Wno-macro-redefined) + ]) +], +[AC_MSG_RESULT(no)]) + +AC_SUBST(RM, ['rm -f']) +AC_SUBST(CP, ['cp']) +RMDIRS='$(top_srcdir)/tool/rmdirs' +RMDIR=rmdir +mkdir "rmdirs_$$_test" "rmdirs_$$_test/a" +rmdir --ignore-fail-on-non-empty "rmdirs_$$_test" 2>/dev/null && +RMDIR='rmdir --ignore-fail-on-non-empty' +$RMDIR -p "rmdirs_$$_test/a" 2>/dev/null && +{ test -d "rmdirs_$$_test" || RMDIRS="$RMDIR -p"; } +rmdir "rmdirs_$$_test/a" "rmdirs_$$_test" 2>/dev/null +AC_SUBST(RMDIR) +AC_SUBST(RMDIRS) +AC_SUBST(RMALL, ['rm -fr']) + +AC_MSG_CHECKING([for cd using physical directory]) +rm -fr conf$$.dir +mkdir conf$$.dir && +(cd conf$$.dir && mkdir src build && cd src && +$as_ln_s ../build . > /dev/null 2>&1 && cd build && +for chdir in 'cd -P' 'PWD= cd'; do + /bin/sh -c "$chdir ../src && echo '$chdir' > cdcmd" 2> /dev/null && break +done) +AS_IF([test -f conf$$.dir/src/cdcmd], [ + read CHDIR < conf$$.dir/src/cdcmd 2> /dev/null +], [ + CHDIR=cd +]) +rm -fr conf$$.dir +AC_MSG_RESULT([$CHDIR]) +AC_SUBST(CHDIR) + +AS_CASE(["$FIRSTMAKEFILE"], [*GNUmakefile:*], [gnumake=yes], [ + AC_MSG_CHECKING([if ${MAKE-make} is GNU make]) + mkdir conftest.dir + echo "all:; @echo yes" > conftest.dir/GNUmakefile + echo "all:; @echo no" > conftest.dir/Makefile + gnumake=`(cd conftest.dir; ${MAKE-make})` + rm -fr conftest.dir + AS_CASE(["$gnumake"], + [*yes*], [ + FIRSTMAKEFILE=GNUmakefile:template/GNUmakefile.in + gnumake=yes], + [ + gnumake=no]) + AC_MSG_RESULT($gnumake) +]) +} + +[begin]_group "compiler section" && { +RUBY_WERROR_FLAG([ + AC_MSG_CHECKING([whether CFLAGS is valid]) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])], + [AC_MSG_RESULT(yes)], + [ + AC_MSG_RESULT(no) + AC_MSG_ERROR([something wrong with CFLAGS="$CFLAGS"]) + ] + ) + + AC_MSG_CHECKING([whether LDFLAGS is valid]) + { + mkdir tmp.$$.try_link && + cd tmp.$$.try_link && + cp ../confdefs.h . && + echo '<?xml?><plist><dict><key>CFBundleIdentifier</key><string></string></dict></plist>' > Info.plist && + : + } || AC_MSG_ERROR([failed to make temporary directory]) + AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])], + [AC_MSG_RESULT(yes)], + [ + cd .. && rm -fr tmp.$$.try_link + AC_MSG_RESULT(no) + AC_MSG_ERROR([something wrong with LDFLAGS="$LDFLAGS"]) + ] + ) + cd .. && rm -fr tmp.$$.try_link +]) + +: "rpath" && { + AC_CACHE_CHECK(whether ELF binaries are produced, rb_cv_binary_elf, + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])],[ + AS_CASE(["`head -1 conftest$EXEEXT | tr -dc '\177ELF' | tr '\177' .`"], + [.ELF*], [rb_cv_binary_elf=yes], [rb_cv_binary_elf=no])], + [rb_cv_binary_elf=no])]) + + rpathflag='' + AS_IF([test x"${RPATHFLAG=}" = x], [ + AS_CASE(["$target_os"], + [aix*], [rpathflag='-blibpath:'], + [for rpathflag in "-rpath " -R; do + AS_CASE("$rpathflag", + [*" "], [AS_CASE(["${linker_flag}"], + [*,], [rpathflag=`echo "$rpathflag" | tr ' ' ,`])]) + rpathflag="${linker_flag}${rpathflag}" + RUBY_TRY_LDFLAGS([${rpathflag}.], [], [rpathflag=]) + AS_IF([test "x${rpathflag}" != x], [break]) + done]) + ], [ + rpathflag=`echo "$RPATHFLAG" | sed 's/%.*//'` + ]) + + AC_ARG_ENABLE(rpath, + AS_HELP_STRING([--enable-rpath], [embed run path into extension libraries. + enabled by default on ELF platforms]), + [enable_rpath=$enableval], [enable_rpath="$rb_cv_binary_elf"]) + + AS_IF([test "$enable_rpath:${RPATHFLAG}" = yes:], [ + RPATHFLAG="${rpathflag:+${rpathflag}%1\$-s}" + ]) + AS_CASE([${RPATHFLAG}],[*'%1$'*],[: ${LIBPATHFLAG='-L%1$-s'}],[: ${LIBPATHFLAG='-L%s'}]) +} + +RUBY_TRY_LDFLAGS(-fdeclspec, [fdeclspec=yes], [fdeclspec=no]) +AS_IF([test "$fdeclspec" = yes], [ + RUBY_APPEND_OPTIONS(CFLAGS, -fdeclspec) + RUBY_APPEND_OPTIONS(cflags, -fdeclspec) + RUBY_APPEND_OPTIONS(orig_cflags, -fdeclspec) +]) +RUBY_TRY_CXXFLAGS(-fdeclspec, [fdeclspec=yes], [fdeclspec=no], [@%:@include <cstdio>]) +AS_IF([test "$fdeclspec" = yes], [ + RUBY_APPEND_OPTIONS(CXXFLAGS, -fdeclspec) +]) + +AC_ARG_ENABLE(devel, + AS_HELP_STRING([--enable-devel], [enable development build]), + [RUBY_DEVEL=$enableval], + [AS_IF([test "x${RUBY_DEVEL-no}" != xyes], [RUBY_DEVEL=])] +)dnl +AC_SUBST(RUBY_DEVEL) +particular_werror_flags=${RUBY_DEVEL:-no} +AC_ARG_ENABLE(werror, + AS_HELP_STRING([--disable-werror], + [don't make warnings into errors + even if a compiler support -Werror feature + [[disabled by default unless development version]]]), + [particular_werror_flags=$enableval]) + +rb_cv_warnflags="$warnflags" +AS_CASE(["$GCC:${warnflags+set}:${extra_warnflags:+set}:"], +[yes::*|yes:*:set:], [# GCC && (!warnflags || extra_warnflags) + AS_IF([test $gcc_major -le 6], [ + extra_warnflags="$extra_warnflags -Wno-maybe-uninitialized" + ]) + AS_CASE([ $CFLAGS ], [*" -save-temps="*|*" -save-temps "*], [], [ + extra_warnflags="$extra_warnflags -Werror=misleading-indentation" + ]) + AS_CASE([$target_os], [mingw*], [ + # 64bit Windows is IL32P64; shorten-64-to-32 causes tons of warnigs + extra_warnflags="$extra_warnflags -Wno-shorten-64-to-32" + ], [ + extra_warnflags="$extra_warnflags -Werror=shorten-64-to-32" + ]) + + # ICC doesn't support -Werror= + AS_IF([test $icc_version -gt 0], [ + particular_werror_flags=no + ]) + for wflag in \ + -Werror=extra-tokens \ + -Werror=deprecated-declarations \ + -Werror=division-by-zero -Werror=div-by-zero \ + -Werror=duplicated-cond \ + -Werror=implicit-function-declaration \ + -Werror=implicit-int \ + -Werror=pointer-arith \ + -Werror=write-strings \ + -Werror=old-style-definition \ + -Wimplicit-fallthrough=0 \ + -Wmissing-noreturn \ + -Wno-cast-function-type \ + -Wno-long-long \ + -Wno-missing-field-initializers \ + -Wno-overlength-strings \ + -Wno-packed-bitfield-compat \ + -Wno-tautological-compare \ + -Wno-unused-parameter \ + -Wno-unused-value \ + -Wsuggest-attribute=format \ + -Wsuggest-attribute=noreturn \ + -Wunused-variable \ + -diag-disable=175,188,1684,2259,2312 \ + $clang_warnflags \ + $extra_warnflags \ + ; do + AS_IF([test "$particular_werror_flags" != yes], [ + wflag=`echo x$wflag | sed 's/^x-Werror=/-W/;s/^x//'` + ]) + ok=no + RUBY_TRY_CFLAGS($wflag, [ + RUBY_APPEND_OPTIONS(warnflags, $wflag) + ok=yes + ]) + AS_CASE([$ok:$wflag], [no:-Werror=*], [ + wflag=`echo x$wflag | sed 's/^x-Werror=/-W/'` + RUBY_TRY_CFLAGS($wflag, [ + RUBY_APPEND_OPTIONS(warnflags, $wflag) + particular_werror_flags=no + ]) + ]) + done + AS_IF([test "$particular_werror_flags" = "yes"], [ + wflag=-Werror=undef + ], [ + wflag=-Wundef + ]) + RUBY_TRY_CFLAGS($wflag, [ + RUBY_APPEND_OPTIONS(warnflags, $wflag) + ], [], [ + @%:@if !defined(RUBY_CONFIG_TEST_NEVER_DEFINED_SYMBOL) + @%:@elif RUBY_CONFIG_TEST_NEVER_DEFINED_SYMBOL + @%:@endif + ]) + AS_CASE([" $warnflags "],[*" -Wno-missing-field-initializers "*], [wflag="-Wall -Wextra"], + [wflag=-Wall]) + RUBY_TRY_CFLAGS($wflag, [warnflags="$wflag${warnflags+ $warnflags}"]) + # Disable warnflags while conftest. -Werror=* flags might make bad OS capability guess. + rb_cv_warnflags="$warnflags" + warnflags= +]) +RUBY_TRY_CFLAGS(-Qunused-arguments, [RUBY_APPEND_OPTIONS(rb_cv_wsuppress_flags, -Qunused-arguments)]) +AC_COMPILE_IFELSE([ + AC_LANG_PROGRAM([ +@%:@if !(defined(__SUNPRO_C)||defined(__SUNPRO_CC)) +@%:@error not sunpro +@%:@endif],[])], [ + for e in \ + E_STATEMENT_NOT_REACHED \ + E_INIT_SIGN_EXTEND \ + E_INIT_DOES_NOT_FIT \ + E_INITIALIZATION_TYPE_MISMATCH + do + RUBY_TRY_CFLAGS([-erroff=${e}], [ + RUBY_APPEND_OPTIONS(rb_cv_warnflags, [-erroff=${e}]) + ]) + done +]) + +AC_ARG_WITH(compress-debug-sections, + AS_HELP_STRING([--with-compress-debug-sections=type], + [enable debug section compression]), + [compress_debug_sections=$withval], [compress_debug_sections=]) + +AS_IF([test "$GCC" = yes], [ + # -D_FORTIFY_SOURCE + # When defined _FORTIFY_SOURCE, glibc enables some additional sanity + # argument check. The performance drop is very little and Ubuntu enables + # _FORTIFY_SOURCE=2 by default. So, let's support it for protecting us from + # a mistake of silly C extensions. + + # TODO: check if link succeeds with _FORTIFY_SOURCE=2. + AS_CASE(["$target_os"], + [mingw*], [ + fortify_source=no + ]) + AC_ARG_ENABLE(fortify_source, + AS_HELP_STRING([--disable-fortify-source], + [disable -D_FORTIFY_SOURCE=2 option, which causes link error on mingw]), + [fortify_source=$enableval]) + AS_IF([test "x$fortify_source" != xno], [ + RUBY_TRY_CFLAGS([$optflags -D_FORTIFY_SOURCE=2], + [RUBY_PREPEND_OPTION(hardenflags, -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2)], [], + [@%:@include <stdio.h>]) + ]) + + # -fstack-protector + AS_CASE(["$target_os"], + [emscripten*|wasi*], [ + stack_protector=no + ]) + AS_IF([test -z "${stack_protector+set}"], [ + AS_FOR(option, opt, [-fstack-protector-strong -fstack-protector], [ + RUBY_TRY_CFLAGS(option, [stack_protector=yes]) + AS_IF([test "x$stack_protector" = xyes], [ + RUBY_TRY_LDFLAGS(option, [], [stack_protector=]) + ]) + AS_IF([test "x$stack_protector" = xyes], [stack_protector=option; break]) + ]) + ]) + AC_MSG_CHECKING([for -fstack-protector]) + AC_MSG_RESULT(["$stack_protector"]) + AS_CASE(["$stack_protector"], [-*], [ + RUBY_PREPEND_OPTION(hardenflags, $stack_protector) + RUBY_APPEND_OPTION(XLDFLAGS, $stack_protector) + RUBY_APPEND_OPTION(LDFLAGS, $stack_protector) + ]) + + # aarch64 branch protection + AS_CASE(["$target_cpu"], [aarch64|arm64], [ + # LLVM libunwind is not actually capable of unwinding code compiled with pointer + # authentication unless it's built without LIBUNWIND_ENABLE_CROSS_UNWINDING (see + # https://github.com/llvm/llvm-project/blob/8e35c86977ce5529a9387657321ac9fefcdae5b5/libunwind/src/DwarfInstructions.hpp#L294) + # It seems that macOS ships LLVM compiled this way. + # Detect this and disable automatic insertion of pac-ret flags in that case, since we assume + # that reliable backtraces are more important than hardening flags. + AC_MSG_CHECKING([for a broken LLVM libunwind that cannot unwind code with RA signing]) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + @%:@include <libunwind.h> + int foo = UNW_ECROSSRASIGNING; + ]])], + # If compilation succeeds, that means we a) had libunwind, and b) it was NOT native only + [rb_cv_libunwind_broken_ra_signing=yes], + # if compilation fails, that means we either a) do not have libunwind, or b) have it in + # native only mode (which is good!) + [rb_cv_libunwind_broken_ra_signing=no] + ) + AC_MSG_RESULT(["$rb_cv_libunwind_broken_ra_signing"]) + AS_IF([test "x$rb_cv_libunwind_broken_ra_signing" = "xno"], [ + AS_FOR(option, opt, [-mbranch-protection=pac-ret -msign-return-address=all], [ + # Try these flags in the _prepended_ position - i.e. we want to try building a program + # with CFLAGS="-mbranch-protection=pac-ret $CFLAGS". If the builder has provided different + # branch protection flags in CFLAGS, we don't want to overwrite those. We just want to + # find some branch protection flags which work if none were provided. + RUBY_TRY_CFLAGS_PREPEND(option, [branch_protection=yes], [branch_protection=no]) + AS_IF([test "x$branch_protection" = xyes], [ + # _prepend_ the options to CFLAGS, so that user-provided flags will overwrite them. + # These CFLAGS are used during the configure script to compile further test programs; + # however, $harden_flags is prepended separately to CFLAGS at the end of the script. + RUBY_PREPEND_OPTION(hardenflags, $opt) + break + ]) + ]) + ]) + ]) + + AS_CASE("${compress_debug_sections:-zlib}", + [none|no], [], [ + RUBY_TRY_LDFLAGS(${linker_flag}--compress-debug-sections=${compress_debug_sections:-zlib}, + [compress_debug_sections=${compress_debug_sections:-zlib}], + [compress_debug_sections=no]) + ]) + AS_IF([test "x$compress_debug_sections" != xno], [ + RUBY_APPEND_OPTION(DLDFLAGS, ${linker_flag}--compress-debug-sections=$compress_debug_sections) + ]) + + AS_CASE(["$target_os"],[mingw*], [ + # On Windows platforms, system provided headers are VC++ + # optimized. That is, C++ habits are often contaminated into + # various headers. Most frequent situation is the use of // + # comments. We bypass ANSI C mode for them. Otherwise + # extension libs cannot include those headers. + + # Since math.h in some mingw64 wrongly declares frexp and modf + # to be pure, the variables pointed by the second arguments are + # considered uninitialized unexpectedly. + AC_CACHE_CHECK([whether frexp and modf are broken], + rb_cv_mingw64_broken_frexp_modf, + [ + save_CFLAGS="$CFLAGS" + AS_IF([test "$particular_werror_flags" = "yes"], [ + CFLAGS="$CFLAGS -Werror=uninitialized" + ], [ + CFLAGS="$CFLAGS -Werror -Wuninitialized" + ]) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <math.h> + int foo(double x) + { + int exp; + frexp(x, &exp); + return exp; + }]], [[if (foo(0.0)) return 1;]])], + [rb_cv_mingw64_broken_frexp_modf=no], + [rb_cv_mingw64_broken_frexp_modf=yes]) + CFLAGS="$save_CFLAGS" + ]) + AS_IF([test "$rb_cv_mingw64_broken_frexp_modf" = yes], [ + AC_DEFINE(RUBY_MINGW64_BROKEN_FREXP_MODF) + ]) + ], + [cygwin*|msys*|darwin*|netbsd*], [ + # need lgamma_r() + ]) + + # suppress annoying -Wstrict-overflow warnings + RUBY_TRY_CFLAGS(-fno-strict-overflow, [RUBY_APPEND_OPTION(XCFLAGS, -fno-strict-overflow)]) + + test "${debugflags+set}" || {RUBY_TRY_LDFLAGS(-ggdb3, [debugflags=-ggdb3])} + test "${debugflags+set}" || {RUBY_TRY_LDFLAGS(-ggdb, [debugflags=-ggdb])} + test "${debugflags+set}" || {RUBY_TRY_LDFLAGS(-g3, [debugflags=-g3])} +]) +test $ac_cv_prog_cc_g = yes && : ${debugflags=-g} + +AS_IF([test "$GCC" = ""], [ + AS_CASE(["$target_os"],[aix*],[warnflags="$warnflags -qinfo=por" rb_cv_warnflags="$rb_cv_warnflags -qinfo=por"]) +]) +AS_IF([test "$GCC" = yes], [ + RUBY_TRY_CFLAGS(-fvisibility=hidden, [visibility_option=yes], [visibility_option=no]) + AC_SUBST(WERRORFLAG, "-Werror") + AS_IF([test "$visibility_option" = yes], [ + RUBY_APPEND_OPTION(XCFLAGS, -fvisibility=hidden) + AC_DEFINE(RUBY_SYMBOL_EXPORT_BEGIN, [_Pragma("GCC visibility push(default)")]) + AC_DEFINE(RUBY_SYMBOL_EXPORT_END, [_Pragma("GCC visibility pop")]) + ], [ + RUBY_TRY_LDFLAGS([-Wl,-unexported_symbol,_Init_*], [visibility_option=ld], [visibility_option=no]) + ]) +]) + +AS_IF([test "$GCC" = yes], [ + # optflags + + AS_CASE(["$target_os"], [mingw*], [ + RUBY_TRY_CFLAGS(-fno-omit-frame-pointer, [optflags="${optflags+$optflags }-fno-omit-frame-pointer"]) + RUBY_TRY_CFLAGS(-static-libgcc, [static_libgcc=yes], [static_libgcc=no]) + AS_IF([test "$static_libgcc" = yes], [ + RUBY_APPEND_OPTION(EXTLDFLAGS, -static-libgcc) + ]) + ]) + + # disable fast-math + for oflag in -fno-fast-math; do + RUBY_TRY_CFLAGS($oflag, [RUBY_APPEND_OPTION(optflags, $oflag)]) + done + for oflag in -fexcess-precision=standard -fp-model\ precise; do + RUBY_TRY_CFLAGS($oflag, [RUBY_APPEND_OPTION(XCFLAGS, $oflag)]) + done +]) + +AS_CASE(["$target_cpu"], [[i[3-6]86*]], [ + AC_CACHE_CHECK([for __sync_val_compare_and_swap], [rb_cv_gcc_compiler_cas], [ + AC_LINK_IFELSE([AC_LANG_PROGRAM([[unsigned long atomic_var;]], + [[__sync_val_compare_and_swap(&atomic_var, 0, 1);]])], + [rb_cv_gcc_compiler_cas=yes], + [ + save_CFLAGS="$CFLAGS" CFLAGS="$CFLAGS -march=i486" + AC_LINK_IFELSE([AC_LANG_PROGRAM([[unsigned long atomic_var;]], + [[__sync_val_compare_and_swap(&atomic_var, 0, 1);]])], + [rb_cv_gcc_compiler_cas=i486], + [rb_cv_gcc_compiler_cas=no]) + CFLAGS="$save_CFLAGS" + ]) + ]) + AS_IF([test "$rb_cv_gcc_compiler_cas" = i486], [ARCH_FLAG="-march=i486"]) +]) + +OPT_DIR= +AC_ARG_WITH([gmp-dir], + AS_HELP_STRING([--with-gmp-dir=DIR], + [specify the prefix directory where gmp is installed]), + [OPT_DIR="${OPT_DIR:+$OPT_DIR$PATH_SEPARATOR}$withval"], []) +AC_ARG_WITH([gmp], + [AS_HELP_STRING([--without-gmp], + [disable GNU GMP to accelerate Bignum operations])], + [], [with_gmp=yes]) + +AC_ARG_WITH(opt-dir, + AS_HELP_STRING([--with-opt-dir=DIR-LIST], + [add optional headers and libraries directories separated by $PATH_SEPARATOR]), + [OPT_DIR="${OPT_DIR:+$OPT_DIR$PATH_SEPARATOR}$withval"], []) + +AS_IF([test "x$OPT_DIR" != x], [ + save_IFS="$IFS" IFS="$PATH_SEPARATOR" val= PWD= + for dir in $OPT_DIR; do + test -z "$dir" && continue + dir=`eval $CHDIR '"$dir"' 2>/dev/null && pwd` || continue + val="${val:+$val$PATH_SEPARATOR}$dir" + done + IFS="$save_IFS" OPT_DIR="$val" + unset PWD + unset save_IFS + val=`IFS="$PATH_SEPARATOR" + for dir in $OPT_DIR; do + echo x ${LIBPATHFLAG} ${RPATHFLAG} | + sed "s/^x *//;s${IFS}"'%1\\$-s'"${IFS}${dir}/lib${IFS}g;s${IFS}%s${IFS}${dir}/lib${IFS}g" + done | tr '\012' ' ' | sed 's/ *$//'` + LDFLAGS="${LDFLAGS:+$LDFLAGS }$val" + DLDFLAGS="${DLDFLAGS:+$DLDFLAGS }$val" + LDFLAGS_OPTDIR="$val" + INCFLAGS="${INCFLAGS:+$INCFLAGS }"`echo "$OPT_DIR" | tr "${PATH_SEPARATOR}" '\012' | + sed '/^$/d;s|^|-I|;s|$|/include|' | tr '\012' ' ' | sed 's/ *$//'` +]) +AC_SUBST(incflags, "$INCFLAGS") + +test -z "${ac_env_CFLAGS_set}" -a -n "${cflags+set}" && eval CFLAGS="\"$cflags $ARCH_FLAG\"" +test -z "${ac_env_CXXFLAGS_set}" -a -n "${cxxflags+set}" && eval CXXFLAGS="\"$cxxflags $ARCH_FLAG\"" + + +AC_CACHE_CHECK([whether compiler has statement and declarations in expressions], + rb_cv_have_stmt_and_decl_in_expr, + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]],[[ __extension__ ({ int a = 0; a; }); ]])], + [rb_cv_have_stmt_and_decl_in_expr=yes], + [rb_cv_have_stmt_and_decl_in_expr=no])]) +AS_IF([test "$rb_cv_have_stmt_and_decl_in_expr" = yes], [ + AC_DEFINE(HAVE_STMT_AND_DECL_IN_EXPR) +]) +} + +[begin]_group "header and library section" && { +AC_ARG_WITH(winnt-ver, + AS_HELP_STRING([--with-winnt-ver=0xXXXX], [target Windows NT version (default to 0x0600)]), + [with_winnt_ver="$withval"], [with_winnt_ver="0x0600"]) +AS_CASE(["$target_os"], +[mingw*], [ + RUBY_APPEND_OPTION(CPPFLAGS, -D_WIN32_WINNT=$with_winnt_ver) + RUBY_APPEND_OPTION(CPPFLAGS, -D__MINGW_USE_VC2005_COMPAT) +]) + +RUBY_THREAD + +dnl Checks for libraries. +AS_CASE(["$target_os"],[*bsd*|dragonfly*],[],[ac_cv_func_daemon=no]) + +AS_CASE(["$target_os"], [*android*], [ + AS_CASE(["$target_cpu"], [arm*], [ + ac_cv_func___builtin_setjmp=no + ]) +]) + +AS_UNSET(ORIG_LIBS) +POSTLINK=: +AC_SUBST(POSTLINK) +cleanlibs= +AC_SUBST(cleanlibs) +AS_CASE(["$target_os"], +[nextstep*], [ ], +[openstep*], [ ], +[rhapsody*], [ ], +[darwin*], [ + ORIG_LIBS="$LIBS" + RUBY_PREPEND_OPTION(LIBS, -lobjc) + RUBY_APPEND_OPTIONS(CPPFLAGS, -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE -D_DARWIN_UNLIMITED_SELECT -D_REENTRANT) + AC_CACHE_CHECK([whether syscall(2) is deprecated], rb_cv_syscall_deprecated, + [RUBY_WERROR_FLAG([ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <unistd.h>]], + [[if (syscall(0)) return 1;]])], + [rb_cv_syscall_deprecated=no], + [rb_cv_syscall_deprecated=yes])])]) + AS_IF([test $rb_cv_syscall_deprecated = yes], [ + ac_cv_func___syscall=no + ac_cv_func_syscall=no + ac_cv_header_sys_syscall_h=no + ac_cv_header_syscall_h=no + ]) + ac_cv_func_getcontext=no + ac_cv_func_setcontext=no + ac_cv_type_getgroups=gid_t # getgroups() on Rosetta fills garbage + ac_cv_lib_crypt_crypt=no + ac_cv_func_fdatasync=no # Mac OS X wrongly reports it has fdatasync() + ac_cv_func_vfork=no + AS_IF([test $gcc_major -eq 4 -a $gcc_minor -lt 3], [ + ac_cv_func___builtin_setjmp=no + ]) + AC_CACHE_CHECK(for broken crypt with 8bit chars, rb_cv_broken_crypt, + [AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include <stdio.h> +#include <unistd.h> +#include <string.h> + +void +broken_crypt(const char *salt, const char *buf1, const char *buf2) +{ +#if 0 + printf("%.2x%.2x: %s -> %s\n", (unsigned char)salt[0], (unsigned char)salt[1], + buf1+2, buf2+2); +#endif +} + +int +main() +{ + int i; + char salt[2], buf[256], *s; + for (i = 0; i < 128*128; i++) { + salt[0] = 0x80 | (i & 0x7f); + salt[1] = 0x80 | (i >> 7); + strcpy(buf, crypt("", salt)); + if (strcmp(buf, s = crypt("", salt))) { + broken_crypt(salt, buf, s); + return 1; + } + } + salt[0] = salt[1] = ' '; + strcpy(buf, crypt("", salt)); + salt[0] = salt[1] = 0x80 | ' '; + if (strcmp(buf, s = crypt("", salt))) { + broken_crypt(salt, buf, s); + return 1; + } + return 0; +} +]])], + rb_cv_broken_crypt=no, + rb_cv_broken_crypt=yes, + rb_cv_broken_crypt=yes)]) + AS_IF([test "$rb_cv_broken_crypt" = yes], [ + AC_DEFINE(BROKEN_CRYPT, 1) + ]) + POSTLINK="" + AC_CHECK_PROGS(codesign, codesign) + dsymutils= + AS_CASE("$CC_NO_WRAPPER", [gcc*-1[[3-9]]], [ + dsymutils=${CC_NO_WRAPPER@%:@gcc} + dsymutils=dsymutil${dsymutils%-1*} + dsymutils="$dsymutils-19 $dsymutils-18 $dsymutils-17" + ]) + AC_CHECK_PROGS(dsymutil, $dsymutils dsymutil) + AS_IF([test -n "$codesign"], [ + POSTLINK="{ test -z '\$(RUBY_CODESIGN)' || $codesign -s '\$(RUBY_CODESIGN)' \$@; }${POSTLINK:+; $POSTLINK}" + ]) + AS_IF([test -n "$dsymutil"], [ + POSTLINK="$dsymutil \$@ 2>/dev/null${POSTLINK:+; $POSTLINK}" + ]) + AC_CHECK_HEADERS(crt_externs.h, [], [], [ + #include <crt_externs.h> + ]) + cleanlibs='$(TARGET_SO:=.dSYM)' + ], +[solaris*], [ LIBS="-lm $LIBS" + ac_cv_func_vfork=no + AC_MSG_CHECKING(whether _XOPEN_SOURCE is already given) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <unistd.h> + #ifndef _XOPEN_SOURCE + #error _XOPEN_SOURCE is not defined + #endif + ]], [[]])], + [given_xopen_source=yes], [given_xopen_source=no]) + AC_MSG_RESULT($given_xopen_source) + AS_IF([test $given_xopen_source = no], [ + AC_MSG_CHECKING(appropriate _XOPEN_SOURCE value to define) + define_xopen_source="" + for tmp_xpg in 7 6 5; do + AS_IF([test x"$define_xopen_source" != x], [ + break + ]) + RUBY_WERROR_FLAG([AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + #define _XOPEN_SOURCE ${tmp_xpg}00 + #include <unistd.h> + #ifndef _XPG${tmp_xpg} + #error _XPG${tmp_xpg} should be defined by _XOPEN_SOURCE=${tmp_xpg}00 + #endif + ]], [[]])], + [define_xopen_source=${tmp_xpg}00], []) + ]) + done + AS_IF([test x"$define_xopen_source" = x], [ + define_xopen_source=no + ]) + AC_MSG_RESULT($define_xopen_source) + AS_IF([test x"$define_xopen_source" != xno], [ + RUBY_APPEND_OPTIONS(CPPFLAGS, -D_XOPEN_SOURCE=$define_xopen_source) + # _XOPEN_SOURCE should not be defined for C++ on Solaris. + RUBY_APPEND_OPTIONS(CXXFLAGS, -U_XOPEN_SOURCE) + ]) + ]) + AC_CHECK_TYPES([caddr_t],[],[],[@%:@include <sys/types.h>]) + AC_CACHE_CHECK([whether madvise declaration is needed], rb_cv_madvice_prototype_using_caddr_t, + [RUBY_WERROR_FLAG([AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + @%:@include <sys/unistd.h> + @%:@include <sys/mman.h> + @%:@include <sys/types.h> + extern int madvise(caddr_t, size_t, int); + ]], [[]])], + [rb_cv_madvice_prototype_using_caddr_t=yes], [rb_cv_madvice_prototype_using_caddr_t=no]) + ]) + ]) + AS_IF([test $rb_cv_madvice_prototype_using_caddr_t = yes], [AC_DEFINE(NEED_MADVICE_PROTOTYPE_USING_CADDR_T, 1)]) + ], +[haiku*], [ + LIBS="$LIBS" # m lib is include in root + ], +[cygwin*|msys*], [ + ac_cv_header_langinfo_h=yes + RUBY_APPEND_OPTIONS(CPPFLAGS, -D_XOPEN_SOURCE -D_GNU_SOURCE) + AC_CHECK_FUNCS(cygwin_conv_path) + AC_LIBOBJ([langinfo]) + ], +[mingw*], [ LIBS="-lshell32 -lws2_32 -liphlpapi -limagehlp -lshlwapi -lbcrypt $LIBS" + ac_cv_header_pwd_h=no + ac_cv_header_utime_h=no + ac_cv_header_sys_ioctl_h=no + ac_cv_header_sys_param_h=no + ac_cv_header_sys_resource_h=no + ac_cv_header_sys_select_h=no + ac_cv_header_sys_time_h=no + ac_cv_header_sys_times_h=no + ac_cv_header_sys_socket_h=no + ac_cv_func_chown=yes + ac_cv_func_getegid=yes + ac_cv_func_geteuid=yes + ac_cv_func_getgid=yes + ac_cv_func_getuid=yes + ac_cv_func_execv=yes + ac_cv_func_lstat=yes + ac_cv_func_times=yes + ac_cv_func_waitpid=yes + ac_cv_func_fsync=yes + ac_cv_func_seekdir=yes + ac_cv_func_telldir=yes + ac_cv_func_lchown=yes + ac_cv_func_link=yes + ac_cv_func_readlink=yes + ac_cv_func_shutdown=yes + ac_cv_func_symlink=yes + ac_cv_func_clock_getres=yes + ac_cv_func_clock_gettime=yes + ac_cv_lib_crypt_crypt=no + ac_cv_func_getpgrp_void=no + ac_cv_func_memcmp_working=yes + ac_cv_lib_dl_dlopen=no + rb_cv_negative_time_t=yes + ac_cv_func_fcntl=yes + ac_cv_func_flock=yes + ac_cv_func_gmtime_r=yes + rb_cv_large_fd_select=yes + ac_cv_type_struct_timeval=yes + ac_cv_func_malloc_usable_size=no + ac_cv_type_off_t=yes + ac_cv_sizeof_off_t=8 + AS_IF([test "$target_cpu" = x64], [ + ac_cv_func___builtin_setjmp=yes + ac_cv_func_round=no + ac_cv_func_tgamma=no + ]) + AC_CHECK_TYPE([NET_LUID], [], [], + [@%:@include <winsock2.h> + @%:@include <windows.h> + @%:@include <iphlpapi.h>]) + AS_IF([test x"$ac_cv_type_NET_LUID" = xyes], [ + AC_DEFINE(HAVE_TYPE_NET_LUID, 1) + ]) + AC_CHECK_FUNCS(_gmtime64_s) + AC_CHECK_FUNCS(_wfreopen_s) + AC_LIBOBJ([langinfo]) + ], +[bsdi*], [ LIBS="-lm $LIBS" + AC_DEFINE(BROKEN_SETREUID, 1) + AC_DEFINE(BROKEN_SETREGID, 1) + ac_cv_sizeof_rlim_t=8], +[freebsd*], [ LIBS="-lm $LIBS" + ac_cv_func_getpeername=no + ac_cv_func_getsockname=no + ac_cv_func_shutdown=no + ac_cv_func_close=no + ], +[netbsd*], [ LIBS="-lm $LIBS" + ], +[dragonfly*], [ LIBS="-lm $LIBS" + ], +[aix*],[ LIBS="-lm $LIBS" + ac_cv_func_round=no + ac_cv_func___builtin_setjmp=no + ], +[linux*],[ LIBS="-lm $LIBS" + # __builtin_longjmp in ppc64* Linux does not restore + # the TOC register (r2), which is problematic + # when a global exit happens from JITted .so code. + # __builtin_setjmp can have issues on arm64 linux (see [Bug #14480]). + AS_CASE(["$target_cpu"], [powerpc64*|arm64|aarch64], [ + ac_cv_func___builtin_setjmp=no + ]) + ], +[emscripten*], [LIBS="-lm -lc $LIBS" + RUBY_APPEND_OPTIONS(LDFLAGS, "-sALLOW_MEMORY_GROWTH=1") + RUBY_APPEND_OPTIONS(LDFLAGS, "-sASYNCIFY") + RUBY_APPEND_OPTIONS(LDFLAGS, "-sFORCE_FILESYSTEM=1") + ac_cv_func_shutdown=no + ], +[wasi*],[ LIBS="-lm -lwasi-emulated-mman -lwasi-emulated-signal -lwasi-emulated-getpid -lwasi-emulated-process-clocks $LIBS" + RUBY_APPEND_OPTIONS(CFLAGS, -D_WASI_EMULATED_SIGNAL -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_GETPID -D_WASI_EMULATED_PROCESS_CLOCKS) + RUBY_APPEND_OPTIONS(CPPFLAGS, -D_WASI_EMULATED_SIGNAL -D_WASI_EMULATED_MMAN -D_WASI_EMULATED_GETPID -D_WASI_EMULATED_PROCESS_CLOCKS) + POSTLINK="\$(WASMOPT) --asyncify \$(wasmoptflags) -o \$@ \$@${POSTLINK:+; $POSTLINK}" + # wasi-libc's sys/socket.h is not compatible with -std=gnu99, + # so re-declare shutdown in include/ruby/missing.h + ac_cv_func_shutdown=no + ], +[ LIBS="-lm $LIBS"]) +: ${ORIG_LIBS=$LIBS} + +AS_IF([test -n "${POSTLINK}"], [ + # NOTE: A (part of) link commands used link shared extension libraries. If + # the first line of the value is empty, mkmf prepends default link steps. + LINK_SO="$LINK_SO +\$(POSTLINK)" +]) + +AS_IF([test -n "${rb_there_is_in_fact_no_gplusplus_but_autoconf_is_cheating_us}"], [ + AC_MSG_NOTICE([Test skipped due to lack of a C++ compiler.]) +], +[test -n "${CXX}"], [ + RUBY_WERROR_FLAG([ + AC_MSG_CHECKING([whether CXXFLAGS is valid]) + AC_LANG_PUSH(C++) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <cstdio>]], [[]])], + [AC_MSG_RESULT(yes)],[ + AC_MSG_RESULT(no) + # The message mentions CXXFLAGS, but CPPFLAGS might also affects. + AC_MSG_WARN([something wrong with CXXFLAGS="$CXXFLAGS"]) + CXX=false + ]) + AC_LANG_POP(C++) + ]) +]) + +AC_CHECK_LIB(crypt, crypt) # glibc (GNU/Linux, GNU/Hurd, GNU/kFreeBSD) +AC_CHECK_LIB(dl, dlopen) # Dynamic linking for SunOS/Solaris and SYSV +AC_CHECK_LIB(socket, shutdown) # SunOS/Solaris + +dnl Checks for header files. +AC_HEADER_DIRENT +dnl AC_HEADER_STDC has been checked in AC_USE_SYSTEM_EXTENSIONS +AC_HEADER_STDBOOL +AC_HEADER_SYS_WAIT + +AC_CHECK_HEADERS([afunix.h], [], [], +[#ifdef _WIN32 +# include <winsock2.h> +#endif +]) +AC_CHECK_HEADERS(atomic.h) +AC_CHECK_HEADERS(copyfile.h) +AC_CHECK_HEADERS(direct.h) +AC_CHECK_HEADERS(grp.h) +AC_CHECK_HEADERS(fcntl.h) +AC_CHECK_HEADERS(float.h) +AC_CHECK_HEADERS(ieeefp.h) +AC_CHECK_HEADERS(intrinsics.h) +AC_CHECK_HEADERS(langinfo.h) +AC_CHECK_HEADERS(limits.h) +AC_CHECK_HEADERS(locale.h) +AC_CHECK_HEADERS(malloc.h) +AC_CHECK_HEADERS(malloc/malloc.h) +AC_CHECK_HEADERS(malloc_np.h) +AC_CHECK_HEADERS(net/socket.h) +AC_CHECK_HEADERS(process.h) +AC_CHECK_HEADERS(pwd.h) +AC_CHECK_HEADERS(sanitizer/asan_interface.h) +AC_CHECK_HEADERS(sanitizer/msan_interface.h) +AC_CHECK_HEADERS(sanitizer/tsan_interface.h) +AC_CHECK_HEADERS(setjmpex.h) +AC_CHECK_HEADERS(stdalign.h) +AC_CHECK_HEADERS(stdio.h) +AC_CHECK_HEADERS(sys/attr.h) +AC_CHECK_HEADERS(sys/eventfd.h) +AC_CHECK_HEADERS(sys/fcntl.h) +AC_CHECK_HEADERS(sys/file.h) +AC_CHECK_HEADERS(sys/id.h) +AC_CHECK_HEADERS(sys/ioctl.h) +AC_CHECK_HEADERS(sys/mkdev.h) +AC_CHECK_HEADERS(sys/param.h) +AC_CHECK_HEADERS(sys/prctl.h) +AC_CHECK_HEADERS(sys/random.h) +AC_CHECK_HEADERS(sys/resource.h) +AC_CHECK_HEADERS(sys/select.h) +AC_CHECK_HEADERS(sys/sendfile.h) +AC_CHECK_HEADERS(sys/socket.h) +AC_CHECK_HEADERS(sys/syscall.h) +AC_CHECK_HEADERS(sys/sysmacros.h) +AC_CHECK_HEADERS(sys/time.h) +AC_CHECK_HEADERS(sys/times.h) +AC_CHECK_HEADERS(sys/uio.h) +AC_CHECK_HEADERS(sys/utime.h) +AC_CHECK_HEADERS(syscall.h) +AC_CHECK_HEADERS(time.h) +AC_CHECK_HEADERS(ucontext.h) +AC_CHECK_HEADERS(utime.h) +AC_CHECK_HEADERS(sys/epoll.h) +AC_CHECK_HEADERS(sys/event.h) +AC_CHECK_HEADERS(stdckdint.h) +AC_CHECK_HEADERS(stdatomic.h) + +AS_CASE("$target_cpu", [x64|x86_64|[i[3-6]86*]], [ + AC_CHECK_HEADERS(x86intrin.h) +]) +RUBY_UNIVERSAL_CHECK_HEADER([x86_64, i386], x86intrin.h) + +AS_IF([test "x$with_gmp" != xno], + [RUBY_CHECK_HEADER(gmp.h) + AS_IF([test "x$ac_cv_header_gmp_h" != xno], + AC_SEARCH_LIBS([__gmpz_init], [gmp], + [AC_DEFINE(HAVE_LIBGMP, 1)]))]) + +AC_ARG_WITH([jemalloc], + [AS_HELP_STRING([--with-jemalloc],[use jemalloc allocator])], + [with_jemalloc=$withval], [with_jemalloc=no]) +AS_IF([test "x$with_jemalloc" != xno],[ + # find jemalloc header first + save_CPPFLAGS="${CPPFLAGS}" + CPPFLAGS="${INCFLAGS} ${CPPFLAGS}" + malloc_header= + AC_CHECK_HEADER(jemalloc/jemalloc.h, [malloc_header=jemalloc/jemalloc.h], [ + AC_CHECK_HEADER(jemalloc.h, [malloc_header=jemalloc.h]) + ]) + AS_IF([test "$malloc_header" != ""], [ + AC_DEFINE_UNQUOTED(RUBY_ALTERNATIVE_MALLOC_HEADER, [<$malloc_header>]) + ]) + save_LIBS="$LIBS" + AC_CACHE_CHECK([for jemalloc library], rb_cv_jemalloc_library, [ + rb_cv_jemalloc_library=no + # try [with mangle, without mangle] x [no more additional + # libraries, adding jemalloc] combination, using the jemalloc + # header found above. + for mangle in '' mangle; do + for lib in '' -ljemalloc; do + LIBS="${lib:+$lib }$LIBS" + AC_LINK_IFELSE([AC_LANG_PROGRAM([${mangle:+@%:@define JEMALLOC_MANGLE 1} + @%:@include <stdio.h> + @%:@ifdef RUBY_ALTERNATIVE_MALLOC_HEADER + @%:@include RUBY_ALTERNATIVE_MALLOC_HEADER + @%:@else + extern const char *malloc_conf; + @%:@endif], + [/* access at runtime not to be optimized away */ + if (malloc_conf) printf("malloc_conf=%s\n", malloc_conf);])], + [rb_cv_jemalloc_library="${lib:-none required}${mangle:+ with mangle}"]) + LIBS="$save_LIBS" + test "${rb_cv_jemalloc_library}" = no || break 2 + done + done + ]) + CPPFLAGS="${save_CPPFLAGS}" + unset save_CPPFLAGS + with_jemalloc=${rb_cv_jemalloc_library} + AS_CASE(["$with_jemalloc"], + [no], + [AC_MSG_ERROR([jemalloc requested but not found])], + [-l*], [ + set dummy $with_jemalloc + LIBS="$2 $LIBS" + DLDLIBS="$2${DLDLIBS:+ $DLDLIBS}" # probably needed also in extension libraries + ]) + AS_CASE(["$with_jemalloc"], + [*" with mangle"], [ + AC_DEFINE(JEMALLOC_MANGLE) + ]) + AC_DEFINE(HAVE_MALLOC_CONF) + ac_cv_func_malloc_usable_size=yes +]) # with_jemalloc + +dnl check for large file stuff +mv confdefs.h confdefs1.h +: > confdefs.h +AC_SYS_LARGEFILE +# On 32-bit Solaris, it is safe to define _LARGEFILE_SOURCE +# which is not added by AC_SYS_LARGEFILE. +AS_IF([test x"$enable_largefile" != xno], [ + AS_CASE(["$target_os"], [solaris*], [ + AC_MSG_CHECKING([whether _LARGEFILE_SOURCE should be defined]) + AS_CASE(["${ac_cv_sys_file_offset_bits}:${ac_cv_sys_large_files}"], + ["64:"|"64:no"|"64:unknown"], [ + # insert _LARGEFILE_SOURCE before _FILE_OFFSET_BITS line + # that is the same order as "getconf LFS_CFLAGS" output + mv confdefs.h largefile0.h + : > confdefs.h + AC_DEFINE(_LARGEFILE_SOURCE) + cat largefile0.h >> confdefs.h + rm largefile0.h + AC_MSG_RESULT([yes]) + ], [AC_MSG_RESULT([no])]) + ]) +]) +mv confdefs.h largefile.h +mv confdefs1.h confdefs.h +cat largefile.h >> confdefs.h + +AS_CASE(["$target_os"], + [aix*], [ + AS_CASE(["$target_cpu:$ac_cv_sys_large_files"], + [ppc64:*|powerpc64:*], [], + [*:no|*:unknown], [], + [ + # AIX currently does not support a 32-bit call to posix_fadvise() + # if _LARGE_FILES is defined. + ac_cv_func_posix_fadvise=no + ]) + ]) + +AC_C_BIGENDIAN([], [], [], [AC_DEFINE(AC_APPLE_UNIVERSAL_BUILD, 1)]) +AC_C_CONST +AC_C_CHAR_UNSIGNED +AC_C_INLINE +AC_C_VOLATILE +AC_C_TYPEOF +AC_C_RESTRICT + +AS_CASE(":$ac_cv_c_const:$ac_cv_c_volatile:", + [*:no:*], [AC_MSG_ERROR(ANSI C-conforming const and volatile are mandatory)]) + +AC_CHECK_TYPES([long long, off_t]) + +AC_CACHE_CHECK([char bit], [rb_cv_char_bit], + [test "$universal_binary" = yes && cross_compiling=yes + AC_COMPUTE_INT([rb_cv_char_bit], [CHAR_BIT], + [AC_INCLUDES_DEFAULT([@%:@include <limits.h>])], [rb_cv_char_bit=8]) + test "$universal_binary" = yes && cross_compiling=$real_cross_compiling]) + +RUBY_CHECK_SIZEOF(int, [], [ILP]) +RUBY_CHECK_SIZEOF(short) +RUBY_CHECK_SIZEOF(long, [int], [ILP LP]) +RUBY_CHECK_SIZEOF(long long) +RUBY_CHECK_SIZEOF(__int64, [8], [ILP LP]) +RUBY_CHECK_SIZEOF(__int128, [16], [ILP LP]) +RUBY_CHECK_SIZEOF(off_t) +RUBY_CHECK_SIZEOF(void*, [int long "long long"], [ILP LP LLP]) +RUBY_CHECK_SIZEOF(float) +RUBY_CHECK_SIZEOF(double) +RUBY_CHECK_SIZEOF(time_t, [long "long long"], [], [@%:@include <time.h>]) +RUBY_CHECK_SIZEOF(clock_t, [], [], [@%:@include <time.h>]) +AC_SUBST(X_BUILTIN_BINARY, yes) +AS_IF([test "$cross_compiling" = yes], +[dnl miniruby cannot run if cross compiling + X_BUILTIN_BINARY=no +], +[ + AS_CASE([ac_cv_sizeof_voidp], + [[1-9]*], [dnl fixed value + ], + [ + AC_CACHE_CHECK([word size], [rb_cv_word_size], + [for w in 4 8; do + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@if SIZEOF_VOIDP != ${w} + @%:@error SIZEOF_VOIDP + @%:@endif]])], [rb_cv_word_size=${w}; break]) + done]) + AS_IF([test -z $rb_cv_word_size], [X_BUILTIN_BINARY=no]) + ]) +]) + +AC_CACHE_CHECK(packed struct attribute, rb_cv_packed_struct, + [rb_cv_packed_struct=no + for mac in \ + "__pragma(pack(push, 1)) x __pragma(pack(pop))" \ + "x __attribute__((packed))" \ + ; do + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@define PACKED_STRUCT(x) $mac + PACKED_STRUCT(struct { int a; });]], [[]])], + [rb_cv_packed_struct=$mac; break]) + done]) +AS_IF([test "$rb_cv_packed_struct" != no], [ + AC_DEFINE_UNQUOTED([RBIMPL_ATTR_PACKED_STRUCT_BEGIN()], [`echo " $rb_cv_packed_struct " | sed 's/ x .*//;s/^ *//'`]) + AC_DEFINE_UNQUOTED([RBIMPL_ATTR_PACKED_STRUCT_END()], [`echo " $rb_cv_packed_struct " | sed 's/.* x //;s/ *$//'`]) + RUBY_TRY_CFLAGS(-Wno-address-of-packed-member, [AC_DEFINE(USE_UNALIGNED_MEMBER_ACCESS)]) +]) + +AS_IF([test "x$ac_cv_type_long_long" = xyes], [ + RUBY_CHECK_PRINTF_PREFIX(long long, ll I64, LL) +], [test "x$ac_cv_type___int64" = xyes], [ + RUBY_CHECK_PRINTF_PREFIX(__int64, ll I64, LL) +]) + +RUBY_REPLACE_TYPE(pid_t, int, PIDT) +RUBY_REPLACE_TYPE(uid_t, int, UIDT) +RUBY_REPLACE_TYPE(gid_t, int, GIDT) +RUBY_REPLACE_TYPE(time_t, [], TIMET, [@%:@include <time.h>]) +RUBY_REPLACE_TYPE(dev_t, [int long "long long"], DEVT) +RUBY_REPLACE_TYPE(mode_t, ["unsigned short" "unsigned int" long], MODET, [@%:@include <sys/stat.h>]) +RUBY_REPLACE_TYPE(rlim_t, [int long "long long"], RLIM, [ +@%:@ifdef HAVE_SYS_TYPES_H +@%:@include <sys/types.h> +@%:@endif +@%:@ifdef HAVE_SYS_TYPES_H +@%:@include <sys/time.h> +@%:@endif +@%:@include <sys/resource.h> +]) +RUBY_REPLACE_TYPE(off_t, [], OFFT) +RUBY_REPLACE_TYPE(clockid_t, [], CLOCKID, [@%:@ifdef HAVE_TIME_H +@%:@ include <time.h> +@%:@endif +@%:@ifdef HAVE_SYS_TIME_H +@%:@ include <sys/time.h> +@%:@endif]) + +# __VA_ARGS__ is also tested in AC_PROG_CC_C99 since autoconf 2.60a (around +# 2006). The check below is redundant and should always success. Remain not +# deleted for backward compat. +AC_CACHE_CHECK(for variable length macro, rb_cv_va_args_macro, + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +int foo(const char*); +@%:@define FOO(...) foo(@%:@__VA_ARGS__) +]], [[FOO(1);FOO(1,2);FOO(1,2,3);]])], + rb_cv_va_args_macro=yes, + rb_cv_va_args_macro=no)]) +AS_IF([test "$rb_cv_va_args_macro" = yes], [ + AC_DEFINE(HAVE_VA_ARGS_MACRO) +]) + +# We want C11's `_Alignof`. GCC (and alike) have `__alignof__`, which behave +# slightly differently than the C11's. We cannot use `__alignof__` for our +# purpose. The problem is, however, that old gcc and old clang had both +# implemented `_Alignof` as a synonym of `__alignof__`. They are not what we +# want. We have to check sanity. +# +# See also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52023 +# See also: https://bugs.llvm.org/show_bug.cgi?id=26547 +AC_CACHE_CHECK([if _Alignof() works], rb_cv_have__alignof,[ + rb_cv_have__alignof=no + RUBY_WERROR_FLAG([ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + @%:@ifdef HAVE_STDALIGN_H + @%:@include <stdalign.h> + @%:@endif + @%:@ifdef STDC_HEADERS + @%:@include <stddef.h> + @%:@endif + @%:@ifndef __GNUC__ + @%:@define __extension__ + @%:@endif + ]], [[ + typedef struct conftest_tag { + char _; + double d; + } T; + static int conftest_ary@<:@ + offsetof(T, d) == __extension__ _Alignof(double) + ? 1 : -1 + @:>@; + return conftest_ary@<:@0@:>@; + ]])],[ + rb_cv_have__alignof=yes + ],[]) + ]) +]) +AS_IF([test "$rb_cv_have__alignof" != no], [ + AC_DEFINE(HAVE__ALIGNOF) +]) + +RUBY_FUNC_ATTRIBUTE(__const__, CONSTFUNC) +RUBY_FUNC_ATTRIBUTE(__pure__, PUREFUNC) +RUBY_FUNC_ATTRIBUTE(__noreturn__, NORETURN) +RUBY_FUNC_ATTRIBUTE(__deprecated__, DEPRECATED) +RUBY_FUNC_ATTRIBUTE(__deprecated__("by "@%:@n), DEPRECATED_BY(n,x), rb_cv_func_deprecated_by) +RUBY_FUNC_ATTRIBUTE(__noinline__, NOINLINE) +RUBY_FUNC_ATTRIBUTE(__always_inline__, ALWAYS_INLINE) +RUBY_FUNC_ATTRIBUTE(__no_sanitize__(san), NO_SANITIZE(san, x), rb_cv_func_no_sanitize) +RUBY_FUNC_ATTRIBUTE(__no_sanitize_address__, NO_SANITIZE_ADDRESS) +RUBY_FUNC_ATTRIBUTE(__no_address_safety_analysis__, NO_ADDRESS_SAFETY_ANALYSIS) +RUBY_FUNC_ATTRIBUTE(__warn_unused_result__, WARN_UNUSED_RESULT) +RUBY_FUNC_ATTRIBUTE(__unused__, MAYBE_UNUSED) +RUBY_FUNC_ATTRIBUTE(__error__ mesg, ERRORFUNC(mesg,x), rb_cv_func___error__) +RUBY_FUNC_ATTRIBUTE(__warning__ mesg, WARNINGFUNC(mesg,x), rb_cv_func___warning__) +RUBY_FUNC_ATTRIBUTE(__weak__, WEAK, rb_cv_func_weak) +AS_IF([test "$rb_cv_func_weak" != x], [ + AC_DEFINE(HAVE_FUNC_WEAK) +]) + +AC_CACHE_CHECK([for std::nullptr_t], rb_cv_CXX_nullptr, [ + AC_LANG_PUSH([C++]) + AC_COMPILE_IFELSE( + [AC_LANG_PROGRAM( + [@%:@include <cstddef>], + [static std::nullptr_t const *const conftest = nullptr;])], + [rb_cv_CXX_nullptr=yes], + [rb_cv_CXX_nullptr=no]) + AC_LANG_POP()]) +AS_IF([test "$rb_cv_CXX_nullptr" != no],[AC_DEFINE(HAVE_NULLPTR)]) + +if_i386=${universal_binary+[defined __i386__]} +RUBY_FUNC_ATTRIBUTE(__stdcall__, FUNC_STDCALL, rb_cv_func_stdcall, ${if_i386}) +RUBY_FUNC_ATTRIBUTE(__cdecl__, FUNC_CDECL, rb_cv_func_cdecl, ${if_i386}) +RUBY_FUNC_ATTRIBUTE(__fastcall__, FUNC_FASTCALL, rb_cv_func_fastcall, ${if_i386}) +RUBY_FUNC_ATTRIBUTE(__optimize__("O0"), FUNC_UNOPTIMIZED, rb_cv_func_unoptimized) +RUBY_FUNC_ATTRIBUTE(__optimize__("-Os","-fomit-frame-pointer"), FUNC_MINIMIZED, rb_cv_func_minimized) + +AS_IF([test "$GCC" = yes], [ + AC_CACHE_CHECK([for function alias], [rb_cv_gcc_function_alias], + [rb_cv_gcc_function_alias=no + for a in alias weak,alias; do + AC_LINK_IFELSE([AC_LANG_PROGRAM([[void foo(void) {} + void bar(void) __attribute__(($a("foo")));]], [[bar()]])], + [rb_cv_gcc_function_alias=$a; break]) + done]) + AS_IF([test "$rb_cv_gcc_function_alias" != no], [ + AC_DEFINE(HAVE_ATTRIBUTE_FUNCTION_ALIAS) + AC_DEFINE_UNQUOTED([RUBY_ALIAS_FUNCTION_TYPE(type, prot, name, args)], + [type prot __attribute__(($rb_cv_gcc_function_alias(@%:@name)));]) + AC_DEFINE_UNQUOTED([RUBY_ALIAS_FUNCTION_VOID(prot, name, args)], + [RUBY_ALIAS_FUNCTION_TYPE(void, prot, name, args)]) + ]) +]) + +{ + AC_CACHE_CHECK([for __atomic builtins], [rb_cv_gcc_atomic_builtins], [ + AC_LINK_IFELSE([AC_LANG_PROGRAM([[unsigned int atomic_var;]], + [[ + __atomic_exchange_n(&atomic_var, 0, __ATOMIC_SEQ_CST); + __atomic_exchange_n(&atomic_var, 1, __ATOMIC_SEQ_CST); + __atomic_fetch_add(&atomic_var, 1, __ATOMIC_SEQ_CST); + __atomic_fetch_sub(&atomic_var, 1, __ATOMIC_SEQ_CST); + __atomic_or_fetch(&atomic_var, 1, __ATOMIC_SEQ_CST); + ]])], + [rb_cv_gcc_atomic_builtins=yes], + [rb_cv_gcc_atomic_builtins=no])]) + AS_IF([test "$rb_cv_gcc_atomic_builtins" = yes], [ + AC_DEFINE(HAVE_GCC_ATOMIC_BUILTINS) + for lib in "" atomic; do + AS_IF([test "$lib" != ""], [ + AC_CHECK_LIB([atomic], [__atomic_fetch_add_8]) + unset rb_cv_gcc_atomic_builtins_64 + ]) + AC_CACHE_CHECK([for 64bit __atomic builtins${lib:+ with -l$lib}], + [rb_cv_gcc_atomic_builtins_64], [ + AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@include <stdint.h> + uint64_t atomic_var;]], + [[ + __atomic_load_n(&atomic_var, __ATOMIC_RELAXED); + __atomic_store_n(&atomic_var, 0, __ATOMIC_RELAXED); + ]])], + [rb_cv_gcc_atomic_builtins_64=yes], + [rb_cv_gcc_atomic_builtins_64=no])]) + AS_IF([test "$rb_cv_gcc_atomic_builtins_64" = yes], [ + AC_DEFINE(HAVE_GCC_ATOMIC_BUILTINS_64) + break + ]) + done + ]) + + AC_CACHE_CHECK([for __sync builtins], [rb_cv_gcc_sync_builtins], [ + AC_LINK_IFELSE([AC_LANG_PROGRAM([[unsigned int atomic_var;]], + [[ + __sync_lock_test_and_set(&atomic_var, 0); + __sync_lock_test_and_set(&atomic_var, 1); + __sync_fetch_and_add(&atomic_var, 1); + __sync_fetch_and_sub(&atomic_var, 1); + __sync_or_and_fetch(&atomic_var, 1); + __sync_val_compare_and_swap(&atomic_var, 0, 1); + ]])], + [rb_cv_gcc_sync_builtins=yes], + [rb_cv_gcc_sync_builtins=no])]) + AS_IF([test "$rb_cv_gcc_sync_builtins" = yes], [ + AC_DEFINE(HAVE_GCC_SYNC_BUILTINS) + ]) + + AC_CACHE_CHECK(for __builtin_unreachable, rb_cv_func___builtin_unreachable, + [RUBY_WERROR_FLAG( + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[volatile int zero;]], + [[if (zero) __builtin_unreachable();]])], + [rb_cv_func___builtin_unreachable=yes], + [rb_cv_func___builtin_unreachable=no]) + ]) + ]) + AS_IF([test "$rb_cv_func___builtin_unreachable" = yes], [ + AC_DEFINE(HAVE___BUILTIN_UNREACHABLE) + ]) + + AC_CACHE_CHECK(for __assume, rb_cv_func___assume, + [RUBY_WERROR_FLAG([ + AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], + [[__assume(1);]])], + [rb_cv_func___assume=yes], + [rb_cv_func___assume=no]) + ]) + ]) + AS_IF([test "$rb_cv_func___assume" = yes], [ + AC_DEFINE(HAVE___ASSUME) + ]) +} + +AC_CACHE_CHECK(for exported function attribute, rb_cv_func_exported, [ +rb_cv_func_exported=no +RUBY_WERROR_FLAG([ +for mac in '__declspec(dllexport)' '__attribute__ ((__visibility__("default")))'; do + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@define RUBY_FUNC_EXPORTED $mac extern + RUBY_FUNC_EXPORTED void conftest_attribute_check(void);]], [[]])], + [rb_cv_func_exported="$mac"; break]) +done +])]) +AS_IF([test "$rb_cv_func_exported" != no], [ + AC_DEFINE_UNQUOTED(RUBY_FUNC_EXPORTED, [$rb_cv_func_exported extern]) +]) +RUBY_DECL_ATTRIBUTE([__nonnull__(n)], [RUBY_FUNC_NONNULL(n,x)], [rb_cv_func_nonnull], + [], [function], [ +@%:@define x int conftest_attribute_check(void *p) +@%:@define n 1 +]) + +RUBY_APPEND_OPTION(XCFLAGS, -DRUBY_EXPORT) + +AC_CACHE_CHECK(for function name string predefined identifier, + rb_cv_function_name_string, + [AS_CASE(["$target_os"],[openbsd*],[ + rb_cv_function_name_string=__func__ + ],[ + rb_cv_function_name_string=no + RUBY_WERROR_FLAG([ + for func in __func__ __FUNCTION__; do + AC_LINK_IFELSE([AC_LANG_PROGRAM([[@%:@include <stdio.h>]], + [[puts($func);]])], + [rb_cv_function_name_string=$func + break]) + done + ]) + ])] +) +AS_IF([test "$rb_cv_function_name_string" != no], [ + AC_DEFINE_UNQUOTED(RUBY_FUNCTION_NAME_STRING, [$rb_cv_function_name_string]) +]) + +AC_CACHE_CHECK(if enum over int is allowed, rb_cv_enum_over_int, [ + rb_cv_enum_over_int=no + AS_IF([test "x$ac_cv_type_long_long" = xyes], [ + type="unsigned long long" max="ULLONG_MAX" + ], [ + type="unsigned long" max="ULONG_MAX" + ]) + RUBY_WERROR_FLAG([ + AC_COMPILE_IFELSE([ + AC_LANG_BOOL_COMPILE_TRY([ + @%:@include <limits.h> + enum {conftest_max = $max}; + ], [ + (conftest_max == $max) && + (sizeof(conftest_max) == sizeof($type)) + ] + )], + [rb_cv_enum_over_int=yes], + [rb_cv_enum_over_int=no] + ) + ]) +]) +AS_IF([test $rb_cv_enum_over_int = yes], [ + AC_DEFINE(ENUM_OVER_INT, 1) +]) + +dnl Check whether we need to define sys_nerr locally +AC_CHECK_DECLS([sys_nerr], [], [], [$ac_includes_default +@%:@include <errno.h>]) + +AC_CHECK_DECLS([getenv]) + +AS_CASE(["$target_cpu"], +[alpha*|sh4|sh4el|sh4eb], [AS_CASE(["$target_os"::"$GCC"], + [*::yes], # gcc + [CFLAGS="-mieee $CFLAGS"], + [osf*], # ccc + [CFLAGS="-ieee $CFLAGS"], + )], +[sparc*], [AC_LIBOBJ([sparc])]) + +ac_cv_header_net_socket_h=${ac_cv_header_net_socket_h=no} +AS_IF([test "$ac_cv_header_net_socket_h" = yes], [ + ac_cv_header_sys_socket_h=${ac_cv_header_sys_socket_h=no} +], [ + ac_cv_header_sys_socket_h=${ac_cv_header_sys_socket_h=yes} +]) + + +AC_TYPE_SIZE_T +RUBY_CHECK_SIGNEDNESS(size_t, [AC_MSG_ERROR(size_t is signed)], [], + [@%:@include <sys/types.h>]) +RUBY_CHECK_SIZEOF(size_t, [int long void*], [], [@%:@include <sys/types.h>]) +RUBY_CHECK_SIZEOF(ptrdiff_t, size_t, [], [@%:@include <stddef.h>]) +RUBY_CHECK_SIZEOF(dev_t) +RUBY_CHECK_PRINTF_PREFIX(size_t, z) +RUBY_CHECK_PRINTF_PREFIX(ptrdiff_t, t) +AC_CHECK_MEMBERS([struct stat.st_blksize]) +AC_CHECK_MEMBERS([struct stat.st_blocks]) +AC_CHECK_MEMBERS([struct stat.st_rdev]) +RUBY_CHECK_SIZEOF([struct stat.st_size], [off_t int long "long long"], [], [@%:@include <sys/stat.h>]) +AS_IF([test "$ac_cv_member_struct_stat_st_blocks" = yes], [ + RUBY_CHECK_SIZEOF([struct stat.st_blocks], [off_t int long "long long"], [], [@%:@include <sys/stat.h>]) +]) +RUBY_CHECK_SIZEOF([struct stat.st_ino], [long "long long"], [], [@%:@include <sys/stat.h>]) +RUBY_CHECK_SIZEOF([struct stat.st_dev], [dev_t int long "long long"], [], [@%:@include <sys/stat.h>]) +AS_IF([test "$ac_cv_member_struct_stat_st_rdev" = yes], [ + RUBY_CHECK_SIZEOF([struct stat.st_rdev], [dev_t int long "long long"], [], [@%:@include <sys/stat.h>]) +]) +AC_CHECK_MEMBERS([struct stat.st_atim]) +AC_CHECK_MEMBERS([struct stat.st_atimespec]) +AC_CHECK_MEMBERS([struct stat.st_atimensec]) +AC_CHECK_MEMBERS([struct stat.st_mtim]) +AC_CHECK_MEMBERS([struct stat.st_mtimespec]) +AC_CHECK_MEMBERS([struct stat.st_mtimensec]) +AC_CHECK_MEMBERS([struct stat.st_ctim]) +AC_CHECK_MEMBERS([struct stat.st_ctimespec]) +AC_CHECK_MEMBERS([struct stat.st_ctimensec]) +AC_CHECK_MEMBERS([struct stat.st_birthtimespec]) +AS_IF([test "x$ac_cv_member_struct_stat_st_birthtimespec" != xyes], + [AC_CHECK_MEMBERS([struct statx.stx_btime])]) + +AC_CHECK_TYPES([struct timeval], [], [], [@%:@ifdef HAVE_TIME_H +@%:@include <time.h> +@%:@endif +@%:@ifdef HAVE_SYS_TIME_H +@%:@include <sys/time.h> +@%:@endif]) + +AS_IF([test "${ac_cv_type_struct_timeval}" = yes], [ + RUBY_CHECK_SIZEOF([struct timeval.tv_sec], [time_t long "long long"], [], + [@%:@ifdef HAVE_TIME_H +@%:@include <time.h> +@%:@endif +@%:@ifdef HAVE_SYS_TIME_H +@%:@include <sys/time.h> +@%:@endif]) + AS_CASE(${ac_cv_sizeof_struct_timeval_tv_sec}, + [SIZEOF_INT], [t=int], + [SIZEOF_LONG], [t=long], + [SIZEOF_LONG_LONG], [t=LONG_LONG], + [t=]) + AS_IF([test "${t}" != ""], [ + AC_DEFINE_UNQUOTED(TYPEOF_TIMEVAL_TV_SEC, [$t]) + ]) +]) + +AC_CHECK_TYPES([struct timespec], [], [], [@%:@ifdef HAVE_TIME_H +@%:@include <time.h> +@%:@endif +@%:@ifdef HAVE_SYS_TIME_H +@%:@include <sys/time.h> +@%:@endif]) + +AC_CHECK_TYPES([struct timezone], [], [], [@%:@ifdef HAVE_TIME_H +@%:@ include <time.h> +@%:@endif +@%:@ifdef HAVE_SYS_TIME_H +@%:@ include <sys/time.h> +@%:@endif]) + +AC_CACHE_VAL([rb_cv_large_fd_select], + [AC_CHECK_TYPE(fd_mask, [rb_cv_large_fd_select=yes], [rb_cv_large_fd_select=no], [AC_INCLUDES_DEFAULT([]) +@%:@ifdef HAVE_SYS_SELECT_H +@%:@ include <sys/select.h> +@%:@endif])]) +AS_IF([test "$rb_cv_large_fd_select" = yes], [ + AC_DEFINE(HAVE_RB_FD_INIT, 1) +]) + +RUBY_DEFINT(int8_t, 1) +RUBY_DEFINT(uint8_t, 1, unsigned) +RUBY_DEFINT(int16_t, 2) +RUBY_DEFINT(uint16_t, 2, unsigned) +RUBY_DEFINT(int32_t, 4) +RUBY_DEFINT(uint32_t, 4, unsigned) +RUBY_DEFINT(int64_t, 8) +RUBY_DEFINT(uint64_t, 8, unsigned) +RUBY_DEFINT(int128_t, 16) +RUBY_DEFINT(uint128_t, 16, unsigned) +RUBY_DEFINT(intptr_t, void*) +RUBY_DEFINT(uintptr_t, void*, unsigned) +AS_IF([test "x$rb_cv_type_intptr_t" != xno], [ + RUBY_CHECK_PRINTF_PREFIX(intptr_t, '' ll I64 l, PTR) +]) +RUBY_DEFINT(ssize_t, size_t, [], [@%:@include <sys/types.h>]) dnl may differ from int, so not use AC_TYPE_SSIZE_T. +AS_IF([test "x$rb_cv_type_int64_t" != xno], [ + RUBY_CHECK_PRINTF_PREFIX(int64_t, ll I64 l, 64) +]) + +AC_CACHE_CHECK(for stack end address, rb_cv_stack_end_address, +[rb_cv_stack_end_address=no + AC_LINK_IFELSE([AC_LANG_PROGRAM( + [[extern void *__libc_stack_end;]], + [[if (!__libc_stack_end) return 1;]])], + [rb_cv_stack_end_address="__libc_stack_end"]) +]) +AS_IF([test $rb_cv_stack_end_address != no], [ + AC_DEFINE_UNQUOTED(STACK_END_ADDRESS, $rb_cv_stack_end_address) +]) + +dnl Checks for library functions. +AC_TYPE_GETGROUPS +AS_CASE(["${target_cpu}-${target_os}:${target_archs}"], +[powerpc*-darwin*], [ + AC_LIBSOURCES(alloca.c) + AC_SUBST([ALLOCA], [\${LIBOBJDIR}alloca.${ac_objext}]) + AC_DEFINE(C_ALLOCA) + AC_DEFINE_UNQUOTED(alloca, alloca) + ], +[universal-darwin*:*ppc*], [ + AC_LIBSOURCES(alloca.c) + AC_SUBST([ALLOCA], [\${LIBOBJDIR}alloca.${ac_objext}]) + RUBY_DEFINE_IF([defined __POWERPC__], C_ALLOCA, 1) # Darwin defines __POWERPC__ for ppc and ppc64 both + RUBY_DEFINE_IF([defined __POWERPC__], alloca, alloca) + ], +[ + AC_FUNC_ALLOCA + ]) +AS_IF([test "x$ALLOCA" = "x"], [ + AC_CACHE_CHECK([for dynamic size alloca], rb_cv_dynamic_alloca, [ + for chk in ok __chkstk; do + AC_LINK_IFELSE([AC_LANG_PROGRAM([[ + @%:@ifdef HAVE_ALLOCA_H + @%:@include <alloca.h> + @%:@endif + void $chk() {} + int dynamic_alloca_test; + int dynamic_alloca_result;]], + [[dynamic_alloca_result = alloca(dynamic_alloca_test) != 0;]])], + [rb_cv_dynamic_alloca=$chk; break]) + done]) + AS_IF([test "x$rb_cv_dynamic_alloca" = "x__chkstk"], [ + AC_DEFINE_UNQUOTED(RUBY_ALLOCA_CHKSTK, _$rb_cv_dynamic_alloca) + AS_CASE("$target_cpu", + [x64|x86_64], [ + AC_SUBST([ALLOCA], [\${LIBOBJDIR}x86_64-chkstk.${ac_objext}]) + ],) + ]) +]) +AC_FUNC_MEMCMP + +AS_CASE(["$target_os"],[freebsd*],[ + AC_DEFINE(BROKEN_CLOSE) + AC_REPLACE_FUNCS(close) + ]) + +# dup and dup2 are always available except for WASI +AS_CASE(["$target_os"], + [wasi*], [], + [ + RUBY_REQUIRE_FUNCS(dup dup2) + ] +) + +AC_REPLACE_FUNCS(acosh) +AC_REPLACE_FUNCS(cbrt) +AC_REPLACE_FUNCS(crypt) +AC_REPLACE_FUNCS(erf) +AC_REPLACE_FUNCS(explicit_bzero) +AC_REPLACE_FUNCS(ffs) +AC_REPLACE_FUNCS(flock) +AC_REPLACE_FUNCS(hypot) +AC_REPLACE_FUNCS(lgamma_r) +AC_REPLACE_FUNCS(memmove) +AC_REPLACE_FUNCS(nan) +AC_REPLACE_FUNCS(nextafter) +AC_REPLACE_FUNCS(setproctitle) +AC_REPLACE_FUNCS(strchr) +AC_REPLACE_FUNCS(strerror) +AC_REPLACE_FUNCS(strlcat) +AC_REPLACE_FUNCS(strlcpy) +AC_REPLACE_FUNCS(strstr) +AC_REPLACE_FUNCS(tgamma) + +AC_DEFINE(HAVE_ISFINITE) # C99; backward compatibility + +# for missing/setproctitle.c +AS_CASE(["$target_os"], +[aix* | k*bsd*-gnu | kopensolaris*-gnu | linux* | darwin*], [AC_DEFINE(SPT_TYPE,SPT_REUSEARGV)], +[]) +AC_CHECK_HEADERS(sys/pstat.h) + + +AC_DEFINE(HAVE_SIGNBIT) # C99; backward compatibility + +AC_FUNC_FORK + +AC_CHECK_FUNCS(__syscall) +AC_CHECK_FUNCS(_longjmp) # used for AC_ARG_WITH(setjmp-type) +# we don't use _setjmp if _longjmp doesn't exist. +test x$ac_cv_func__longjmp = xno && ac_cv_func__setjmp=no +AC_CHECK_FUNCS(arc4random_buf) +AC_CHECK_FUNCS(atan2l atan2f) +AC_CHECK_DECLS(atomic_signal_fence, [], [], [@%:@include <stdatomic.h>]) +AC_CHECK_FUNCS(chmod) +AC_CHECK_FUNCS(chown) +AC_CHECK_FUNCS(chroot) +AC_CHECK_FUNCS(chsize) +AC_CHECK_FUNCS(clock_gettime) +AC_CHECK_FUNCS(copy_file_range) +AC_CHECK_FUNCS(cosh) +AC_CHECK_FUNCS(crypt_r) +AC_CHECK_FUNCS(daemon) +AC_CHECK_FUNCS(dirfd) +AC_CHECK_FUNCS(dl_iterate_phdr) +AC_CHECK_FUNCS(dlopen) +AC_CHECK_FUNCS(dladdr) +AC_CHECK_FUNCS(dup3) +AC_CHECK_FUNCS(eaccess) +AC_CHECK_FUNCS(endgrent) +AC_CHECK_FUNCS(eventfd) +AC_CHECK_FUNCS(execl) +AC_CHECK_FUNCS(execle) +AC_CHECK_FUNCS(execv) +AC_CHECK_FUNCS(execve) +AC_CHECK_FUNCS(explicit_memset) +AC_CHECK_FUNCS(fcopyfile) +AC_CHECK_FUNCS(fchdir) +AC_CHECK_FUNCS(fchmod) +AC_CHECK_FUNCS(fchown) +AC_CHECK_FUNCS(fcntl) +AC_CHECK_FUNCS(fdatasync) +AC_CHECK_FUNCS(fdopendir) +AC_CHECK_FUNCS(fgetattrlist) +AC_CHECK_FUNCS(fmod) +AC_CHECK_FUNCS(fstatat) +AC_CHECK_FUNCS(fsync) +AC_CHECK_FUNCS(ftruncate) +AC_CHECK_FUNCS(ftruncate64) # used for Win32 platform +AC_CHECK_FUNCS(getattrlist) +AC_CHECK_FUNCS(getcwd) +AC_CHECK_FUNCS(getegid) +AC_CHECK_FUNCS(getentropy) +AC_CHECK_FUNCS(geteuid) +AC_CHECK_FUNCS(getgid) +AC_CHECK_FUNCS(getgidx) +AC_CHECK_FUNCS(getgrnam) +AC_CHECK_FUNCS(getgrnam_r) +AC_CHECK_FUNCS(getgroups) +AC_CHECK_FUNCS(getlogin) +AC_CHECK_FUNCS(getlogin_r) +AC_CHECK_FUNCS(getpgid) +AC_CHECK_FUNCS(getpgrp) +AC_CHECK_FUNCS(getppid) +AC_CHECK_FUNCS(getpriority) +AC_CHECK_FUNCS(getpwnam) +AC_CHECK_FUNCS(getpwnam_r) +AC_CHECK_FUNCS(getpwuid) +AC_CHECK_FUNCS(getpwuid_r) +AC_CHECK_FUNCS(getrandom) +AC_CHECK_FUNCS(getresgid) +AC_CHECK_FUNCS(getresuid) +AC_CHECK_FUNCS(getrlimit) +AC_CHECK_FUNCS(getsid) +AC_CHECK_FUNCS(gettimeofday) # for making ac_cv_func_gettimeofday +AC_CHECK_FUNCS(getuid) +AC_CHECK_FUNCS(getuidx) +AC_CHECK_FUNCS(gmtime_r) +AC_CHECK_FUNCS(initgroups) +AC_CHECK_FUNCS(ioctl) +AC_CHECK_FUNCS(isfinite) +AC_CHECK_FUNCS(issetugid) +AC_CHECK_FUNCS(kill) +AC_CHECK_FUNCS(killpg) +AC_CHECK_FUNCS(lchmod) +AC_CHECK_FUNCS(lchown) +AC_CHECK_FUNCS(link) +AC_CHECK_FUNCS(llabs) +AC_CHECK_FUNCS(lockf) +AC_CHECK_FUNCS(log2) +AC_CHECK_FUNCS(lstat) +AC_CHECK_FUNCS(lutimes) +AC_CHECK_FUNCS(malloc_usable_size) +AC_CHECK_FUNCS(malloc_size) +AC_CHECK_FUNCS(malloc_trim) +AC_CHECK_FUNCS(mblen) +AC_CHECK_FUNCS(memalign) +AC_CHECK_FUNCS(memset_s) +AC_CHECK_FUNCS(writev) +AC_CHECK_FUNCS(memrchr) +AC_CHECK_FUNCS(memmem) +AC_CHECK_FUNCS(mkfifo) +AC_CHECK_FUNCS(mknod) +AC_CHECK_FUNCS(mktime) +AC_CHECK_FUNCS(mmap) +AC_CHECK_FUNCS(mremap) +AC_CHECK_FUNCS(openat) +AC_CHECK_FUNCS(pclose) +AC_CHECK_FUNCS(pipe) +AC_CHECK_FUNCS(pipe2) +AC_CHECK_FUNCS(poll) +AC_CHECK_FUNCS(popen) +AC_CHECK_FUNCS(posix_fadvise) +AC_CHECK_FUNCS(posix_madvise) +AC_CHECK_FUNCS(posix_memalign) +AC_CHECK_FUNCS(ppoll) +AC_CHECK_FUNCS(pread) +AC_CHECK_FUNCS(pwrite) +AC_CHECK_FUNCS(qsort_r) +AC_CHECK_FUNCS(qsort_s) +AC_CHECK_FUNCS(readlink) +AC_CHECK_FUNCS(realpath) +AC_CHECK_FUNCS(round) +AC_CHECK_FUNCS(sched_getaffinity) +AC_CHECK_FUNCS(seekdir) +AC_CHECK_FUNCS(select_large_fdset) +AC_CHECK_FUNCS(sendfile) +AC_CHECK_FUNCS(setegid) +AC_CHECK_FUNCS(setenv) +AC_CHECK_FUNCS(seteuid) +AC_CHECK_FUNCS(setgid) +AC_CHECK_FUNCS(setgroups) +AC_CHECK_FUNCS(setpgid) +AC_CHECK_FUNCS(setpgrp) +AC_CHECK_FUNCS(setregid) +AC_CHECK_FUNCS(setresgid) +AC_CHECK_FUNCS(setresuid) +AC_CHECK_FUNCS(setreuid) +AC_CHECK_FUNCS(setrgid) +AC_CHECK_FUNCS(setrlimit) +AC_CHECK_FUNCS(setruid) +AC_CHECK_FUNCS(setsid) +AC_CHECK_FUNCS(setuid) +AC_CHECK_FUNCS(shutdown) +AC_CHECK_FUNCS(sigaction) +AC_CHECK_FUNCS(sigaltstack) +AC_CHECK_FUNCS(sigprocmask) +AC_CHECK_FUNCS(sinh) +AC_CHECK_FUNCS(snprintf) +AC_CHECK_FUNCS(spawnv) +AC_CHECK_FUNCS(symlink) +AC_CHECK_FUNCS(syscall) +AC_CHECK_FUNCS(sysconf) +AC_CHECK_FUNCS(system) +AC_CHECK_FUNCS(tanh) +AC_CHECK_FUNCS(telldir) +AC_CHECK_FUNCS(timegm) +AC_CHECK_FUNCS(times) +AC_CHECK_FUNCS(truncate) +AC_CHECK_FUNCS(truncate64) # used for Win32 +AC_CHECK_FUNCS(tzset) +AC_CHECK_FUNCS(umask) +AC_CHECK_FUNCS(unsetenv) +AC_CHECK_FUNCS(utimensat) +AC_CHECK_FUNCS(utimes) +AC_CHECK_FUNCS(wait4) +AC_CHECK_FUNCS(waitpid) +AC_CHECK_FUNCS(__cospi) +AC_CHECK_FUNCS(__sinpi) + +AS_IF([test "x$ac_cv_member_struct_statx_stx_btime" = xyes], + [AC_CHECK_FUNCS(statx)]) + +AS_IF([test "$ac_cv_func_getcwd" = yes], [ + AC_CACHE_CHECK(if getcwd allocates buffer if NULL is given, [rb_cv_getcwd_malloc], + [AC_RUN_IFELSE([AC_LANG_SOURCE([[ +@%:@include <stddef.h> +@%:@include <stdio.h> +@%:@ifdef HAVE_UNISTD_H +@%:@include <unistd.h> +@%:@endif +@%:@ifndef EXIT_SUCCESS +@%:@define EXIT_SUCCESS 0 +@%:@endif +@%:@ifndef EXIT_FAILURE +@%:@define EXIT_FAILURE 1 +@%:@endif + +int +main(int argc, char **argv) +{ + if (!getcwd(NULL, 0)) return EXIT_FAILURE; + return EXIT_SUCCESS; +} +]])], + rb_cv_getcwd_malloc=yes, + rb_cv_getcwd_malloc=no, + AS_CASE($target_os, + [linux*|darwin*|*bsd|cygwin*|msys*|mingw*|mswin*], + [rb_cv_getcwd_malloc=yes], + [rb_cv_getcwd_malloc=no]))]) + AS_IF([test "$rb_cv_getcwd_malloc" = no], [AC_DEFINE(NO_GETCWD_MALLOC, 1)]) +]) + +AS_IF([test "$ac_cv_func_crypt_r" = yes], + [AC_CHECK_HEADERS(crypt.h)]) +AS_IF([test "$ac_cv_func_crypt_r:$ac_cv_header_crypt_h" = yes:yes], + [AC_CHECK_MEMBERS([struct crypt_data.initialized], [], [], + [AC_INCLUDES_DEFAULT([@%:@include <crypt.h>])])]) + +RUBY_CHECK_BUILTIN_FUNC(__builtin_alloca_with_align, [__builtin_alloca_with_align(1, 4096)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_assume_aligned, [__builtin_assume_aligned((void*)32, 32)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_bswap16, [__builtin_bswap16(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_bswap32, [__builtin_bswap32(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_bswap64, [__builtin_bswap64(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_popcount, [__builtin_popcount(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_popcountll, [__builtin_popcountll(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_clz, [__builtin_clz(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_clzl, [__builtin_clzl(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_clzll, [__builtin_clzll(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_ctz, [__builtin_ctz(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_ctzll, [__builtin_ctzll(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_constant_p, [__builtin_constant_p(0)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_choose_expr, [ + [int x[__extension__(__builtin_choose_expr(1, 1, -1))]]; + [int y[__extension__(__builtin_choose_expr(0, -1, 1))]]; + ]) +AS_IF([test x$rb_cv_builtin___builtin_choose_expr = xyes], [ + RUBY_CHECK_BUILTIN_FUNC(__builtin_choose_expr_constant_p, [ + [int x[__extension__(__builtin_choose_expr(__builtin_constant_p(1), 1, -1))]]; + [int y[__extension__(__builtin_choose_expr(__builtin_constant_p(foo), -1, 1))]]; + ]) +]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_types_compatible_p, [__builtin_types_compatible_p(int, int)]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_trap, [__builtin_trap()]) +RUBY_CHECK_BUILTIN_FUNC(__builtin_expect, [__builtin_expect(0, 0)]) + +RUBY_CHECK_BUILTIN_OVERFLOW(add) +RUBY_CHECK_BUILTIN_OVERFLOW(sub) +RUBY_CHECK_BUILTIN_OVERFLOW(mul) + +AS_IF([test "$ac_cv_func_qsort_r" != no], [ + AC_CACHE_CHECK(whether qsort_r is GNU version, rb_cv_gnu_qsort_r, + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +@%:@include <stdlib.h> +void (qsort_r)(void *base, size_t nmemb, size_t size, + int (*compar)(const void *, const void *, void *), + void *arg); +]], [[ ]])], + [rb_cv_gnu_qsort_r=yes], + [rb_cv_gnu_qsort_r=no]) + ]) + AC_CACHE_CHECK(whether qsort_r is BSD version, rb_cv_bsd_qsort_r, + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +@%:@include <stdlib.h> +void (qsort_r)(void *base, size_t nmemb, size_t size, + void *arg, int (*compar)(void *, const void *, const void *)); +]], [[ ]])], + [rb_cv_bsd_qsort_r=yes], + [rb_cv_bsd_qsort_r=no]) + ]) + AS_CASE("$rb_cv_gnu_qsort_r:$rb_cv_bsd_qsort_r", + [yes:no], [ + AC_DEFINE(HAVE_GNU_QSORT_R, 1) + ], + [no:yes], [ + AC_DEFINE(HAVE_BSD_QSORT_R, 1) + ]) +]) + +AC_CACHE_CHECK(whether atan2 handles Inf as C99, rb_cv_atan2_inf_c99, [ + AS_IF([test $ac_cv_func_atan2f:$ac_cv_func_atan2l = yes:yes], [ + AC_RUN_IFELSE([AC_LANG_SOURCE([[ +@%:@include <math.h> +@%:@ifdef HAVE_UNISTD_H +@%:@include <unistd.h> +@%:@endif +@%:@ifndef EXIT_SUCCESS +@%:@define EXIT_SUCCESS 0 +@%:@endif +@%:@ifndef EXIT_FAILURE +@%:@define EXIT_FAILURE 1 +@%:@endif + +int +main(int argc, char **argv) +{ + if (fabs(atan2(INFINITY, INFINITY) - M_PI_4) <= 0.01) return EXIT_SUCCESS; + return EXIT_FAILURE; +} +]])], + [rb_cv_atan2_inf_c99=yes], + [rb_cv_atan2_inf_c99=no], + [AS_CASE($target_os, [mingw*|mswin*], [rb_cv_atan2_inf_c99=no], [rb_cv_atan2_inf_c99=yes])] + ) + ], [rb_cv_atan2_inf_c99=no]) +]) +AS_IF([test "x$rb_cv_atan2_inf_c99" = xyes], [AC_DEFINE(ATAN2_INF_C99)]) + +# Some platform need -lrt for clock_gettime, but the other don't. +AS_IF([test x"$ac_cv_func_clock_gettime" != xyes], [ + # glibc 2.17 moves clock_* functions from librt to the main C library. + # https://sourceware.org/legacy-ml/libc-announce/2012/msg00001.html + AC_CHECK_LIB(rt, clock_gettime) + AS_IF([test x"$ac_cv_lib_rt_clock_gettime" = xyes], [ + AC_DEFINE(HAVE_CLOCK_GETTIME, 1) + ]) +]) +AC_CHECK_FUNCS(clock_getres) # clock_getres should be tested after clock_gettime test including librt test. +AC_CHECK_LIB([rt], [timer_create]) +AC_CHECK_LIB([rt], [timer_settime]) +AS_IF([test x"$ac_cv_lib_rt_timer_create" = xyes], [ + AC_DEFINE(HAVE_TIMER_CREATE, 1) +]) +AS_IF([test x"$ac_cv_lib_rt_timer_settime" = xyes], [ + AC_DEFINE(HAVE_TIMER_SETTIME, 1) +]) + +AC_CACHE_CHECK(for unsetenv returns a value, rb_cv_unsetenv_return_value, + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +#include <stdlib.h> +]], [[int v = unsetenv("foo");]])], + rb_cv_unsetenv_return_value=yes, + rb_cv_unsetenv_return_value=no)]) +AS_IF([test "$rb_cv_unsetenv_return_value" = no], [ + AC_DEFINE(VOID_UNSETENV) +]) + +# End of setjmp check. + +AC_ARG_ENABLE(setreuid, + AS_HELP_STRING([--enable-setreuid], [use setreuid()/setregid() according to need even if obsolete]), + [use_setreuid=$enableval]) +AS_IF([test "$use_setreuid" = yes], [ + AC_DEFINE(USE_SETREUID) + AC_DEFINE(USE_SETREGID) +]) +AC_STRUCT_TIMEZONE +AC_CACHE_CHECK(for struct tm.tm_gmtoff, rb_cv_member_struct_tm_tm_gmtoff, + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ +@%:@define _BSD_SOURCE +@%:@define _DEFAULT_SOURCE +@%:@include <time.h> + ]], + [[struct tm t; t.tm_gmtoff = 3600;]])], + [rb_cv_member_struct_tm_tm_gmtoff=yes], + [rb_cv_member_struct_tm_tm_gmtoff=no])]) +AS_IF([test "$rb_cv_member_struct_tm_tm_gmtoff" = yes], [ + AC_DEFINE(HAVE_STRUCT_TM_TM_GMTOFF) +]) +AC_CACHE_CHECK(for external int daylight, rb_cv_have_daylight, + [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <time.h> + int i;]], + [[i = daylight;]])], + rb_cv_have_daylight=yes, + rb_cv_have_daylight=no)]) +AS_IF([test "$rb_cv_have_daylight" = yes], [ + AC_DEFINE(HAVE_DAYLIGHT) +]) + +AC_CACHE_CHECK(for negative time_t for gmtime(3), rb_cv_negative_time_t, + [AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include <stdlib.h> +#include <time.h> + +void +check(struct tm *tm, int y, int m, int d, int h, int s) +{ + if (!tm || + tm->tm_year != y || + tm->tm_mon != m-1 || + tm->tm_mday != d || + tm->tm_hour != h || + tm->tm_sec != s) { + exit(1); + } +} + +int +main() +{ + time_t t = -1; + struct tm *tm; + + check(gmtime(&t), 69, 12, 31, 23, 59); + t = ~(time_t)0 << 31; + check(gmtime(&t), 1, 12, 13, 20, 52); + return 0; +} +]])], + rb_cv_negative_time_t=yes, + rb_cv_negative_time_t=no, + rb_cv_negative_time_t=yes)]) +AS_IF([test "$rb_cv_negative_time_t" = yes], [ + AC_DEFINE(NEGATIVE_TIME_T) +]) + +# [ruby-dev:40910] overflow of time on FreeBSD +# https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=145341 +AC_CACHE_CHECK(for localtime(3) overflow correctly, rb_cv_localtime_overflow, + [AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include <stdlib.h> +#include <time.h> + +void +check(time_t t1) +{ + struct tm *tm; + time_t t2; + tm = localtime(&t1); + if (!tm) + return; /* overflow detected. ok. */ + t2 = mktime(tm); + if (t1 == t2) + return; /* round-trip. ok. */ + exit(1); +} + +int +main() +{ + time_t t; + if (~(time_t)0 <= 0) { + t = (((time_t)1) << (sizeof(time_t) * 8 - 2)); + t |= t - 1; + } + else { + t = ~(time_t)0; + } + check(t); + return 0; +} +]])], + rb_cv_localtime_overflow=yes, + rb_cv_localtime_overflow=no, + rb_cv_localtime_overflow=no)]) +AS_IF([test "$rb_cv_localtime_overflow" = no], [ + AC_DEFINE(LOCALTIME_OVERFLOW_PROBLEM) +]) + +AS_IF([test "$ac_cv_func_sigprocmask" = yes && test "$ac_cv_func_sigaction" = yes], [ + AC_DEFINE(POSIX_SIGNAL) +], [ + AC_CHECK_FUNCS(sigsetmask) + AC_CACHE_CHECK(for BSD signal semantics, rb_cv_bsd_signal, + [AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include <stdio.h> +#include <signal.h> + +void +sig_handler(int dummy) +{ +} + +int +main() +{ + signal(SIGINT, sig_handler); + kill(getpid(), SIGINT); + kill(getpid(), SIGINT); + return 0; +} +]])], + rb_cv_bsd_signal=yes, + rb_cv_bsd_signal=no, + rb_cv_bsd_signal=$ac_cv_func_sigsetmask)]) + AS_IF([test "$rb_cv_bsd_signal" = yes], [ + AC_DEFINE(BSD_SIGNAL) + ]) +]) + +AC_CHECK_TYPES([sig_t],[],[],[@%:@include <signal.h>]) + +AS_IF([test "$ac_cv_func_getpgid" = no], [ + # AC_FUNC_GETPGRP fails when cross-compiling with old autoconf. + # autoconf is changed between 2.52d and 2.52f? + # https://lists.gnu.org/archive/html/bug-gnu-utils/2001-09/msg00181.html + # "autoconf cleanup for AC_FUNC_GETPGRP and GETPGRP_VOID" +AC_FUNC_GETPGRP +]) +AS_IF([test "$ac_cv_func_setpgid:$ac_cv_func_setpgrp" = no:yes], [ + # AC_FUNC_SETPGRP fails when cross-compiling. (until autoconf 2.69?) + # https://lists.gnu.org/archive/html/bug-autoconf/2013-02/msg00002.html + # "AC_FUNC_SETPGRP fails to work properly when cross-compiling" +AC_FUNC_SETPGRP +]) + +AS_IF([test x"$ac_cv_func_dirfd" = xno], [ + AS_CASE(["$target_os"],[solaris*], + [AC_CHECK_MEMBERS([DIR.d_fd, DIR.dd_fd],,,[ +#include <sys/types.h> +#include <dirent.h> +])]) +]) + +AC_CACHE_CHECK(whether right shift preserve sign bit, rb_cv_rshift_sign, + [AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([], [(-1==(-1>>1))])], + rb_cv_rshift_sign=yes, + rb_cv_rshift_sign=no)]) +AS_IF([test "$rb_cv_rshift_sign" = yes], [ + AC_DEFINE(RSHIFT(x,y), ((x)>>(int)(y))) +], [ + AC_DEFINE(RSHIFT(x,y), (((x)<0) ? ~((~(x))>>(int)(y)) : (x)>>(int)(y))) +]) + +AS_IF([test "$ac_cv_func_copy_file_range" = no], [ + AC_CACHE_CHECK([for copy_file_range], + rb_cv_use_copy_file_range, + [AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/syscall.h> +#include <fcntl.h> +#include <unistd.h> + +#ifndef O_TMPFILE + #define O_TMPFILE __O_TMPFILE +#endif + +int +main() +{ +#ifdef __NR_copy_file_range + int ret, fd_in, fd_out; + fd_in = open("/tmp", O_TMPFILE|O_RDWR, S_IRUSR); + fd_out = open("/tmp", O_TMPFILE|O_WRONLY, S_IWUSR); + ret = syscall(__NR_copy_file_range, fd_in, NULL, fd_out, NULL, 0, 0); + close(fd_in); + close(fd_out); + if (ret == -1) { return 1; } + return 0; +#else + return 1; +#endif +} + ]])], + [rb_cv_use_copy_file_range=yes], + [rb_cv_use_copy_file_range=no], + [rb_cv_use_copy_file_range=no])]) +]) +AS_CASE(["$ac_cv_func_copy_file_range:$rb_cv_use_copy_file_range"], [*yes*], [ + AC_DEFINE(USE_COPY_FILE_RANGE) +]) + +AS_CASE(["$ac_cv_func_gettimeofday:$ac_cv_func_clock_gettime"], +[*yes*], [], +[ + AC_MSG_ERROR(clock_gettime() or gettimeofday() must exist) +]) + +AS_IF([test "$ac_cv_func_sysconf" = yes], [ + RUBY_CHECK_SYSCONF(CLK_TCK) +]) + +AS_IF([test "${universal_binary-no}" = yes ], [ + archflagpat=`eval echo '"'"${ARCH_FLAG}"'"' | sed 's/[[][|.*]]/\\&/g'` + save_CFLAGS="$CFLAGS" new_cflags=`echo "$CFLAGS" | sed "s|$archflagpat"'||'` + save_LDFLAGS="$LDFLAGS" new_ldflags=`echo "$LDFLAGS" | sed "s|$archflagpat"'||'` + stack_dir= + for archs in ${universal_archnames}; do + archs=`echo $archs | sed 's/=.*//'` + CFLAGS="$new_cflags -arch $archs" + LDFLAGS="$new_ldflags -arch $archs" + RUBY_STACK_GROW_DIRECTION($archs, dir) + AS_IF([test x$stack_dir = x], [ + stack_dir=$dir + ], [test x$stack_dir != x$dir], [ + stack_dir=no + ]) + done + CFLAGS="$save_CFLAGS" LDFLAGS="$save_LDFLAGS" + AS_IF([test x$stack_dir = xno], [ + for archs in ${universal_archnames}; do + archs=`echo $archs | sed 's/=.*//'` + eval dir=\$[rb_cv_stack_grow_dir_]AS_TR_SH([$archs]) + RUBY_DEFINE_IF([defined __${archs}__], STACK_GROW_DIRECTION, $dir) + done + ], [ + AC_DEFINE_UNQUOTED(STACK_GROW_DIRECTION, $stack_dir) + ]) +], [ + RUBY_STACK_GROW_DIRECTION($target_cpu, dir) + AC_DEFINE_UNQUOTED(STACK_GROW_DIRECTION, $dir) +]) + +AC_ARG_WITH(coroutine, + AS_HELP_STRING([--with-coroutine=IMPLEMENTATION], [specify the coroutine implementation to use]), + [coroutine_type=$withval], [coroutine_type=]) +AS_CASE([$coroutine_type], [yes|''], [ + coroutine_type= + AS_CASE(["$target_cpu-$target_os"], + [universal-darwin*], [ + coroutine_type=universal + ], + [x*64-darwin*], [ + coroutine_type=amd64 + ], + [arm64-darwin*], [ + coroutine_type=arm64 + ], + # Correct target name is powerpc*-, but Ruby seems to prefer ppc*-. + # Notice that Darwin PPC ABI differs from AIX and ELF. + # Adding PPC targets for AIX, *BSD and *Linux will require separate implementations. + [powerpc-darwin*|ppc-darwin*], [ + coroutine_type=ppc + ], + [powerpc64-darwin*|ppc64-darwin*], [ + coroutine_type=ppc64 + ], + [x*64-linux*], [ + AS_CASE(["$ac_cv_sizeof_voidp"], + [8], [ coroutine_type=amd64 ], + [4], [ coroutine_type=x86 ], + dnl unknown pointer size, bail out as no Context.h soon. + ) + ], + [*86-linux*], [ + coroutine_type=x86 + ], + [x64-mingw*], [ + coroutine_type=win64 + ], + [*86-mingw*], [ + coroutine_type=win32 + ], + [aarch64-mingw*], [ + coroutine_type=arm64 + ], + [arm*-linux*], [ + coroutine_type=arm32 + ], + [aarch64-linux*], [ + coroutine_type=arm64 + ], + [powerpc64le-linux*], [ + coroutine_type=ppc64le + ], + [riscv64-linux*], [ + coroutine_type=riscv64 + ], + [loongarch64-linux*], [ + coroutine_type=loongarch64 + ], + [x86_64-freebsd*], [ + coroutine_type=amd64 + ], + [i386-freebsd*], [ + coroutine_type=x86 + ], + [aarch64-freebsd*], [ + coroutine_type=arm64 + ], + [powerpc64-freebsd*], [ + coroutine_type=ppc64le + ], + [powerpc64le-freebsd*], [ + coroutine_type=ppc64le + ], + [x86_64-netbsd*], [ + coroutine_type=amd64 + ], + [i386-netbsd*], [ + coroutine_type=x86 + ], + [aarch64-netbsd*], [ + coroutine_type=arm64 + ], + [x86_64-openbsd*], [ + coroutine_type=amd64 + ], + [i386-openbsd*], [ + coroutine_type=x86 + ], + [aarch64-openbsd*], [ + coroutine_type=arm64 + ], + [riscv64-openbsd*], [ + coroutine_type=riscv64 + ], + [*-openbsd*], [ + coroutine_type=pthread + ], + [x86_64-dragonfly*], [ + coroutine_type=amd64 + ], + [*-haiku*], [ + coroutine_type=pthread + ], + [*-emscripten*], [ + coroutine_type=emscripten + ], + [*-wasi*], [ + coroutine_type=asyncify + ], + [ + AC_CHECK_FUNCS([getcontext swapcontext makecontext], + [coroutine_type=ucontext], + [coroutine_type=pthread; break] + ) + ] + ) + AC_MSG_CHECKING(native coroutine implementation for ${target_cpu}-${target_os}) + AC_MSG_RESULT(${coroutine_type}) +]) +COROUTINE_H=coroutine/$coroutine_type/Context.h +AS_IF([test ! -f "$srcdir/$COROUTINE_H"], + [AC_MSG_ERROR('$coroutine_type' is not supported as coroutine)]) +COROUTINE_SRC=coroutine/$coroutine_type/Context.c +AS_IF([test ! -f "$srcdir/$COROUTINE_SRC"], + [COROUTINE_SRC=coroutine/$coroutine_type/Context.'$(ASMEXT)']) +AC_DEFINE_UNQUOTED(COROUTINE_H, ["$COROUTINE_H"]) +AC_SUBST(X_COROUTINE_H, [$COROUTINE_H]) +AC_SUBST(X_COROUTINE_SRC, [$COROUTINE_SRC]) + +AS_IF([test "$THREAD_MODEL" = pthread], [ + AC_CACHE_CHECK([whether pthread_t is scalar type], [rb_cv_scalar_pthread_t], [ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + @%:@include <pthread.h> + ]], [[ + pthread_t thread_id; + thread_id = 0; + if (!thread_id) return 0; + ]])],[rb_cv_scalar_pthread_t=yes],[rb_cv_scalar_pthread_t=no]) + ]) + AS_IF([test x"$rb_cv_scalar_pthread_t" = xyes], [ + : # RUBY_CHECK_SIZEOF(pthread_t, [void* int long], [], [@%:@include <pthread.h>]) + ], [ + AC_DEFINE(NON_SCALAR_THREAD_ID) + ]) + AC_CHECK_FUNCS(sched_yield pthread_attr_setinheritsched \ + pthread_attr_get_np pthread_attr_getstack pthread_attr_getguardsize \ + pthread_get_stackaddr_np pthread_get_stacksize_np \ + thr_stksegment pthread_stackseg_np pthread_getthrds_np \ + pthread_condattr_setclock \ + pthread_setname_np pthread_set_name_np) + AS_CASE(["$target_os"],[emscripten*],[ac_cv_func_pthread_sigmask=no],[AC_CHECK_FUNCS(pthread_sigmask)]) + AS_CASE(["$target_os"],[aix*],[ac_cv_func_pthread_getattr_np=no],[AC_CHECK_FUNCS(pthread_getattr_np)]) + set_current_thread_name= + AS_IF([test "$ac_cv_func_pthread_setname_np" = yes], [ + AC_CACHE_CHECK([arguments of pthread_setname_np], [rb_cv_func_pthread_setname_np_arguments], + [rb_cv_func_pthread_setname_np_arguments= + # Linux,AIX, (pthread_self(), name) + # NetBSD (pthread_self(), \"%s\", name) + # Darwin (name) + for mac in \ + "(pthread_self(), name)" \ + "(pthread_self(), \"%s\", name)" \ + "(name)" \ + ; do + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + @%:@include <pthread.h> + @%:@ifdef HAVE_PTHREAD_NP_H + @%:@include <pthread_np.h> + @%:@endif + @%:@define SET_THREAD_NAME(name) pthread_setname_np${mac} + ]], + [[if (SET_THREAD_NAME("conftest")) return 1;]])], + [rb_cv_func_pthread_setname_np_arguments="${mac}" + break]) + done + ] + ) + AS_IF([test -n "${rb_cv_func_pthread_setname_np_arguments}"], [ + set_current_thread_name="pthread_setname_np${rb_cv_func_pthread_setname_np_arguments}" + ]) + ], [test "$ac_cv_func_pthread_set_name_np" = yes], [ + set_current_thread_name="pthread_set_name_np(pthread_self(), name)" + ]) + AS_IF([test -n "$set_current_thread_name"], [ + AC_DEFINE_UNQUOTED(SET_CURRENT_THREAD_NAME(name), $set_current_thread_name) + AS_CASE([$set_current_thread_name], + [*'pthread_self()'*], [ + set_another_thread_name=`echo "$set_current_thread_name" | sed 's/pthread_self()/thid/'` + AC_DEFINE_UNQUOTED(SET_ANOTHER_THREAD_NAME(thid,name), $set_another_thread_name) + ]) + ]) + + AC_CACHE_CHECK([for thread-local storage specifier], [rb_cv_tls_specifier], + rb_cv_tls_specifier=none + RUBY_WERROR_FLAG([ + for attr in \ + _Thread_local \ + __thread \ + ; do + AC_LINK_IFELSE([AC_LANG_PROGRAM([[$attr int conftest;]])], + [rb_cv_tls_specifier=$attr; break]) + done + ]) + ) + AS_IF([test x"${rb_cv_tls_specifier}" != xnone], + [AC_DEFINE_UNQUOTED(RB_THREAD_LOCAL_SPECIFIER, ${rb_cv_tls_specifier})] + ) +]) + +AS_IF([test x"$ac_cv_header_ucontext_h" = xno], [ + AC_CACHE_CHECK([if signal.h defines ucontext_t], [rb_cv_ucontext_in_signal_h], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <signal.h>]], + [[size_t size = sizeof(ucontext_t);]])], + [rb_cv_ucontext_in_signal_h=yes], [rb_cv_ucontext_in_signal_h=no])]) + AS_IF([test x"$rb_cv_ucontext_in_signal_h" = xyes], [ + AC_DEFINE_UNQUOTED(UCONTEXT_IN_SIGNAL_H, 1) + ]) +]) +AS_IF([test x"$ac_cv_header_ucontext_h" = xyes -o x"$rb_cv_ucontext_in_signal_h" = xyes], [ + AC_CACHE_CHECK([if mcontext_t is a pointer], [rb_cv_mcontext_t_ptr], + [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + @%:@include <signal.h> + @%:@ifdef HAVE_UCONTEXT_H + @%:@include <ucontext.h> + @%:@endif + mcontext_t test(mcontext_t mc) {return mc+1;} + ]], + [[test(0);]])], + [rb_cv_mcontext_t_ptr=yes], [rb_cv_mcontext_t_ptr=no])]) + AS_IF([test x"$rb_cv_mcontext_t_ptr" = xyes], [ + AC_DEFINE_UNQUOTED(DEFINE_MCONTEXT_PTR(mc, uc), mcontext_t mc = (uc)->uc_mcontext) + ], [ + AC_DEFINE_UNQUOTED(DEFINE_MCONTEXT_PTR(mc, uc), mcontext_t *mc = &(uc)->uc_mcontext) + ]) + AS_IF([test x"$THREAD_MODEL" = xpthread], [ + AC_CHECK_FUNCS(getcontext setcontext) + ]) +]) + +AS_IF([test "$ac_cv_func_fork_works" = "yes" -a x"$THREAD_MODEL" = xpthread], [ + AC_CACHE_CHECK([if fork works with pthread], rb_cv_fork_with_pthread, + [AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include <stdlib.h> +#include <unistd.h> +#include <pthread.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <signal.h> +#ifndef EXIT_SUCCESS +#define EXIT_SUCCESS 0 +#endif +#ifndef EXIT_FAILURE +#define EXIT_FAILURE 1 +#endif + +void * +thread_func(void *dmy) +{ + return dmy; +} + +int +use_threads(void) +{ + pthread_t tid; + if (pthread_create(&tid, 0, thread_func, 0) != 0) { + return -1; + } + if (pthread_join(tid, 0) != 0) { + return -1; + } + return 0; +} + +int +main(int argc, char *argv[]) +{ + pid_t pid; + if (use_threads()) return EXIT_FAILURE; + pid = fork(); + + if (pid) { + int loc; + sleep(1); + if (waitpid(pid, &loc, WNOHANG) == 0) { + kill(pid, SIGKILL); + return EXIT_FAILURE; + } + if (!WIFEXITED(loc) || WEXITSTATUS(loc) != EXIT_SUCCESS) + return EXIT_FAILURE; + } + else { + if (use_threads()) return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +}]])], + rb_cv_fork_with_pthread=yes, + rb_cv_fork_with_pthread=no, + rb_cv_fork_with_pthread=yes)]) + test x$rb_cv_fork_with_pthread = xyes || AC_DEFINE(CANNOT_FORK_WITH_PTHREAD) +]) + +AC_CHECK_HEADERS([sys/user.h]) +AS_IF([test "x$ac_cv_func_mmap" = xyes], [ + AC_CACHE_CHECK([whether PAGE_SIZE is compile-time const], rb_cv_const_page_size, + [malloc_headers=`sed -n '/MALLOC_HEADERS_BEGIN/,/MALLOC_HEADERS_END/p' ${srcdir}/gc.c` + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[$malloc_headers + typedef char conftest_page[PAGE_SIZE]; + ]], [[]])], + [rb_cv_const_page_size=yes], + [rb_cv_const_page_size=no])]) +]) +AS_IF([test "x$rb_cv_const_page_size" = xyes], + [AC_DEFINE(HAVE_CONST_PAGE_SIZE, 1)], + [AC_DEFINE(HAVE_CONST_PAGE_SIZE, 0)] +) + +AS_IF([test "x$ac_cv_func_ioctl" = xyes], [ + AC_CACHE_CHECK([ioctl request type], rb_cv_ioctl_request_type, + [rb_cv_ioctl_request_type=no + dnl corresponding NUM2IOCTLREQ needs to be defined + for type in "unsigned long:ULONG_MAX" int:INT_MAX; do + max=`echo $type | sed 's/.*://'` + type=`echo $type | sed 's/:.*//'` + RUBY_WERROR_FLAG([ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[ + @%:@include <limits.h> + @%:@include <sys/types.h> + @%:@if defined(HAVE_SYS_IOCTL_H) && !defined(_WIN32) + @%:@include <sys/ioctl.h> + @%:@endif + ]], [[ + $type req = $max; + if (ioctl(0, req)) {/* do nothing*/}; + ]])], + [rb_cv_ioctl_request_type="$type"]) + ]) + test "x$rb_cv_ioctl_request_type" = xno || break + done]) + AS_CASE(["$rb_cv_ioctl_request_type"], [no|int], [], + ["unsigned long"], [ + AC_DEFINE_UNQUOTED(IOCTL_REQ_TYPE, [$rb_cv_ioctl_request_type]) + AC_DEFINE_UNQUOTED(NUM2IOCTLREQ(num), [NUM2ULONG(num)]) + ]) +]) + +} + +[begin]_group "runtime section" && { +dnl whether use dln_a_out or not +AC_ARG_WITH(dln-a-out, + AS_HELP_STRING([--with-dln-a-out], [dln_a_out is deprecated]), + [ + AS_CASE([$withval], + [yes], [ + AC_MSG_ERROR(dln_a_out no longer supported) + ]) +]) + +AS_IF([test "$rb_cv_binary_elf" = yes], [ + AC_DEFINE(USE_ELF) + AC_CHECK_HEADERS([elf.h elf_abi.h]) + AS_IF([test $ac_cv_header_elf_h = yes -o $ac_cv_header_elf_abi_h = yes], [ + AC_LIBOBJ([addr2line]) + AC_CHECK_LIB([z], [uncompress]) + ]) +]) + +AC_CHECK_HEADERS([mach-o/loader.h]) +AS_IF([test "$ac_cv_header_mach_o_loader_h" = yes], [ + AC_LIBOBJ([addr2line]) +]) + +AS_CASE(["$target_os"], +[linux* | gnu* | k*bsd*-gnu | bsdi* | kopensolaris*-gnu], [ + AS_IF([test "$rb_cv_binary_elf" = no], [ + AC_MSG_ERROR(Not ELF) + ], [ + LDFLAGS="$LDFLAGS -rdynamic" + ])]) +LIBEXT=a + +AC_SUBST(DLDFLAGS)dnl +AC_SUBST(ARCH_FLAG)dnl + +AC_SUBST(STATIC)dnl +AC_SUBST(CCDLFLAGS)dnl +AC_SUBST(LDSHARED)dnl +AC_SUBST(LDSHAREDXX)dnl +AC_SUBST(DLEXT)dnl +AC_SUBST(LIBEXT)dnl +AC_SUBST(ASMEXT, S)dnl + +STATIC= + +: "dlopen" && { + rb_cv_dlopen=unknown + AC_MSG_CHECKING(whether OS depend dynamic link works) + AS_IF([test "$GCC" = yes], [ + AS_CASE(["$target_os"], + [darwin*], [ + # The -fno-common is needed if we wish to embed the Ruby interpreter + # into a plugin module of some project (as opposed to embedding it + # within the project's application). The -I/usr/local/include is + # needed because CPP as discovered by configure (cc -E -traditional) + # fails to consult /usr/local/include by default. This causes + # mkmf.rb's have_header() to fail if the desired resource happens to be + # installed in the /usr/local tree. + RUBY_APPEND_OPTION(CCDLFLAGS, -fno-common)], + [bsdi*|cygwin*|msys*|mingw*|aix*|interix*], [ ], + [ + RUBY_APPEND_OPTION(CCDLFLAGS, -fPIC)]) + ], [ + AS_CASE(["$target_os"], + [solaris*|irix*], [CCDLFLAGS="$CCDLFLAGS -KPIC"], + [sunos*], [CCDLFLAGS="$CCDLFLAGS -PIC"], + [esix*|uxpds*], [CCDLFLAGS="$CCDLFLAGS -KPIC"], + [: ${CCDLFLAGS=""}]) + ]) +} + +EXTSTATIC= +AC_SUBST(EXTSTATIC)dnl +AC_ARG_WITH(static-linked-ext, + AS_HELP_STRING([--with-static-linked-ext], [link external modules statically]), + [AS_CASE([$withval],[yes],[STATIC=;EXTSTATIC=static],[no],[],[EXTSTATIC="$withval"])]) +AS_CASE([",$EXTSTATIC,"], [,static,|*,enc,*], [ + ENCOBJS='enc/encinit.$(OBJEXT) enc/libenc.$(LIBEXT) enc/libtrans.$(LIBEXT)' + EXTOBJS='ext/extinit.$(OBJEXT)' + AC_DEFINE_UNQUOTED(EXTSTATIC, 1) + AC_SUBST(ENCSTATIC, static) +], [ + ENCOBJS='dmyenc.$(OBJEXT)' + EXTOBJS='dmyext.$(OBJEXT)' +]) +AC_SUBST(ENCOBJS) +AC_SUBST(EXTOBJS) + +: "rpath" && { + AS_CASE(["$target_os"], + [solaris*], [ AS_IF([test "$GCC" = yes], [ + : ${LDSHARED='$(CC) -shared'} + AS_IF([test "$rb_cv_prog_gnu_ld" = yes], [ + LDFLAGS="$LDFLAGS -Wl,-E" + ]) + ], [ + : ${LDSHARED='$(CC) -G'} + ]) + AS_IF([test "$ac_cv_sizeof_voidp" = 8], [ + : ${LIBPATHENV=LD_LIBRARY_PATH_64} + : ${PRELOADENV=LD_PRELOAD_64} + ], [ + : ${LIBPATHENV=LD_LIBRARY_PATH_32} + : ${PRELOADENV=LD_PRELOAD_32} + ]) + rb_cv_dlopen=yes], + [sunos*], [ : ${LDSHARED='$(LD) -assert nodefinitions'} + rb_cv_dlopen=yes], + [irix*], [ : ${LDSHARED='$(LD) -shared'} + rb_cv_dlopen=yes], + [sysv4*], [ : ${LDSHARED='$(LD) -G'} + rb_cv_dlopen=yes], + [nto-qnx*], [ : ${LDSHARED='$(CC) -shared'} + rb_cv_dlopen=yes], + [esix*|uxpds*], [ : ${LDSHARED='$(LD) -G'} + rb_cv_dlopen=yes], + [osf*], [ : ${LDSHARED='$(LD) -shared -expect_unresolved "*"'} + rb_cv_dlopen=yes], + [bsdi3*], [ AS_CASE(["$CC"], + [*shlicc*], [ : ${LDSHARED='$(CC) -r'} + rb_cv_dlopen=yes])], + [linux* | gnu* | k*bsd*-gnu | netbsd* | bsdi* | kopensolaris*-gnu | haiku*], [ + : ${LDSHARED='$(CC) -shared'} + AS_IF([test "$rb_cv_binary_elf" = yes], [ + LDFLAGS="$LDFLAGS -Wl,-export-dynamic" + ]) + rb_cv_dlopen=yes], + [interix*], [ : ${LDSHARED='$(CC) -shared'} + XLDFLAGS="$XLDFLAGS -Wl,-E" + rb_cv_dlopen=yes], + [freebsd*|dragonfly*], [ + : ${LDSHARED='$(CC) -shared'} + AS_IF([test "$rb_cv_binary_elf" = yes], [ + LDFLAGS="$LDFLAGS -rdynamic" + DLDFLAGS="$DLDFLAGS "'-Wl,-soname,$@' + ], [ + test "$GCC" = yes && test "$rb_cv_prog_gnu_ld" = yes || LDSHARED='$(LD) -Bshareable' + ]) + rb_cv_dlopen=yes], + [openbsd*|mirbsd*], [ : ${LDSHARED='$(CC) -shared ${CCDLFLAGS}'} + AS_IF([test "$rb_cv_binary_elf" = yes], [ + LDFLAGS="$LDFLAGS -Wl,-E" + ]) + rb_cv_dlopen=yes], + [darwin*], [ : ${LDSHARED='$(CC) -dynamic -bundle'} + : ${DLDSHARED='$(CC) -dynamiclib'} + : ${LDFLAGS=""} + : ${LIBPATHENV=DYLD_LIBRARY_PATH} + : ${PRELOADENV=DYLD_INSERT_LIBRARIES} + AS_IF([test x"$enable_shared" = xyes], [ + # Resolve symbols from libruby.dylib in $(LIBS) when --enable-shared + ], [test "x$EXTSTATIC" = x], [ + # When building exts as bundles, a mach-o bundle needs to know its loader + # program to bind symbols from the ruby executable + EXTDLDFLAGS="-bundle_loader '\$(BUILTRUBY)'" + ]) + rb_cv_dlopen=yes], + [aix*], [ : ${LDSHARED='$(CC)'} + AS_IF([test "$GCC" = yes], [ + LDSHARED="$LDSHARED ${linker_flag}-G -shared" + ], [ + LDSHARED="$LDSHARED ${linker_flag}-G" + ]) + EXTDLDFLAGS='-e$(TARGET_ENTRY)' + XLDFLAGS="${linker_flag}"'-bE:$(ARCHFILE)'" ${linker_flag}-brtl" + XLDFLAGS="$XLDFLAGS ${linker_flag}-blibpath:${prefix}/lib:${LIBPATH:-/usr/lib:/lib}" + : ${ARCHFILE="ruby.imp"} + TRY_LINK='$(CC) -oconftest $(INCFLAGS) -I$(hdrdir) $(CPPFLAGS)' + TRY_LINK="$TRY_LINK"' $(CFLAGS) $(src) $(LIBPATH) $(LDFLAGS) $(LOCAL_LIBS) $(LIBS)' + : ${LIBPATHENV=LIBPATH} + : ${PRELOADENV=LDR_PRELOAD} + rb_cv_dlopen=yes], + [nto-qnx*], [ DLDFLAGS="$DLDFLAGS -L/lib -L/usr/lib -L/usr/local/lib" + : ${LDSHARED='$(LD) -Bshareable -x'} + LDFLAGS="$LDFLAGS -L/lib -L/usr/lib -L/usr/local/lib" + rb_cv_dlopen=yes], + [cygwin*|msys*|mingw*], [ + : ${LDSHARED='$(CC) -shared'} + XLDFLAGS="$XLDFLAGS -Wl,--stack,0x00200000,--enable-auto-import" + DLDFLAGS="${DLDFLAGS} -Wl,--enable-auto-image-base,--enable-auto-import" + : ${LIBPATHENV=PATH} + : ${PRELOADENV=""} + rb_cv_dlopen=yes], + [hiuxmpp], [ : ${LDSHARED='$(LD) -r'}], + [atheos*], [ : ${LDSHARED='$(CC) -shared'} + rb_cv_dlopen=yes], + [wasi*], [ : ${LDSHARED='$(LD) -shared -Xlinker --export-dynamic'}], + [ : ${LDSHARED='$(LD)'}]) + AC_MSG_RESULT($rb_cv_dlopen) +} + +AS_IF([test "$rb_cv_dlopen" = yes], [ + AS_CASE(["$target_os"], + [darwin*], [ + AC_SUBST(ADDITIONAL_DLDFLAGS, "") + for flag in \ + "-multiply_defined suppress" \ + "-undefined dynamic_lookup" \ + ; do + test "x${linker_flag}" = x || flag="${linker_flag}`echo ${flag} | tr ' ' ,`" + RUBY_TRY_LDFLAGS([$flag], [], [flag=]) + AS_IF([test x"$flag" = x], [continue]) + + AC_MSG_CHECKING([whether $flag is accepted for bundle]) + : > conftest.c + AS_IF([${LDSHARED%%'$(CC)'*}$CC${LDSHARED@%:@*'$(CC)'} -o conftest.bundle $flag conftest.c >/dev/null 2>conftest.err && + test ! -s conftest.err], [ + AC_MSG_RESULT([yes]) + RUBY_APPEND_OPTIONS(DLDFLAGS, [$flag]) + ], [ + AC_MSG_RESULT([no]) + RUBY_APPEND_OPTIONS(ADDITIONAL_DLDFLAGS, [$flag]) + ]) + rm -fr conftest.* + done + ]) +]) + +AS_IF([test "${LDSHAREDXX}" = ""], [ + AS_CASE(["${LDSHARED}"], + [*'$(CC)'*], [ + LDSHAREDXX=`echo "${LDSHARED}" | sed 's/\$(CC)/$(CXX)/'` + ], + [*'${CC}'*], [ + LDSHAREDXX=`echo "${LDSHARED}" | sed 's/\${CC}/${CXX}/'` + ], + [*$CC*], [ + LDSHAREDXX=`echo "${LDSHARED}" | sed "s|$CC|$CXX|"` + ], + [ld" "*], [ + ]) +]) + +AC_SUBST(LINK_SO) +AC_SUBST(LIBPATHFLAG) +AC_SUBST(RPATHFLAG) +AC_SUBST(LIBPATHENV, "${LIBPATHENV-LD_LIBRARY_PATH}") +AC_SUBST(PRELOADENV, "${PRELOADENV-LD_PRELOAD}") +AC_SUBST(TRY_LINK) + +AS_CASE(["$target_os"], +[freebsd*], [ + AC_CHECK_LIB([procstat], [procstat_open_sysctl]) + AS_IF([test "x$ac_cv_lib_procstat_procstat_open_sysctl" = xyes], [ + AC_CHECK_FUNCS(procstat_getvmmap) + ]) + ]) +AS_CASE(["$target_cpu-$target_os"], +[*-darwin*], [ + AC_CHECK_HEADERS([libproc.h]) + AC_CHECK_HEADERS([execinfo.h]) + AS_IF([test "x$ac_cv_header_execinfo_h" = xyes], [ + AC_CHECK_LIB([execinfo], [backtrace]) + AC_CHECK_HEADERS([libunwind.h]) + + AC_CHECK_HEADERS([mach/task.h mach/mach_init.h mach/mach_port.h]) + AS_IF([ test \ + "x${ac_cv_header_mach_task_h}" = xyes -a \ + "x${ac_cv_header_mach_mach_init_h}" = xyes -a \ + "x${ac_cv_header_mach_mach_port_h}" = xyes \ + ], [ + AC_DEFINE([HAVE_MACH_TASK_EXCEPTION_PORTS], [1]) + ]) + ])], +[*-freebsd*|x86_64-netbsd*], [ + AC_CHECK_HEADERS([execinfo.h]) + AS_IF([test "x$ac_cv_header_execinfo_h" = xyes], [ + AC_CHECK_LIB([execinfo], [backtrace]) + AC_CHECK_LIB([unwind], [unw_backtrace]) + ])]) +AC_CHECK_FUNCS(backtrace) + +AS_IF([test "x$ac_cv_func_backtrace" = xyes], [ + AC_CACHE_CHECK(for broken backtrace, rb_cv_broken_backtrace, + [AC_RUN_IFELSE([AC_LANG_SOURCE([[ +#include <unistd.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdint.h> +#include <string.h> +#include <signal.h> +#include <execinfo.h> + +]`grep '^@%:@ *define *RUBY_SIGALTSTACK_SIZE' ${srcdir}/signal.c`[ +#define TRACE_SIZE 256 + +void sigsegv(int signum, siginfo_t *info, void *ctx){ + void *trace[TRACE_SIZE]; + int n = backtrace(trace, TRACE_SIZE); + if (n > 0) { + /*fprintf(stdout, "backtrace:%d\n",n);*/ + } else { + _exit(EXIT_FAILURE); + } + _exit(EXIT_SUCCESS); +} +int +main(void) +{ + volatile int *a = NULL; + stack_t ss; + struct sigaction sa; + + ss.ss_sp = malloc(RUBY_SIGALTSTACK_SIZE); + if (ss.ss_sp == NULL) { + fprintf(stderr, "cannot allocate memory for sigaltstack\n"); + return EXIT_FAILURE; + } + ss.ss_size = RUBY_SIGALTSTACK_SIZE; + ss.ss_flags = 0; + if (sigaltstack(&ss, NULL) == -1) { + fprintf(stderr, "sigaltstack failed\n"); + return EXIT_FAILURE; + } + memset(&sa, 0, sizeof(struct sigaction)); + sigemptyset(&sa.sa_mask); + sa.sa_sigaction = sigsegv; + sa.sa_flags |= SA_SIGINFO; + sa.sa_flags |= SA_ONSTACK; + sigaction(SIGSEGV, &sa, NULL); + a[0] = 1; + return EXIT_SUCCESS; +} +]])], + rb_cv_broken_backtrace=no, + rb_cv_broken_backtrace=yes, + rb_cv_broken_backtrace=no)]) + AS_IF([test "$rb_cv_broken_backtrace" = yes], [ + AC_DEFINE(BROKEN_BACKTRACE, 1) + ]) +]) + +AC_ARG_WITH(valgrind, + AS_HELP_STRING([--without-valgrind],[disable valgrind memcheck support]), + [], with_valgrind=yes) +AS_IF([test x$with_valgrind != xno], + [AC_CHECK_HEADERS(valgrind/memcheck.h)]) + +: "dlext & soext" && { + AS_CASE(["$target_os"], + [darwin*], [ + SOEXT=dylib + DLEXT=bundle], + [cygwin*|msys*|mingw*|*djgpp*], [ + LOAD_RELATIVE=1 + SOEXT=dll + DLEXT=so], + [ + DLEXT=so]) +: ${SOEXT="${DLEXT}"} +AC_SUBST(SOEXT) + +AS_IF([test "$rb_cv_dlopen:$load_relative" = yes:yes], [ + AS_IF([test "$ac_cv_func_dladdr" = yes], [ + LOAD_RELATIVE=1 + ]) +]) +AS_IF([test x"$LOAD_RELATIVE" = x1], [ + load_relative=yes +], [ + unset load_relative +]) + +len=2 # .rb +n=`expr "$DLEXT" : '.*'`; test "$n" -gt "$len" && len=$n +AC_DEFINE_UNQUOTED(DLEXT_MAXLEN, `expr $len + 1`) +test ".$DLEXT" = "." || AC_DEFINE_UNQUOTED(DLEXT, ".$DLEXT") +AC_SUBST(DLEXT) + +AC_DEFINE_UNQUOTED(SOEXT, ".$SOEXT") +} + +: "strip" && { + AC_MSG_CHECKING([for $STRIP flags]) + AC_LINK_IFELSE([AC_LANG_PROGRAM], [AS_IF( + ["${STRIP}" -A -n conftest$ac_exeext 2>/dev/null], [ + AC_MSG_RESULT([-A -n]) + STRIP="${STRIP} -A -n" + ], + ["${STRIP}" -S -x conftest$ac_exeext 2>/dev/null], [ + AC_MSG_RESULT([-S -x]) + STRIP="${STRIP} -S -x" + ], [ + AC_MSG_RESULT([none needed]) + ]) + ]) +} + +AC_ARG_WITH(ext, + AS_HELP_STRING([--with-ext=EXTS], + [pass to --with-ext option of extmk.rb])) +AC_ARG_WITH(out-ext, + AS_HELP_STRING([--with-out-ext=EXTS], + [pass to --without-ext option of extmk.rb])) +AC_ARG_WITH(setup, + AS_HELP_STRING([--with-setup=SETUP], [use extension libraries setup]), + [setup=$withval]) +AS_IF([test -n "$setup"], [ + AS_IF([! test -f "ext/$setup" -o -f "$srcdir/ext/$setup"], [ + AC_MSG_ERROR(Setup file $setup not found under ext or $srcdir/ext) + ]) +], [test -f "$srcdir/ext/Setup.$target_os"], [ + setup="Setup.$target_os" +], [ + setup= + for file in "$srcdir"/ext/Setup.*; do + AS_CASE(["$file"], [*~|*.bak|*.orig|*.rej|*.tmp], [continue]) + setup=`basename "$file"` + AS_CASE(["$target_os"], [`expr "$setup" : 'Setup.\(.*\)'`*], [break]) + platform=`sed '/^option *platform */!d;s///;s/|/*|/g;q' "$file"` + AS_IF([test "x$platform" != x], [ + eval "AS_CASE([\"\$target_os\"], [$platform*], [break])" + ]) + setup= + done + : ${setup:=Setup} +]) +AC_SUBST(setup) + +rubylibprefix='${libdir}/${RUBY_BASE_NAME}' +AC_ARG_WITH(rubylibprefix, + AS_HELP_STRING([--with-rubylibprefix=DIR], [prefix for ruby libraries [[LIBDIR/RUBY_BASE_NAME]]]), + [AS_IF([test "x$withval" = xno], [ + AC_MSG_ERROR([No ruby, No libprefix]) + ]) + rubylibprefix="$withval"]) +AC_SUBST(rubylibprefix) + +AS_IF([test x"${exec_prefix}" != xNONE], [ + RUBY_EXEC_PREFIX="$exec_prefix" +], [test x"$prefix" != xNONE], [ + RUBY_EXEC_PREFIX="$prefix" +], [ + RUBY_EXEC_PREFIX=$ac_default_prefix +]) +pat=`echo "${RUBY_EXEC_PREFIX}" | tr -c '\012' .`'\(.*\)' +for var in bindir includedir libdir rubylibprefix; do + eval val='"$'$var'"' + AS_CASE(["$val"], ["${RUBY_EXEC_PREFIX}"*], [val='${exec_prefix}'"`expr \"$val\" : \"$pat\"`"]) + eval $var='"$val"' +done + +BTESTRUBY='$(MINIRUBY)' +AS_IF([test x"$cross_compiling" = xyes], [ + test x"$MINIRUBY" = x && MINIRUBY="${RUBY-$BASERUBY} -I${ac_abs_builddir-.} "-r'$(arch)-fake' + XRUBY_LIBDIR=`${RUBY-$BASERUBY} -rrbconfig -e ['puts RbConfig::CONFIG["libdir"]']` + XRUBY_RUBYLIBDIR=`${RUBY-$BASERUBY} -rrbconfig -e ['puts RbConfig::CONFIG["rubylibdir"]']` + XRUBY_RUBYHDRDIR=`${RUBY-$BASERUBY} -rrbconfig -e ['puts RbConfig::CONFIG["rubyhdrdir"]']` + AC_SUBST(XRUBY_LIBDIR) + AC_SUBST(XRUBY_RUBYLIBDIR) + AC_SUBST(XRUBY_RUBYHDRDIR) + PREP='$(arch)-fake.rb' + AS_CASE(["$enable_shared:$EXTSTATIC:$target_os"], [no::darwin*], [ + # darwin target requires miniruby for linking ext bundles + PREP="$PREP"' miniruby$(EXEEXT)' + ]) + RUNRUBY_COMMAND='$(MINIRUBY) -I`$(CHDIR) $(srcdir)/lib; pwd`' + RUNRUBY='$(RUNRUBY_COMMAND)' + XRUBY='$(MINIRUBY)' + TEST_RUNNABLE=no + CROSS_COMPILING=yes + AC_DEFINE(CROSS_COMPILING, 1) +], [ + MINIRUBY='./miniruby$(EXEEXT) -I$(srcdir)/lib -I.' + MINIRUBY="$MINIRUBY"' -I$(EXTOUT)/common' + PREP='miniruby$(EXEEXT)' + RUNRUBY_COMMAND='$(MINIRUBY) $(tooldir)/runruby.rb --extout=$(EXTOUT) $(RUNRUBYOPT)' + RUNRUBY='$(RUNRUBY_COMMAND) --' + XRUBY='$(RUNRUBY)' + TEST_RUNNABLE=yes + CROSS_COMPILING=no +]) +AC_SUBST(TEST_RUNNABLE) +AC_SUBST(CROSS_COMPILING) +AC_SUBST(MINIRUBY) +AC_SUBST(BTESTRUBY) +AC_SUBST(PREP) +AC_SUBST(RUNRUBY_COMMAND) +AC_SUBST(RUNRUBY) +AC_SUBST(XRUBY) +AC_SUBST(EXTOUT, [${EXTOUT=.ext}]) + +LIBRUBY_A='lib$(RUBY_SO_NAME)-static.a' +LIBRUBY='$(LIBRUBY_A)' +LIBRUBYARG_STATIC='-l$(RUBY_SO_NAME)-static' +LIBRUBYARG='$(LIBRUBYARG_STATIC)' +SOLIBS='$(MAINLIBS)' + +AS_CASE(["$target_os"], + [cygwin*|msys*|mingw*|haiku*|darwin*], [ + : ${DLDLIBS=""} + ], + [ + DLDLIBS="${DLDLIBS:+$DLDLIBS }-lc" + ]) + +AC_ARG_ENABLE(multiarch, + AS_HELP_STRING([--enable-multiarch], [enable multiarch compatible directories]), + [AS_CASE([$enableval], [no], [unset multiarch], [multiarch=])], + [unset multiarch]) +AS_IF([test ${multiarch+set}], [ + AC_DEFINE(ENABLE_MULTIARCH) +]) + +archlibdir='${libdir}/${arch}' +sitearchlibdir='${libdir}/${sitearch}' +archincludedir='${includedir}/${arch}' +sitearchincludedir='${includedir}/${sitearch}' + +AC_ARG_WITH(soname, + AS_HELP_STRING([--with-soname=SONAME], [base name of shared library]), + [RUBY_SO_NAME=$withval], + [ + AS_CASE(["$target_os"], + [darwin*], [ + RUBY_SO_NAME='$(RUBY_BASE_NAME).$(RUBY_API_VERSION)' + ], + [cygwin*], [ + RUBY_SO_NAME='$(RUBY_BASE_NAME)$(MAJOR)$(MINOR)0' + ], + [mingw*], [ + RUBY_SO_NAME="${rb_cv_msvcrt}"'-$(RUBY_BASE_NAME)$(MAJOR)$(MINOR)0' + AS_IF([test x"${target_cpu}" != xi386 || test x"${rb_cv_msvcrt}" != xmsvcrt], [ + RUBY_SO_NAME="${target_cpu}-${RUBY_SO_NAME}" + ]) + ], + [RUBY_SO_NAME='$(RUBY_BASE_NAME)']) + ]) + +LIBRUBY_LDSHARED=${DLDSHARED=${LDSHARED}} +LIBRUBY_DLDFLAGS=$DLDFLAGS +LIBRUBY_SO='lib$(RUBY_SO_NAME).$(SOEXT).$(RUBY_PROGRAM_VERSION)' +LIBRUBY_SONAME='lib$(RUBY_SO_NAME).$(SOEXT).$(RUBY_API_VERSION)' +LIBRUBY_ALIASES='lib$(RUBY_SO_NAME).$(SOEXT)' +ENABLE_SHARED=no + +AC_ARG_ENABLE(shared, + AS_HELP_STRING([--enable-shared], [build a shared library for Ruby]), + [enable_shared=$enableval]) +libprefix=${multiarch+'$(archlibdir)'}${multiarch-'$(libdir)'} +LIBRUBY_RELATIVE=${load_relative-no} +AS_CASE("$enable_shared", [yes], [ + LIBRUBY='$(LIBRUBY_SO)' + LIBRUBYARG_SHARED='-l$(RUBY_SO_NAME)' + LIBRUBYARG='$(LIBRUBYARG_SHARED)' + LIBRUBY_RELATIVE=no + test -z "$CCDLFLAGS" || CFLAGS="$CFLAGS $CCDLFLAGS" + ENABLE_SHARED=yes + + # libdir can be overridden in config.site file (on OpenSUSE at least). + libdir_basename=lib + AS_IF([test "$bindir" = '${exec_prefix}/bin'], [ + AS_CASE(["$libdir"], ['${exec_prefix}/'*], [libdir_basename=`basename "$libdir"`]) + ]) + AC_DEFINE_UNQUOTED(LIBDIR_BASENAME, ["${libdir_basename}"]) + libdir_basename="${libdir_basename}"${multiarch+'/${arch}'} + + # Debian bullseye reportedly has its ld(1) patched, which breaks + # --enable-shared --with-jemalloc combination. We might have to deal with + # the ld(1) change sooner or later, but in the meantime let us force it + # the old way. + # + # See https://github.com/ruby/ruby/pull/4627 + RUBY_TRY_LDFLAGS([${linker_flag}--no-as-needed], [no_as_needed=yes], [no_as_needed=no]) + AS_IF([test "$no_as_needed" = yes], [ + RUBY_APPEND_OPTIONS(LDFLAGS, [${linker_flag}--no-as-needed]) + ]) + + AS_CASE(["$target_os"], + [freebsd*|dragonfly*], [], + [ + AS_IF([test "$GCC" = yes], [ + RUBY_TRY_LDFLAGS([${linker_flag}--no-undefined], [no_undefined=yes], [no_undefined=no]) + AS_IF([test "no_undefined" = yes], [ + RUBY_APPEND_OPTION(EXTLDFLAGS, [${linker_flag}--no-undefined]) + ]) + ]) + ]) + + relative_libprefix="/../${multiarch+../}${libdir_basename}" + AS_CASE(["$target_os"], + [sunos4*], [ + LIBRUBY_ALIASES='$(LIBRUBY_SONAME) lib$(RUBY_SO_NAME).$(SOEXT)' + ], + [linux* | gnu* | k*bsd*-gnu | atheos* | kopensolaris*-gnu | haiku*], [ + RUBY_APPEND_OPTIONS(LIBRUBY_DLDFLAGS, ['-Wl,-soname,$(LIBRUBY_SONAME)' "$LDFLAGS_OPTDIR"]) + LIBRUBY_ALIASES='$(LIBRUBY_SONAME) lib$(RUBY_SO_NAME).$(SOEXT)' + AS_IF([test "$load_relative" = yes], [ + libprefix="'\$\${ORIGIN}${relative_libprefix}'" + LIBRUBY_RPATHFLAGS="-Wl,-rpath,${libprefix}" + LIBRUBY_RELATIVE=yes + ]) + ], + [freebsd*|dragonfly*], [ + LIBRUBY_SO='lib$(RUBY_SO_NAME).$(SOEXT).$(MAJOR)$(MINOR)' + LIBRUBY_SONAME='$(LIBRUBY_SO)' + AS_IF([test "$rb_cv_binary_elf" != "yes" ], [ + LIBRUBY_SO="$LIBRUBY_SO.\$(TEENY)" + LIBRUBY_ALIASES='' + ], [test "$load_relative" = yes], [ + libprefix="'\$\$ORIGIN${relative_libprefix}'" + LIBRUBY_RPATHFLAGS="-Wl,-rpath,${libprefix}" + LIBRUBY_RELATIVE=yes + ]) + ], + [netbsd*], [ + LIBRUBY_SONAME='lib$(RUBY_SO_NAME).$(SOEXT).$(MAJOR)$(MINOR)' + LIBRUBY_SO="${LIBRUBY_SONAME}"'.$(TEENY)' + RUBY_APPEND_OPTIONS(LIBRUBY_DLDFLAGS, ['-Wl,-soname,$(LIBRUBY_SONAME)' "$LDFLAGS_OPTDIR"]) + AS_IF([test "$rb_cv_binary_elf" = yes], [ # ELF platforms + LIBRUBY_ALIASES='$(LIBRUBY_SONAME) lib$(RUBY_SO_NAME).$(SOEXT)' + ], [ # a.out platforms + LIBRUBY_ALIASES="" + ]) + ], + [openbsd*|mirbsd*], [ + LIBRUBY_SO='lib$(RUBY_SO_NAME).$(SOEXT).$(MAJOR).'`expr ${MINOR} \* 10 + ${TEENY}` + ], + [solaris*], [ + LIBRUBY_SO='lib$(RUBY_SO_NAME).$(SOEXT).$(MAJOR)' + LIBRUBY_SONAME='lib$(RUBY_SO_NAME).$(SOEXT).$(RUBY_PROGRAM_VERSION)' + LIBRUBY_ALIASES='$(LIBRUBY_SONAME) lib$(RUBY_SO_NAME).$(SOEXT)' + RUBY_APPEND_OPTIONS(LIBRUBY_DLDFLAGS, ["${linker_flag}-h${linker_flag:+,}"'$(@F)']) + AS_IF([test "$load_relative" = yes], [ + libprefix="'\$\$ORIGIN${relative_libprefix}'" + LIBRUBY_RPATHFLAGS="-R${libprefix}" + LIBRUBY_RELATIVE=yes + ], [ + LIBRUBY_RPATHFLAGS='-R${libdir}' + ]) + ], + [aix*], [ + RUBY_APPEND_OPTIONS(LIBRUBY_DLDFLAGS, ["${linker_flag}-bnoentry" "$XLDFLAGS" "$LDFLAGS_OPTDIR"]) + LIBRUBYARG_SHARED='-L${libdir} -l${RUBY_SO_NAME}' + LIBS="$LIBS -lm -lc" + ], + [darwin*], [ + LIBRUBY_SO='lib$(RUBY_SO_NAME).$(SOEXT)' + LIBRUBY_SONAME='$(LIBRUBY_SO)' + LIBRUBY_ALIASES='lib$(RUBY_INSTALL_NAME).$(SOEXT)' + AS_IF([test "$load_relative" = yes], [ + libprefix="@executable_path${relative_libprefix}" + LIBRUBY_RELATIVE=yes + ]) + LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS -install_name ${libprefix}"'/$(LIBRUBY_SONAME)' + LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-compatibility_version $(RUBY_API_VERSION)' + LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-current_version $(RUBY_PROGRAM_VERSION)' + AS_IF([test "$visibility_option" = ld], [ + LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-Wl,-unexported_symbol,_Init_*' + LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-Wl,-unexported_symbol,_InitVM_*' + LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-Wl,-unexported_symbol,_ruby_static_id_*' + LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "'-Wl,-unexported_symbol,*_threadptr_*' + ]) + LIBRUBY_DLDFLAGS="$LIBRUBY_DLDFLAGS "' $(XLDFLAGS)' + ], + [interix*], [ + LIBRUBYARG_SHARED='-L. -L${libdir} -l$(RUBY_SO_NAME)' + ], + [cygwin*|msys*|mingw*|mswin*], [ + LIBRUBY_RELATIVE=yes + ]) +], [ + LIBRUBYARG_SHARED= + + # enable PIE if possible + AC_ARG_ENABLE(pie, + AS_HELP_STRING([--disable-pie], [disable PIE feature]), + [pie=$enableval], [pie=]) + AS_IF([test "$GCC" = yes -a -z "$EXTSTATIC" -a "x$pie" != xno], [ + RUBY_TRY_CFLAGS(-fPIE, [pie=yes], [pie=no]) + AS_IF([test "$pie" = yes], [ + # Use -fPIE when testing -pie. RUBY_TRY_LDFLAGS sets + # $save_CFLAGS internally, so set other name here. + save_CFLAGS_before_pie="$CFLAGS" + CFLAGS="$CFLAGS -fPIE" + + # gcc need -pie but clang need -Wl,-pie. + for pie in -pie -Wl,-pie; do + RUBY_TRY_LDFLAGS([$pie], [], [pie=]) + AS_IF([test "x$pie" != x], [ + RUBY_APPEND_OPTION(XCFLAGS, -fPIE) + RUBY_APPEND_OPTION(XLDFLAGS, $pie) + break + ]) + done + CFLAGS="$save_CFLAGS_before_pie" + ]) + ]) +]) +AS_IF([test "$enable_rpath" = yes], [ + AS_CASE(["${cross_compiling}${load_relative}"], + [*yes*], [rpathflag="${RPATHFLAG}"], + [rpathflag="$RPATHFLAG${LIBPATHFLAG:+${RPATHFLAG:+ }$LIBPATHFLAG}"]) + rpathflag=`IFS="$PATH_SEPARATOR" + echo x "$rpathflag" | + sed "s/^x *//;s${IFS}"'%1\\$-s'"${IFS}${libprefix}${IFS}g;s${IFS}%s${IFS}${libprefix}${IFS}g" + ` + LIBRUBY_RPATHFLAGS="${LIBRUBY_RPATHFLAGS:+$LIBRUBY_RPATHFLAGS }${rpathflag}" + LIBRUBYARG_SHARED="${LIBRUBY_RPATHFLAGS:+$LIBRUBY_RPATHFLAGS }$LIBRUBYARG_SHARED" + LIBRUBYARG_STATIC="${LIBRUBY_RPATHFLAGS:+$LIBRUBY_RPATHFLAGS }$LIBRUBYARG_STATIC" +]) +AC_SUBST(LIBRUBY_RELATIVE) + +LDFLAGS="-L. $LDFLAGS" +AC_SUBST(ARCHFILE) + +AS_IF([test "$EXEEXT" = .exe], [ + EXECUTABLE_EXTS='".exe",".com",".cmd",".bat"' + AC_DEFINE_UNQUOTED(EXECUTABLE_EXTS, $EXECUTABLE_EXTS) + EXECUTABLE_EXTS=`echo $EXECUTABLE_EXTS | tr -d '"' | tr , ' '` + AC_SUBST(EXECUTABLE_EXTS) +]) + +AS_CASE("$cross_compiling:${LIBPATHENV}", [yes:* | no:], [], [ + AC_MSG_CHECKING(whether wrapper for $LIBPATHENV is needed) + AS_IF([env ${LIBPATHENV}=/lib /bin/sh -c ': ${'${LIBPATHENV}'?}' 2>/dev/null], + [AC_MSG_RESULT(no)], + [AC_SUBST(XRUBY_LIBPATHENV_WRAPPER, 'exe/$(PROGRAM)') + AC_MSG_RESULT(yes)] + ) +]) + +AC_ARG_ENABLE(dtrace, + AS_HELP_STRING([--enable-dtrace], + [enable DTrace for tracing inside ruby. enabled by default on systems having dtrace]), + [enable_dtrace=$enableval], [enable_dtrace=auto]) + +LIBRUBY_A_OBJS='$(OBJS)' +DTRACE_REBUILD= +AS_CASE(["${enable_dtrace}"], +[yes|auto], [ + RUBY_DTRACE_AVAILABLE() +], [ + rb_cv_dtrace_available=no +]) +AS_CASE(["$target_os"],[freebsd*],[ + rb_cv_dtrace_available=no + ]) +AS_IF([test "${enable_dtrace}" = yes], [dnl + AS_IF([test -z "$DTRACE"], [dnl + AC_MSG_ERROR([dtrace(1) is missing]) + ], [test "$cross_compiling" = yes], [dnl + AC_MSG_ERROR([--enable-dtrace, however, cross compiling]) + ], [test "${rb_cv_dtrace_available}" = "no"], [dnl + AC_MSG_ERROR([--enable-dtrace, however, USDT is not available]) + ]) +]) +AS_CASE([$rb_cv_dtrace_available], +[yes*], [dnl + RUBY_DTRACE_POSTPROCESS() + AS_IF([test "$rb_cv_prog_dtrace_g" != no], [dnl + DTRACE_OBJ='probes.$(OBJEXT)' + ]) + AS_IF([test "$rb_cv_prog_dtrace_g" = rebuild], [dnl + DTRACE_REBUILD=yes + LIBRUBY_A_OBJS='$(DTRACE_GLOMMED_OBJ)' + ]) + AS_CASE("${target_os}", [freebsd*], [dnl + # FreeBSD's dtrace requires libelf + LIBS="-lelf $LIBS" + ]) + DTRACE_EXT=d +], [dnl + enable_dtrace=no + DTRACE_EXT=dmyh +]) +AC_SUBST(DTRACE_EXT) +AC_SUBST(DTRACE_OBJ) +AC_SUBST(DTRACE_REBUILD) +AC_SUBST(DTRACE_OPT) +AC_SUBST(LIBRUBY_A_OBJS) + +AC_ARG_ENABLE(gcov, + AS_HELP_STRING([--enable-gcov], [enable coverage measurement by gcov]), + [gcov=yes]) +AS_IF([test x"$gcov" = xyes], [ + CFLAGS="$CFLAGS -coverage -fprofile-update=atomic" + LDFLAGS="$LDFLAGS -coverage" +]) + +RUBY_SETJMP_TYPE +RUBY_MODULAR_GC +} + +[begin]_group "installation section" && { +dnl build rdoc index if requested +RDOCTARGET="" +CAPITARGET="" +AC_ARG_ENABLE(install-doc, + AS_HELP_STRING([--disable-install-doc], [do not install either rdoc indexes or C API documents during install]), + [install_doc=$enableval], [install_doc=yes]) +AC_ARG_WITH(rdoc, + AS_HELP_STRING([--with-rdoc=ri,html], [comma/space separated list of RDoc formats to install]), + [install_rdoc=`echo ,$withval, | sed 'y/,/ /;s/ ri / rdoc /;s/^ *//;s/ *$//'`], [ +AC_ARG_ENABLE(install-rdoc, + AS_HELP_STRING([--disable-install-rdoc], [do not install rdoc indexes during install]), + [install_rdoc=$enableval], [install_rdoc=yes]) +]) +AC_ARG_ENABLE(install-capi, + AS_HELP_STRING([--disable-install-capi], [do not install C API documents during install]), + [install_capi=$enableval], [install_capi=no]) + +AS_IF([test "$install_doc" != no], [ + AS_CASE(["$install_rdoc"], + [yes], [ + RDOCTARGET="rdoc" + ], + [all], [ + RDOCTARGET="rdoc html" + ], + [no|''], [ + RDOCTARGET="nodoc" + ], + [ + RDOCTARGET="$install_rdoc" + ]) + AS_IF([test "$install_capi" != no -a -n "$DOXYGEN"], [ + CAPITARGET="capi" + ], [ + CAPITARGET="nodoc" + ]) +], [ + RDOCTARGET="nodoc" + CAPITARGET="nodoc" +]) + +AC_SUBST(RDOCTARGET) +AC_SUBST(CAPITARGET) + +AS_CASE(["$RDOCTARGET:$CAPITARGET"],[nodoc:nodoc],[INSTALLDOC=nodoc],[INSTALLDOC=all]) +AC_SUBST(INSTALLDOC) + +AC_ARG_ENABLE(install-static-library, + AS_HELP_STRING([--disable-install-static-library], [do not install static ruby library]), + [INSTALL_STATIC_LIBRARY=$enableval + AS_IF([test x"$enable_shared" = xno -a x"$INSTALL_STATIC_LIBRARY" = xno], + [AC_MSG_ERROR([must install either static or shared library])], + [])], + AS_IF([test x"$enable_shared" = xyes], + [INSTALL_STATIC_LIBRARY=no], + [INSTALL_STATIC_LIBRARY=yes])) +AC_SUBST(INSTALL_STATIC_LIBRARY) +} + +[begin]_group "JIT section" && { +AC_CHECK_PROG(RUSTC, [rustc], [rustc], [no]) dnl no ac_tool_prefix + +dnl check if rustc is recent enough to build YJIT (rustc >= 1.58.0) +JIT_RUSTC_OK=no +JIT_TARGET_ARCH= +AS_IF([test "$RUSTC" != "no"], + AC_MSG_CHECKING([whether ${RUSTC} works for YJIT]) + AS_CASE(["$target_cpu"], + [arm64|aarch64], [JIT_TARGET_ARCH=aarch64], + [x86_64], [JIT_TARGET_ARCH=x86_64], + ) + dnl Fails in case rustc target doesn't match ruby target. + dnl Can happen on Rosetta, for example. + AS_IF([echo "#[cfg(target_arch = \"$JIT_TARGET_ARCH\")] fn main() { let x = 1; format!(\"{x}\"); }" | + $RUSTC - --emit asm=/dev/null 2>/dev/null], + [JIT_RUSTC_OK=yes] + ) + AC_MSG_RESULT($JIT_RUSTC_OK) +) + +dnl check if we can build YJIT/ZJIT on this target platform +dnl we can't easily cross-compile with rustc so we don't support that +JIT_TARGET_OK=no +AS_IF([test "$cross_compiling" = no], + AS_CASE(["$target_cpu-$target_os"], + [*android*], [ + JIT_TARGET_OK=no + ], + [arm64-darwin*|aarch64-darwin*|x86_64-darwin*], [ + JIT_TARGET_OK=yes + ], + [arm64-*linux*|aarch64-*linux*|x86_64-*linux*], [ + JIT_TARGET_OK=yes + ], + [arm64-*bsd*|aarch64-*bsd*|x86_64-*bsd*], [ + JIT_TARGET_OK=yes + ] + ) +) + +dnl build YJIT in release mode if rustc >= 1.58.0 is present and we are on a supported platform +AC_ARG_ENABLE(yjit, + AS_HELP_STRING([--enable-yjit], + [enable in-process JIT compiler that requires Rust build tools. enabled by default on supported platforms if rustc 1.58.0+ is available]), + [YJIT_SUPPORT=$enableval], + [AS_CASE(["$JIT_TARGET_OK:$JIT_RUSTC_OK"], + [yes:yes], [ + YJIT_SUPPORT=yes + ], + [YJIT_SUPPORT=no] + )] +) + +dnl build ZJIT in release mode if rustc >= 1.85.0 is present and we are on a supported platform +ZJIT_SUPPORT=no +AC_ARG_ENABLE(zjit, + AS_HELP_STRING([--enable-zjit], + [enable experimental JIT compiler that requires Rust build tools. enabled by default on supported platforms if rustc 1.85.0+ is available]), + [ZJIT_SUPPORT=$enableval], + [AS_CASE(["$JIT_TARGET_OK"], + [yes], [ + rb_zjit_build_possible=no + AC_MSG_CHECKING([prerequisites for ZJIT])dnl only checked when --enable-zjit is not specified + # Fails in case rustc target doesn't match ruby target. Can happen on Rosetta, for example. + # 1.85.0 is the first stable version that supports the 2024 edition. + AS_IF([test "$RUSTC" != "no" && echo "#[cfg(target_arch = \"$JIT_TARGET_ARCH\")] fn main() {}" | + $RUSTC - --edition=2024 --emit asm=/dev/null 2>/dev/null], + AS_IF([test "$gnumake" = "yes"], [ + rb_zjit_build_possible=yes + ]) + ) + AC_MSG_RESULT($rb_zjit_build_possible) + ZJIT_SUPPORT=$rb_zjit_build_possible + ] + )] +) + +CARGO_BUILD_ARGS= +YJIT_LIBS= +JIT_CARGO_SUPPORT=no +AS_CASE(["${YJIT_SUPPORT}"], +[yes|dev|stats|dev_nodebug], [ + AS_IF([test x"$RUSTC" = "xno"], + AC_MSG_ERROR([rustc is required. Installation instructions available at https://www.rust-lang.org/tools/install]) + ) + + AS_CASE(["${YJIT_SUPPORT}"], + [yes], [ + ], + [dev], [ + rb_cargo_features='disasm,runtime_checks' + JIT_CARGO_SUPPORT=dev + AC_DEFINE(RUBY_DEBUG, 1) + ], + [dev_nodebug], [ + rb_cargo_features='disasm' + JIT_CARGO_SUPPORT=dev_nodebug + AC_DEFINE(YJIT_STATS, 1) + ], + [stats], [ + JIT_CARGO_SUPPORT=stats + AC_DEFINE(YJIT_STATS, 1) + ]) + + YJIT_LIBS="target/release/libyjit.a" + RUST_LIB='$(YJIT_LIBS)' + YJIT_OBJ='yjit.$(OBJEXT)' + JIT_OBJ='jit.$(OBJEXT)' + AS_IF([test x"$YJIT_SUPPORT" != "xyes" ], [ + AC_DEFINE_UNQUOTED(YJIT_SUPPORT, [$YJIT_SUPPORT]) + ]) + AC_DEFINE(USE_YJIT, 1) +], [ + AC_DEFINE(USE_YJIT, 0) +]) + +ZJIT_LIBS= +AS_CASE(["${ZJIT_SUPPORT}"], +[yes|dev|dev_nodebug|stats], [ + AS_IF([test x"$RUSTC" = "xno"], + AC_MSG_ERROR([rustc is required. Installation instructions available at https://www.rust-lang.org/tools/install]) + ) + + AS_CASE(["${ZJIT_SUPPORT}"], + [yes], [ + ], + [dev], [ + rb_cargo_features="$rb_cargo_features,disasm,runtime_checks" + JIT_CARGO_SUPPORT=dev + AC_DEFINE(RUBY_DEBUG, 1) + ], + [dev_nodebug], [ + rb_cargo_features="$rb_cargo_features,disasm" + JIT_CARGO_SUPPORT=dev_nodebug + AC_DEFINE(ZJIT_STATS, 1) + ], + [stats], [ + JIT_CARGO_SUPPORT=stats + AC_DEFINE(ZJIT_STATS, 1) + ]) + + ZJIT_LIBS="target/release/libzjit.a" + RUST_LIB='$(ZJIT_LIBS)' + ZJIT_OBJ='zjit.$(OBJEXT)' + JIT_OBJ='jit.$(OBJEXT)' + AS_IF([test x"$ZJIT_SUPPORT" != "xyes" ], [ + AC_DEFINE_UNQUOTED(ZJIT_SUPPORT, [$ZJIT_SUPPORT]) + ]) + AC_DEFINE(USE_ZJIT, 1) +], [ + AC_DEFINE(USE_ZJIT, 0) +]) + +RUSTC_FLAGS='-g -C lto=thin -C opt-level=3 -C overflow-checks=on' +AS_IF([test -n "${rustc_flags}"], [ + RUSTC_FLAGS="${RUSTC_FLAGS} ${rustc_flags}" +]) + +JIT_RUST_FLAGS='--crate-type=staticlib --cfg feature=\"stats_allocator\"' +RLIB_DIR= +AS_CASE(["$JIT_CARGO_SUPPORT:$YJIT_SUPPORT:$ZJIT_SUPPORT"], +[no:yes:yes], [ # release build of YJIT+ZJIT + YJIT_LIBS= + ZJIT_LIBS= + JIT_RUST_FLAGS="--crate-type=rlib" + RLIB_DIR="target/release" + RUST_LIB="target/release/libruby.a" +], +[no:*], [], +[ # JIT_CARGO_SUPPORT not "no" -- cargo required. + AC_CHECK_TOOL(CARGO, [cargo], [no]) + AS_IF([test x"$CARGO" = "xno"], + AC_MSG_ERROR([this build configuration requires cargo. Installation instructions available at https://www.rust-lang.org/tools/install])) + + YJIT_LIBS= + ZJIT_LIBS= + + # There's more processing below to get the feature set for the + # top-level crate, so capture at this point for feature set of + # just the zjit crate. + ZJIT_TEST_FEATURES="${rb_cargo_features}" + + AS_IF([test x"${YJIT_SUPPORT}" != x"no"], [ + rb_cargo_features="$rb_cargo_features,yjit" + ]) + AS_IF([test x"${ZJIT_SUPPORT}" != x"no"], [ + AC_SUBST(ZJIT_TEST_FEATURES) + rb_cargo_features="$rb_cargo_features,zjit" + ]) + # if YJIT and ZJIT release mode + AS_IF([test "${YJIT_SUPPORT}:${ZJIT_SUPPORT}" = "yes:yes"], [ + JIT_CARGO_SUPPORT=release + ]) + CARGO_BUILD_ARGS="--profile ${JIT_CARGO_SUPPORT} --features ${rb_cargo_features}" + AS_IF([test "${JIT_CARGO_SUPPORT}" = "dev"], [ + RUST_LIB="target/debug/libruby.a" + ], [ + RUST_LIB="target/${JIT_CARGO_SUPPORT}/libruby.a" + ]) +]) + +# In case either we're linking rust code +AS_IF([test -n "$RUST_LIB"], [ + AS_CASE(["$target_os"],[openbsd*],[ + # Link libc++abi (which requires libpthread) for _Unwind_* functions needed by rust stdlib + LDFLAGS="$LDFLAGS -lpthread -lc++abi" + ]) + + # absolute path to stop the "target" dir in src dir from interfering through VPATH + RUST_LIB="$(pwd)/${RUST_LIB}" +]) + +dnl These variables end up in ::RbConfig::CONFIG +AC_SUBST(RUSTC)dnl Rust compiler command +AC_SUBST(JIT_RUST_FLAGS)dnl the common rustc flags for JIT crates such as zjit +AC_SUBST(RUSTC_FLAGS)dnl user-configurable rustc compiler flags +AC_SUBST(CARGO)dnl Cargo command for Rust builds +AC_SUBST(CARGO_BUILD_ARGS)dnl for selecting Rust build profiles +AC_SUBST(YJIT_SUPPORT)dnl what flavor of YJIT the Ruby build includes +AC_SUBST(YJIT_LIBS)dnl the .a library of YJIT +AC_SUBST(YJIT_OBJ)dnl for optionally building the C parts of YJIT +AC_SUBST(ZJIT_SUPPORT)dnl what flavor of ZJIT the Ruby build includes +AC_SUBST(ZJIT_LIBS)dnl path to the .a library of ZJIT +AC_SUBST(ZJIT_OBJ)dnl for optionally building the C parts of ZJIT +AC_SUBST(JIT_OBJ)dnl for optionally building C glue code for Rust FFI +AC_SUBST(RUST_LIB)dnl path to the rust .a library that contains either or both JITs +AC_SUBST(RLIB_DIR)dnl subpath of build directory for .rlib files +AC_SUBST(JIT_CARGO_SUPPORT)dnl "no" or the cargo profile of the rust code +} + +[begin]_group "build section" && { +AC_CACHE_CHECK([for prefix of external symbols], rb_cv_symbol_prefix, [ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[extern void conftest_external(void) {}]], [[]])],[ + rb_cv_symbol_prefix=`$NM conftest.$ac_objext | + sed -n ['/.*T[ ]\([^ ]*\)conftest_external.*/!d;s//\1/p;q']` + ], + [rb_cv_symbol_prefix='']) + test -n "$rb_cv_symbol_prefix" || rb_cv_symbol_prefix=NONE +]) +SYMBOL_PREFIX="$rb_cv_symbol_prefix" +test "x$SYMBOL_PREFIX" = xNONE && SYMBOL_PREFIX='' + +AS_IF([test x"$SOEXT" = xdll], [ + # DLL on Windows is managed by win32/mkexports.rb +], [test x"$enable_shared" = xyes], [ + AC_CACHE_CHECK([for default symbols in empty shared library], rb_cv_symbols_in_emptylib, [ + save_CC="$CC" + eval CC=\"`printf "%s" "${DLDSHARED}" | sed ['s/\$(CC)/${CC}/']`\" + AC_LINK_IFELSE([AC_LANG_PROGRAM()],[ + rb_cv_symbols_in_emptylib=`$NM -Pgp conftest$ac_exeext | + sed ["/ [A-TV-Z] .*/!d;s///;s/^${SYMBOL_PREFIX}//;/^main$/d"]` + ]) + set dummy ${rb_cv_symbols_in_emptylib} + shift + rb_cv_symbols_in_emptylib="$*" + CC="$save_CC" + ]) +]) +AC_SUBST(XSYMBOLS_IN_EMPTYLIB, "${rb_cv_symbols_in_emptylib}") + +DLNOBJ=dln.o +AC_ARG_ENABLE(dln, + AS_HELP_STRING([--disable-dln], [disable dynamic link feature]), + [test "$enableval" = yes || DLNOBJ=dmydln.o]) +AC_SUBST(DLNOBJ) +MINIDLNOBJ=dmydln.o + +AS_CASE(["$target_os"], + [linux*], [ + ], + [netbsd*], [ + RUBY_APPEND_OPTION(CFLAGS, -pipe) + ], + [darwin*], [ + RUBY_TRY_CFLAGS(-pipe, [pipe_opt=yes], [pipe_opt=no]) + AS_IF([test $pipe_opt = yes], [RUBY_APPEND_OPTION(CFLAGS, -pipe)]) + AC_MSG_CHECKING([whether Security framework is needed]) + AC_COMPILE_IFELSE([ + AC_LANG_BOOL_COMPILE_TRY([ +@%:@include <AvailabilityMacros.h> +enum { + least = MAC_OS_X_VERSION_10_7, /* just fail if undefined */ + required = MAC_OS_X_VERSION_MIN_REQUIRED, + upper /* bigger than MIN_REQUIRED, or */ +@%:@ifdef MAC_OS_X_VERSION_10_10 + = MAC_OS_X_VERSION_10_10 +@%:@endif +};], + [required >= least && required < upper])], + [dnl + AC_MSG_RESULT(yes) + RUBY_APPEND_OPTION(XLDFLAGS, [-framework Security]) + RUBY_APPEND_OPTION(LIBRUBYARG_STATIC, [-framework Security]) + ],dnl + [dnl + AC_MSG_RESULT(no) + ]dnl + ) + RUBY_APPEND_OPTION(XLDFLAGS, [-framework CoreFoundation]) + RUBY_APPEND_OPTION(LIBRUBYARG_STATIC, [-framework CoreFoundation]) + ], + [osf*], [ + AS_IF([test "$GCC" != "yes" ], [ + # compile something small: taint.c is fine for this. + # the main point is the '-v' flag of 'cc'. + AS_CASE(["`cc -v -I. -c main.c -o /tmp/main.o 2>&1`"], + [*/gemc_cc*], [ # we have the new DEC GEM CC + CFLAGS="$CFLAGS -oldc" + ], + [ # we have the old MIPS CC + ]) + # cleanup + rm -f /tmp/main.o + CFLAGS="$CFLAGS -std" + ]) + ], + [cygwin*|msys*|mingw*], [ + LIBRUBY_DLDFLAGS="${LIBRUBY_DLDFLAGS}"' -Wl,--out-implib=$(LIBRUBY)' + AS_CASE(["$target_os"], + [cygwin*], [ + AS_IF([test x"$enable_shared" = xyes], [ + LIBRUBY_SO='cyg$(RUBY_SO_NAME)'.dll + LIBRUBY_DLDFLAGS="${LIBRUBY_DLDFLAGS}"' $(RUBYDEF)' + ]) + ], + [mingw*], [ + AS_IF([test x"$enable_shared" = xyes], [ + LIBRUBY_SO='$(RUBY_SO_NAME)'.dll + LIBRUBY_SONAME='' + LIBRUBY_DLDFLAGS="${LIBRUBY_DLDFLAGS}"' $(RUBYDEF)' + ]) + EXPORT_PREFIX=' ' + EXTDLDFLAGS='$(DEFFILE)' + AC_LIBOBJ([win32/win32]) + AC_LIBOBJ([win32/file]) + COMMON_LIBS=m +# COMMON_MACROS="WIN32_LEAN_AND_MEAN=" + COMMON_HEADERS="winsock2.h windows.h" + PLATFORM_DIR=win32 + ]) + LIBRUBY_ALIASES='' + AS_IF([test x"$enable_shared" = xyes], [ + LIBRUBY='lib$(RUBY_SO_NAME).dll.a' + ], [ + LIBRUBY_SO=dummy + LIBRUBY='lib$(RUBY_SO_NAME).a' + LIBRUBYARG='-l$(RUBY_SO_NAME)' + ]) + ], + [wasi*], [ + AC_LIBOBJ([wasm/missing]) + AC_LIBOBJ([wasm/runtime]) + AC_LIBOBJ([wasm/fiber]) + AC_LIBOBJ([wasm/machine]) + AC_LIBOBJ([wasm/setjmp]) + AC_LIBOBJ([wasm/machine_core]) + AC_LIBOBJ([wasm/setjmp_core]) + PLATFORM_DIR=wasm +]) + +MINIOBJS="$MINIDLNOBJ" + +AC_ARG_ENABLE(debug-env, + AS_HELP_STRING([--enable-debug-env], [enable RUBY_DEBUG environment variable]), + [AC_SUBST(ENABLE_DEBUG_ENV, yes)]) + +AS_IF([test "$gnumake" = yes], [ NULLCMD=: ], [ + AC_MSG_CHECKING([for safe null command for ${MAKE-make}]) + mkdir conftest.dir + NULLCMD= + for cmd in : true; do + echo 'A=1' > conftest.dir/Makefile + echo 'B=$(A:1=@'$cmd')' >> conftest.dir/Makefile + echo 'all:; $B 1 2 3 4 5 6 7 8 9' >> conftest.dir/Makefile + AS_IF([(cd conftest.dir; ${MAKE-make} >/dev/null 2>/dev/null)], [ + NULLCMD=$cmd + break + ]) + done + rm -fr conftest.dir + AS_IF([test -z "$NULLCMD"], [ + AC_MSG_ERROR(no candidate for safe null command) + ]) + AC_MSG_RESULT($NULLCMD) +]) +AC_SUBST(NULLCMD) + +AS_IF([test "${universal_binary-no}" = yes ], [ + AC_CACHE_CHECK([for architecture macros], rb_cv_architecture_macros, [ + mv confdefs.h confdefs1.h + : > confdefs.h + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@if defined __`echo ${universal_archnames} | + sed 's/=[^ ]*//g;s/ /__ || defined __/g'`__ +@%:@else +@%:@error +>>>>>><<<<<< +@%:@endif]], [[]])],[ + rb_cv_architecture_macros=yes + mv -f confdefs1.h confdefs.h +], [ + rb_cv_architecture_macros=no + archflagpat=`eval echo '"'"${ARCH_FLAG}"'"' | sed 's/[[][|.*]]/\\&/g'` + new_cflags=`echo "$CFLAGS" | sed "s|$archflagpat"'||'` + for archs in ${universal_archnames}; do + cpu=${archs@%:@*=} + archs=${archs%=*} + CFLAGS="$new_cflags -arch $archs" + archs="__${archs}__" + AC_MSG_CHECKING([for macro ${archs} on ${cpu}]) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@ifndef ${archs} +@%:@error +@%:@endif]], [[]])], + [AC_MSG_RESULT([yes])], [AC_MSG_RESULT([no])]) + done + mv -f confdefs1.h confdefs.h + AC_MSG_ERROR([failed]) + ])]) + AC_CACHE_CHECK(whether __ARCHITECTURE__ is available, rb_cv_architecture_available, + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[@%:@include <stdio.h> + const char arch[[]] = __ARCHITECTURE__;]], [[puts(arch);]])], + [rb_cv_architecture_available=yes], [rb_cv_architecture_available=no])) +]) +} + +[end]_group + +MAINLIBS="$LIBS" +LIBS=$ORIG_LIBS +AS_IF([test -n "${LIBS}"], [ + libspat=`echo "${LIBS}" | sed 's/[[][|.*$^]]/\\&/g;s/^ */ /;s/^ *$/ /'` + MAINFLAGS=`echo " $MAINLIBS " | sed "s|$libspat"'||;s/^ *//;s/ *$//'` +]) +LIBRUBYARG_STATIC="${LIBRUBYARG_STATIC} \$(MAINLIBS)" +CPPFLAGS="$CPPFLAGS "'$(DEFS) ${cppflags}' +AS_IF([test -n "${cflags+set}"], [ + cflagspat=`eval echo '"'"${cflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/^ *$/ /'` + CFLAGS=`echo " $CFLAGS " | sed "s|$cflagspat"'|${cflags}|;s/^ *//;s/ *$//'` +]) +AS_IF([test -n "${cxxflags+set}"], [ + cxxflagspat=`eval echo '"'"${cxxflags}"'"' | sed 's/[[][|.*]]/\\&/g;s/^ */ /;s/^ *$/ /'` + CXXFLAGS=`echo " $CXXFLAGS " | sed "s|$cxxflagspat"'|${cxxflags}|;s/^ *//;s/ *$//'` +]) +AS_IF([test "${ARCH_FLAG}"], [ + archflagpat=`eval echo '"'"${ARCH_FLAG}"'"' | sed 's/[[][|.*]]/\\&/g'` + CFLAGS=`echo "$CFLAGS" | sed "s| *$archflagpat"'||'` + CXXFLAGS=`echo "$CXXFLAGS" | sed "s| *$archflagpat"'||'` + LDFLAGS=`echo "$LDFLAGS" | sed "s| *$archflagpat"'||'` +]) +AS_CASE([" $rb_cv_warnflags "], [*" -Wshorten-64-to-32 "*|*" -Werror=shorten-64-to-32 "*], [ + voidp_ll= + AS_CASE([$ac_cv_sizeof_voidp], + [SIZEOF_LONG_LONG], [voidp_ll=true], + [@<:@0-9@:>@*], [ + AS_IF([test $ac_cv_sizeof_voidp -gt $ac_cv_sizeof_long], [voidp_ll=true]) + ]) + AS_IF([test "$voidp_ll"], [ + # Disable the shorten-64-to-32 warning for now, because it currently + # generates a lot of warnings on platforms where `sizeof(void*)` is + # larger than `sizeof(long)`. + # + # TODO: Replace `long` with `ptrdiff_t` or something in the all sources. + rb_cv_warnflags=`echo "$rb_cv_warnflags" | + sed -e 's/ -W\(shorten-64-to-32 \)/ -Wno-\1/' \ + -e 's/ -Werror=\(shorten-64-to-32 \)/ -Wno-\1/'` + ]) +]) +rb_cv_warnflags=`echo "$rb_cv_warnflags" | sed 's/^ *//;s/ *$//'` +warnflags="$rb_cv_warnflags" +AC_SUBST(cppflags)dnl +AC_SUBST(cflags, ['${hardenflags} '"${orig_cflags:+$orig_cflags }"' ${optflags} ${debugflags} ${warnflags}'])dnl +AC_SUBST(cxxflags)dnl +AC_SUBST(optflags)dnl +AC_SUBST(debugflags)dnl +AC_SUBST(warnflags)dnl +AC_SUBST(strict_warnflags)dnl +AC_SUBST(hardenflags)dnl +AC_SUBST(XCFLAGS)dnl +AC_SUBST(XLDFLAGS)dnl +AC_SUBST(EXTLDFLAGS)dnl +AC_SUBST(EXTDLDFLAGS)dnl +AC_SUBST(LIBRUBY_LDSHARED) +AC_SUBST(LIBRUBY_DLDFLAGS) +AC_SUBST(RUBY_INSTALL_NAME) +AC_SUBST(rubyw_install_name) +AC_SUBST(RUBYW_INSTALL_NAME) +AC_SUBST(RUBY_SO_NAME) +AC_SUBST(LIBRUBY_A) +AC_SUBST(LIBRUBY_SO) +AC_SUBST(LIBRUBY_SONAME) +AC_SUBST(LIBRUBY_ALIASES) +AC_SUBST(LIBRUBY) +AC_SUBST(LIBRUBYARG) +AC_SUBST(LIBRUBYARG_STATIC) +AC_SUBST(LIBRUBYARG_SHARED) +AC_SUBST(SOLIBS) +AC_SUBST(DLDLIBS) +AC_SUBST(DLDSHARED) +AC_SUBST(ENABLE_SHARED) +AC_SUBST(MAINLIBS) +AC_SUBST(COMMON_LIBS) +AC_SUBST(COMMON_MACROS) +AC_SUBST(COMMON_HEADERS) +AC_SUBST(EXPORT_PREFIX) +AC_SUBST(SYMBOL_PREFIX) +AC_SUBST(MINIOBJS) +AC_SUBST(THREAD_MODEL) +AC_SUBST(COROUTINE_TYPE, ${coroutine_type}) +AC_SUBST(PLATFORM_DIR) + +firstmf=`echo $FIRSTMAKEFILE | sed 's/:.*//'` +firsttmpl=`echo $FIRSTMAKEFILE | sed 's/.*://'` +MAKEFILES="Makefile $firstmf" +MAKEFILES="`echo $MAKEFILES`" +AC_SUBST(MAKEFILES) + +ri_prefix= +test "$program_prefix" != NONE && + ri_prefix=$program_prefix + +ri_suffix= +test "$program_suffix" != NONE && + ri_suffix=$program_suffix + +RUBY_INSTALL_NAME="${ri_prefix}"'$(RUBY_BASE_NAME)'"${ri_suffix}" +AS_CASE(["$target_os"], + [cygwin*|msys*|mingw*], [ + RUBYW_INSTALL_NAME="${ri_prefix}"'$(RUBYW_BASE_NAME)'"${ri_suffix}" + rubyw_install_name='$(RUBYW_INSTALL_NAME)' + ]) + +rubylibdir='${rubylibprefix}/${ruby_version}' +rubyarchdir=${multiarch+'${rubyarchprefix}/${ruby_version}'}${multiarch-'${rubylibdir}/${arch}'} + +rubyarchprefix=${multiarch+'${archlibdir}/${RUBY_BASE_NAME}'}${multiarch-'${rubylibprefix}/${arch}'} +AC_ARG_WITH(rubyarchprefix, + AS_HELP_STRING([--with-rubyarchprefix=DIR], + [prefix for architecture dependent ruby libraries [[RUBYLIBPREFIX/ARCH]]]), + [rubyarchprefix="$withval"]) +AC_SUBST(rubyarchprefix) + +rubysitearchprefix=${multiarch+'${sitearchlibdir}/${RUBY_BASE_NAME}'}${multiarch-'${rubylibprefix}/${sitearch}'} +AC_ARG_WITH(rubysitearchprefix, + AS_HELP_STRING([--with-rubysitearchprefix=DIR], + [prefix for architecture dependent site libraries [[RUBYLIBPREFIX/SITEARCH]]]), + [rubysitearchprefix="$withval"]) +AC_SUBST(rubysitearchprefix) + +RI_BASE_NAME=`echo ${RUBY_BASE_NAME} | sed 's/ruby/ri/'` +ridir='${datarootdir}/${RI_BASE_NAME}' +AC_ARG_WITH(ridir, + AS_HELP_STRING([--with-ridir=DIR], [ri documentation [[DATAROOTDIR/ri]]]), + [ridir=$withval]) +AC_SUBST(ridir) +AC_SUBST(RI_BASE_NAME) + +AC_ARG_WITH(ruby-version, + AS_HELP_STRING([--with-ruby-version=STR], [ruby version string for version specific directories [[full]] (full|minor|STR)]), + [ruby_version=$withval], + [ruby_version=full]) +unset RUBY_LIB_VERSION +unset RUBY_LIB_VERSION_STYLE +AS_CASE(["$ruby_version"], + [full], [RUBY_LIB_VERSION_STYLE='3 /* full */'], + [minor], [RUBY_LIB_VERSION_STYLE='2 /* minor */']) +AS_IF([test ${RUBY_LIB_VERSION_STYLE+set}], [ + { + echo "#define RUBY_LIB_VERSION_STYLE $RUBY_LIB_VERSION_STYLE" + echo '@%:@include "confdefs.h"' + echo '#define STRINGIZE(x) x' + test -f revision.h -o -f "${srcdir}/revision.h" || echo '#define RUBY_REVISION 0' + echo '#include "version.h"' + echo 'ruby_version=RUBY_LIB_VERSION' + } > conftest.c + ruby_version="`$CPP -I. -I"${srcdir}" -I"${srcdir}/include" conftest.c | sed '/^ruby_version=/!d;s/ //g'`" + eval $ruby_version +], [test -z "${ruby_version}"], [ + AC_MSG_ERROR([No ruby version, No place for bundled libraries]) +], [ + RUBY_LIB_VERSION="${ruby_version}" +]) +AC_SUBST(RUBY_LIB_VERSION_STYLE) +AC_SUBST(RUBY_LIB_VERSION) + +AC_ARG_WITH(sitedir, + AS_HELP_STRING([--with-sitedir=DIR], [site libraries in DIR [[RUBY_LIB_PREFIX/site_ruby]], "no" to disable site directory]), + [sitedir=$withval], + [sitedir='${rubylibprefix}/site_ruby']) +sitelibdir='${sitedir}/${ruby_version}' + +AC_ARG_WITH(sitearchdir, + AS_HELP_STRING([--with-sitearchdir=DIR], + [architecture dependent site libraries in DIR [[SITEDIR/SITEARCH]], "no" to disable site directory]), + [sitearchdir=$withval], + [sitearchdir=${multiarch+'${rubysitearchprefix}/site_ruby/${ruby_version}'}${multiarch-'${sitelibdir}/${sitearch}'}]) + +AC_ARG_WITH(vendordir, + AS_HELP_STRING([--with-vendordir=DIR], [vendor libraries in DIR [[RUBY_LIB_PREFIX/vendor_ruby]], "no" to disable vendor directory]), + [vendordir=$withval], + [vendordir='${rubylibprefix}/vendor_ruby']) +vendorlibdir='${vendordir}/${ruby_version}' + +AC_ARG_WITH(vendorarchdir, + AS_HELP_STRING([--with-vendorarchdir=DIR], + [architecture dependent vendor libraries in DIR [[VENDORDIR/SITEARCH]], "no" to disable vendor directory]), + [vendorarchdir=$withval], + [vendorarchdir=${multiarch+'${rubysitearchprefix}/vendor_ruby/${ruby_version}'}${multiarch-'${vendorlibdir}/${sitearch}'}]) + +AS_IF([test "${LOAD_RELATIVE+set}"], [ + AC_DEFINE_UNQUOTED(LOAD_RELATIVE, $LOAD_RELATIVE) + RUBY_EXEC_PREFIX='' +]) + +AC_SUBST(RUBY_EXEC_PREFIX) + +AC_SUBST(libdirname, ${multiarch+arch}libdir) +AC_SUBST(archlibdir)dnl +AC_SUBST(sitearchlibdir)dnl +AC_SUBST(archincludedir)dnl +AC_SUBST(sitearchincludedir)dnl +AC_SUBST(arch)dnl +AC_SUBST(sitearch)dnl +AC_SUBST(ruby_version)dnl +AC_SUBST(rubylibdir)dnl +AC_SUBST(rubyarchdir)dnl +AC_SUBST(sitedir)dnl +AC_SUBST(sitelibdir)dnl +AC_SUBST(sitearchdir)dnl +AC_SUBST(vendordir)dnl +AC_SUBST(vendorlibdir)dnl +AC_SUBST(vendorarchdir)dnl + +AC_SUBST(CONFIGURE, "`echo $0 | sed 's|.*/||'`")dnl +AC_SUBST(configure_args, "`echo "${ac_configure_args}" | sed 's/\\$/$$/g'`")dnl + +AS_IF([test "${universal_binary-no}" = yes ], [ + arch="universal-${target_os}" + AS_IF([test "${rb_cv_architecture_available}" = yes], [ + AC_DEFINE_UNQUOTED(RUBY_PLATFORM_CPU, __ARCHITECTURE__) + ], [ + for archs in ${universal_archnames}; do + cpu=`echo $archs | sed 's/.*=//'` + archs=`echo $archs | sed 's/=.*//'` + RUBY_DEFINE_IF([defined __${archs}__ &&! defined RUBY_PLATFORM_CPU], RUBY_PLATFORM_CPU, ["${cpu}"]) + done + ]) + ints='long int short' + test "$ac_cv_type_long_long" = yes && ints="'long long' $ints" + AC_SUBST(UNIVERSAL_ARCHNAMES, "${universal_archnames}") + AC_SUBST(UNIVERSAL_INTS, "${ints}") + AC_DEFINE_UNQUOTED(RUBY_PLATFORM_OS, "${target_os}") + AC_DEFINE_UNQUOTED(RUBY_ARCH, "universal-" RUBY_PLATFORM_OS) + AC_DEFINE_UNQUOTED(RUBY_PLATFORM, "universal." RUBY_PLATFORM_CPU "-" RUBY_PLATFORM_OS) +], [ + AS_IF([test "${target_os}-${rb_cv_msvcrt}" = "mingw32-ucrt" ], [ + arch="${target_cpu}-mingw-ucrt" + ], [ + arch="${target_cpu}-${target_os}" + ]) + AC_DEFINE_UNQUOTED(RUBY_PLATFORM, "$arch") + + AS_IF([test "$arch" = "s390x-linux"], [ + AC_DEFINE_UNQUOTED(USE_MN_THREADS, 0) + ]) +]) + +unset sitearch +AS_CASE(["$target_os"],[mingw*],[sitearch="$target_cpu-$rb_cv_msvcrt"]) +: ${sitearch='${arch}'} + +AC_ARG_WITH(search-path, + AS_HELP_STRING([--with-search-path=DIR], [specify the additional search path]), + [search_path=$withval]) +AS_IF([test "$search_path" != ""], [ + AC_SUBST(RUBY_SEARCH_PATH, $search_path) +]) + +AC_ARG_WITH(rubyhdrdir, + AS_HELP_STRING([--with-rubyhdrdir=DIR], [core headers in DIR [[INCLUDEDIR/RUBY_BASE_NAME-RUBY_VERSION]]]), + [rubyhdrdir=$withval], + [rubyhdrdir='${includedir}/${RUBY_VERSION_NAME}']) + +AC_ARG_WITH(rubyarchhdrdir, + AS_HELP_STRING([--with-rubyarchhdrdir=DIR], + [architecture dependent core headers in DIR [[$(rubyhdrdir)/$(arch)]]]), + [rubyarchhdrdir=$withval], + [rubyarchhdrdir=${multiarch+'${archincludedir}/${RUBY_VERSION_NAME}'}${multiarch-'${rubyhdrdir}/${arch}'}]) + +AC_ARG_WITH(sitehdrdir, + AS_HELP_STRING([--with-sitehdrdir=DIR], [core site headers in DIR [[RUBYHDRDIR/site_ruby]]]), + [sitehdrdir=$withval], + [sitehdrdir='${rubyhdrdir}/site_ruby']) + +AC_ARG_WITH(sitearchhdrdir, + AS_HELP_STRING([--with-sitearchhdrdir=DIR], + [architecture dependent core site headers in DIR [[RUBYHDRDIR/site_ruby]]]), + [sitearchhdrdir=$withval], + [sitearchhdrdir=${multiarch+'${sitearchincludedir}/${RUBY_VERSION_NAME}/site_ruby'}${multiarch-'${sitehdrdir}/${sitearch}'}]) + +AC_ARG_WITH(vendorhdrdir, + AS_HELP_STRING([--with-vendorhdrdir=DIR], [core vendor headers in DIR [[RUBYHDRDIR/vendor_ruby]]]), + [vendorhdrdir=$withval], + [vendorhdrdir='${rubyhdrdir}/vendor_ruby']) + +AC_ARG_WITH(vendorarchhdrdir, + AS_HELP_STRING([--with-vendorarchhdrdir=DIR], + [architecture dependent core vendor headers in DIR [[RUBYHDRDIR/vendor_ruby]]]), + [vendorarchhdrdir=$withval], + [vendorarchhdrdir=${multiarch+'${sitearchincludedir}/${RUBY_VERSION_NAME}/vendor_ruby'}${multiarch-'${vendorhdrdir}/${sitearch}'}]) + +AC_SUBST(rubyhdrdir)dnl +AC_SUBST(sitehdrdir)dnl +AC_SUBST(vendorhdrdir)dnl +AC_SUBST(rubyarchhdrdir)dnl +AC_SUBST(sitearchhdrdir)dnl +AC_SUBST(vendorarchhdrdir)dnl + +AC_ARG_WITH(mantype, + AS_HELP_STRING([--with-mantype=TYPE], [specify man page type; TYPE is one of man and doc]), + [ + AS_CASE(["$withval"], + [man|man.gz|man.bz2|doc|doc.gz|doc.bz2], [MANTYPE=$withval], + [AC_MSG_ERROR(invalid man type: $withval)]) + ]) +AS_IF([test -z "$MANTYPE"], [ + dnl Looks for nroff with -mdoc support. + AC_CACHE_VAL([ac_cv_path_NROFF], [ + AC_PATH_PROGS_FEATURE_CHECK([NROFF], + [nroff awf mandoc], + [$ac_path_NROFF -mdoc ${srcdir}/man/ruby.1 \ + >/dev/null 2>&1 && + ac_cv_path_NROFF=$ac_path_NROFF \ + ac_path_NROFF_found=:], + [], ["/usr/bin:/usr/ucb"] + ) + ]) + AS_IF([test -n "$ac_cv_path_NROFF"], [ + MANTYPE=doc + ], [ + MANTYPE=man + ]) +]) +AC_SUBST(MANTYPE) + +MKMF_VERBOSE=0 +AC_ARG_ENABLE(mkmf-verbose, + AS_HELP_STRING([--enable-mkmf-verbose], [enable verbose in mkmf]), + [MKMF_VERBOSE=1], + [MKMF_VERBOSE=0]) +AC_SUBST(MKMF_VERBOSE) + +AC_ARG_ENABLE(rubygems, + AS_HELP_STRING([--disable-rubygems], [disable rubygems by default]), + [enable_rubygems="$enableval"], [enable_rubygems=yes]) +AS_IF([test x"$enable_rubygems" = xno], [ + USE_RUBYGEMS=no +], [ + USE_RUBYGEMS=yes +]) +AC_SUBST(USE_RUBYGEMS) + +m4_define(available_parsers, [parse.y, prism]) +AC_ARG_WITH(parser, + AS_HELP_STRING([--with-parser=PARSER], + [specify default parser; PARSER is one of ]m4_join([, ],available_parsers)), + [], [with_parser=prism]) +AS_CASE([$with_parser], +m4_foreach(parser, [available_parsers], + parser[,][AC_DEFINE_UNQUOTED(RB_DEFAULT_PARSER, RB_DEFAULT_PARSER_[]AS_TR_CPP(parser)),]) + [AC_MSG_ERROR([Unknown parser: $with_parser])] +) + +# Use the ruby allocator for prism. See prism/defines.h +RUBY_APPEND_OPTIONS(XCFLAGS, -DPRISM_XALLOCATOR) + +arch_hdrdir="${EXTOUT}/include/${arch}/ruby" +AS_MKDIR_P("${arch_hdrdir}") +config_h="${arch_hdrdir}/config.h" +guard=INCLUDE_RUBY_CONFIG_H +{ + echo "#ifndef $guard" + echo "#define $guard 1" + sed "/^@%:@define PACKAGE_/d;s/ *$//" confdefs.h + echo "#endif /* $guard */" +} | tr -d '\015' | +( + AS_IF([test "x$CONFIGURE_TTY" = xyes], [color=--color], [color=]) + exec ${SHELL} ${tooldir}/ifchange $color "${config_h}" - +) >&AS_MESSAGE_FD || AC_MSG_ERROR([failed to create ${config_h}]) +tr -d '\015' < largefile.h > confdefs.h +rm largefile.h + +BUILTIN_ENCS=["`sed -n -e '/^BUILTIN_ENCS[ ]*=/{' \ + -e s/// -e :l -e '/\\\\$/N' -e 's/\\\\\\n/ /' -e 't l' -e p \ + -e '}' "${srcdir}/enc/Makefile.in"`"] +BUILTIN_ENCOBJS= +for e in $BUILTIN_ENCS; do BUILTIN_ENCOBJS="$BUILTIN_ENCOBJS "`echo $e | sed 's/\.c$/.$(OBJEXT)/'`; done +AC_SUBST(BUILTIN_ENCOBJS) + +BUILTIN_TRANSES=["`sed -n -e '/^BUILTIN_TRANSES[ ]*=/{' \ + -e s/// -e :l -e '/\\\\$/N' -e 's/\\\\\\n/ /' -e 't l' -e p \ + -e '}' "${srcdir}/enc/Makefile.in"`"] +BUILTIN_TRANSSRCS= +BUILTIN_TRANSOBJS= +for e in $BUILTIN_TRANSES; do + BUILTIN_TRANSSRCS="$BUILTIN_TRANSSRCS "`echo $e | sed 's/\.trans$/.c/'` + BUILTIN_TRANSOBJS="$BUILTIN_TRANSOBJS "`echo $e | sed 's/\.trans$/.$(OBJEXT)/'` +done +AC_SUBST(BUILTIN_TRANSSRCS) +AC_SUBST(BUILTIN_TRANSOBJS) + +PACKAGE=$RUBY_BASE_NAME +AC_SUBST(PACKAGE) +AS_MESSAGE([$PACKAGE library version = $ruby_version]) + +AS_IF([test x"$CC_WRAPPER" != x], [ + CC='$(CC_WRAPPER) '"${CC@%:@$CC_WRAPPER }" + CPP='$(CC_WRAPPER) '"${CPP@%:@$CC_WRAPPER }" + XCC_WRAPPER="$CC_WRAPPER" +]) +AC_SUBST(CC_WRAPPER, '') +AC_SUBST(XCC_WRAPPER) + +AS_CASE([" $CPP "], [*" $CC "*], [CPP=`echo " $CPP " | sed "s| $CC |"' $(CC) |;s/^ *//;s/ *$//'`]) + +AS_IF([test ! -f "$srcdir/revision.h"], [ + AS_IF([test "x$HAVE_BASERUBY" = xyes], [ + ${BASERUBY} -C "$srcdir" tool/file2lastrev.rb -q --revision.h > "$srcdir/revision.h" + ], [ + touch "$srcdir/revision.h" + ]) +]) + +AS_IF([test x"$firstmf" != x], [ + AC_CONFIG_FILES($firstmf:$firsttmpl, [], [firstmf="$firstmf" firsttmpl="$firsttmpl"]) +]) +AC_CONFIG_FILES(Makefile:template/Makefile.in, [ + tmpmk=confmk$$.tmp + { + AS_IF([test ${VCS+set}], [ + : + ], [git_dir=`$GIT --work-tree="$srcdir" --git-dir="$srcdir/.git" rev-parse --git-dir 2>/dev/null`], [ + VCS='$(GIT)' + ], [ + VCS='echo cannot' + ]) + AS_CASE("$VCS", + ['$(GIT)'|git], [VCSUP='$(VCS) pull --rebase $(GITPULLOPTIONS)'], + [VCSUP='$(VCS)']) + for f in "$srcdir/version.h" "$srcdir/revision.h"; do + test -f "$f" || continue + sed -n \ + -e '[/^@%:@define \(RUBY_RELEASE_[A-Z]*\) \([0-9][0-9]*\)/]{' \ + -e 's//\1 = \2/' \ + -e '[s/ \([0-9]\)$/ 0\1/]' \ + -e p \ + -e '}' "$f" + done + sed '/^MISSING/s/\$U\././g;/^VCS *=/s#@VCS@#'"$VCS"'#;/^VCSUP *=/s#@VCSUP@#'"$VCSUP"'#' Makefile + echo; test x"$EXEEXT" = x || echo 'miniruby: miniruby$(EXEEXT)' + AS_IF([test "$gnumake" != yes], [ + # extract NMake-style include list + set = `sed -n 's/^!include *//p' ${srcdir}/common.mk` + echo common_mk_includes "@S|@*" # generate the macro assignment + shift + common_mk_includes="`echo \"@S|@*\" | sed 's|\$(srcdir)|.|g'`" + (PWD= cd ${srcdir} && sed -f tool/prereq.status common.mk ${common_mk_includes}) + AS_IF([test "$YJIT_SUPPORT" = yes], [ + cat ${srcdir}/yjit/not_gmake.mk + echo ['$(MKFILES): ${srcdir}/yjit/not_gmake.mk'] + ]) + ], [ + echo 'distclean-local::; @$(RM) GNUmakefile uncommon.mk' + ]) + + echo; echo '$(srcdir)/$(CONFIGURE):RUBY_M4_INCLUDED \ + $(empty)' + } > $tmpmk && mv -f $tmpmk Makefile], +[EXEEXT='$EXEEXT' MAKE='${MAKE-make}' gnumake='$gnumake' GIT='$GIT' YJIT_SUPPORT='$YJIT_SUPPORT']) + +AC_ARG_WITH([ruby-pc], + AS_HELP_STRING([--with-ruby-pc=FILENAME], [pc file basename]), + [ruby_pc="$withval"], + [ruby_pc="${RUBY_BASE_NAME}-${MAJOR}.${MINOR}.pc"]) +AC_SUBST(ruby_pc) +AC_SUBST(exec, [exec]) + +AC_ARG_WITH(destdir, + AS_HELP_STRING([--with-destdir=DESTDIR], [specify default directory to install]), + [DESTDIR="$withval"]) +AC_SUBST(DESTDIR) + +AS_IF([test "x$load_relative:$DESTDIR" = xyes:], [ + AS_IF([test "x$prefix" = xNONE], [DESTDIR="$ac_default_prefix"], [DESTDIR="$prefix"]) + prefix=/. +]) + +AC_OUTPUT +} + +AS_IF([test "$silent" = yes], [], [ +AS_IF([${FOLD+:} false], [], [ +AS_IF([test "`echo abcdefg hijklmno | fold -s -w10 | sed 1d`" = hijklmno], [FOLD="fold"], [FOLD=]) +]) +fold_width=`expr $COLUMNS - 30 2>/dev/null` || fold_width=50 +AS_REQUIRE_SHELL_FN([config_summary], + [AS_FUNCTION_DESCRIBE([config_summary], [NAME, VAL], [configuration summary])], + [AS_IF([test -z "$2"], [], [ + AS_ECHO_N([" * $1: "]) | dd bs=1 count=26 2>/dev/null + AS_IF([test "$FOLD"], [ + echo "$2" | fold -s -w$fold_width | + sed '1!s/^/ /;$!s/$/\\/' + ], [echo "$2"]) + ])] +) + +AS_IF([test $install_doc = yes], + [DOCTARGETS=`echo " $RDOCTARGET $CAPITARGET " | sed 's/ nodoc //g;s/^ *//;s/ *$//'`], + [DOCTARGETS=no]) +echo "---" +echo "Configuration summary for $RUBY_BASE_NAME version $MAJOR.$MINOR.$TEENY" +echo "" +config_summary "Installation prefix" "$prefix" +config_summary "exec prefix" "$exec_prefix" +config_summary "arch" "$arch" +config_summary "site arch" "$sitearch" +config_summary "RUBY_BASE_NAME" "$RUBY_BASE_NAME" +config_summary "enable shared" "$enable_shared" +config_summary "ruby lib prefix" "$rubylibprefix" +config_summary "site libraries path" "$rubysitearchprefix" +config_summary "vendor path" "$vendordir" +config_summary "target OS" "$target_os" +config_summary "compiler" "$CC" +config_summary "with thread" "$THREAD_MODEL" +config_summary "with coroutine" "$coroutine_type" +config_summary "with modular GC" "$modular_gc_summary" +config_summary "enable shared libs" "$ENABLE_SHARED" +config_summary "dynamic library ext" "$DLEXT" +config_summary "CFLAGS" "$cflags" +config_summary "CPPFLAGS" "$cppflags" +config_summary "LDFLAGS" "$LDFLAGS" +config_summary "DLDFLAGS" "$DLDFLAGS" +config_summary "optflags" "$optflags" +config_summary "debugflags" "$debugflags" +config_summary "warnflags" "$warnflags" +config_summary "hardenflags" "$hardenflags" +config_summary "strip command" "$STRIP" +config_summary "install doc" "$DOCTARGETS" +config_summary "YJIT support" "$YJIT_SUPPORT" +config_summary "ZJIT support" "$ZJIT_SUPPORT" +config_summary "RUSTC_FLAGS" "$RUSTC_FLAGS" +config_summary "man page type" "$MANTYPE" +config_summary "search path" "$search_path" +config_summary "static-linked-ext" ${EXTSTATIC:+"yes"} +config_summary "BASERUBY -v" "$BASERUBY_VERSION" +echo "" +echo "---" +]) |