mariadb/storage/innodb_plugin/plug.in

#
# Copyright (c) 2006, 2010, Innobase Oy. All Rights Reserved.
# 
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation; version 2 of the License.
# 
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 59 Temple
# Place, Suite 330, Boston, MA 02111-1307 USA
#

MYSQL_STORAGE_ENGINE(innodb_plugin,, [InnoDB Storage Engine],
        [Transactional Tables using InnoDB], [])
MYSQL_PLUGIN_DIRECTORY(innodb_plugin, [storage/innodb_plugin])
MYSQL_PLUGIN_DYNAMIC(innodb_plugin,  [ha_innodb_plugin.la])
MYSQL_PLUGIN_ACTIONS(innodb_plugin,  [
  AC_CHECK_HEADERS(sched.h)
  AC_CHECK_SIZEOF(int, 4)
  AC_CHECK_SIZEOF(long, 4)
  AC_CHECK_SIZEOF(void*, 4)
  AC_CHECK_FUNCS(sched_yield fdatasync localtime_r)
  AC_C_BIGENDIAN
  case "$target_os" in
	lin*)
		CFLAGS="$CFLAGS -DUNIV_LINUX";;
	hpux10*)
		CFLAGS="$CFLAGS -DUNIV_MUST_NOT_INLINE -DUNIV_HPUX -DUNIV_HPUX10";;
	hp*)
		CFLAGS="$CFLAGS -DUNIV_MUST_NOT_INLINE -DUNIV_HPUX";;
	aix*)
		CFLAGS="$CFLAGS -DUNIV_AIX";;
	irix*|osf*|sysv5uw7*|openbsd*)
		CFLAGS="$CFLAGS -DUNIV_MUST_NOT_INLINE";;
	*solaris*|*SunOS*)
		CFLAGS="$CFLAGS -DUNIV_SOLARIS";;
  esac

  INNODB_DYNAMIC_CFLAGS="-DMYSQL_DYNAMIC_PLUGIN"

  case "$target_cpu" in
	x86_64)
		# The AMD64 ABI forbids absolute addresses in shared libraries
		;;
	*86)
		# Use absolute addresses on IA-32
		INNODB_DYNAMIC_CFLAGS="$INNODB_DYNAMIC_CFLAGS -prefer-non-pic"
		;;
  esac
  AC_SUBST(INNODB_DYNAMIC_CFLAGS)

  AC_MSG_CHECKING(whether GCC atomic builtins are available)
  # either define HAVE_IB_GCC_ATOMIC_BUILTINS or not
  AC_TRY_RUN(
    [
      int main()
      {
	long	x;
	long	y;
	long	res;
	char	c;

	x = 10;
	y = 123;
	res = __sync_bool_compare_and_swap(&x, x, y);
	if (!res || x != y) {
          return(1);
        }

	x = 10;
	y = 123;
	res = __sync_bool_compare_and_swap(&x, x + 1, y);
	if (res || x != 10) {
          return(1);
        }

	x = 10;
	y = 123;
	res = __sync_add_and_fetch(&x, y);
	if (res != 123 + 10 || x != 123 + 10) {
	  return(1);
	}

	c = 10;
	res = __sync_lock_test_and_set(&c, 123);
	if (res != 10 || c != 123) {
	  return(1);
	}

	return(0);
      }
    ],
    [
      AC_DEFINE([HAVE_IB_GCC_ATOMIC_BUILTINS], [1],
                [GCC atomic builtins are available])
      AC_MSG_RESULT(yes)
    ],
    [
      AC_MSG_RESULT(no)
    ]
  )

  AC_MSG_CHECKING(whether pthread_t can be used by GCC atomic builtins)
  # either define HAVE_IB_ATOMIC_PTHREAD_T_GCC or not
  AC_TRY_RUN(
    [
      #include <pthread.h>
      #include <string.h>

      int main(int argc, char** argv) {
        pthread_t       x1;
        pthread_t       x2;
        pthread_t       x3;

	memset(&x1, 0x0, sizeof(x1));
	memset(&x2, 0x0, sizeof(x2));
	memset(&x3, 0x0, sizeof(x3));

        __sync_bool_compare_and_swap(&x1, x2, x3);

        return(0);
      }
    ],
    [
      AC_DEFINE([HAVE_IB_ATOMIC_PTHREAD_T_GCC], [1],
                [pthread_t can be used by GCC atomic builtins])
      AC_MSG_RESULT(yes)
    ],
    [
      AC_MSG_RESULT(no)
    ]
  )

  AC_MSG_CHECKING(whether Solaris libc atomic functions are available)
  # either define HAVE_IB_SOLARIS_ATOMICS or not
  AC_CHECK_FUNCS(atomic_add_long \
		 atomic_cas_32 \
		 atomic_cas_64 \
		 atomic_cas_ulong,

		 AC_DEFINE([HAVE_IB_SOLARIS_ATOMICS], [1],
			   [Define to 1 if Solaris libc atomic functions \
			    are available])
  )

  AC_MSG_CHECKING(whether pthread_t can be used by Solaris libc atomic functions)
  # either define HAVE_IB_ATOMIC_PTHREAD_T_SOLARIS or not
  AC_TRY_RUN(
    [
      #include <pthread.h>
      #include <string.h>

      int main(int argc, char** argv) {
        pthread_t       x1;
        pthread_t       x2;
        pthread_t       x3;

        memset(&x1, 0x0, sizeof(x1));
        memset(&x2, 0x0, sizeof(x2));
        memset(&x3, 0x0, sizeof(x3));

        if (sizeof(pthread_t) == 4) {
        
          atomic_cas_32(&x1, x2, x3);
        
        } else if (sizeof(pthread_t) == 8) {
        
          atomic_cas_64(&x1, x2, x3);
        
        } else {
        
          return(1);
        }

	return(0);
      }
    ],
    [
      AC_DEFINE([HAVE_IB_ATOMIC_PTHREAD_T_SOLARIS], [1],
                [pthread_t can be used by solaris atomics])
      AC_MSG_RESULT(yes)
    ],
    [
      AC_MSG_RESULT(no)
    ]
  )

  # this is needed to know which one of atomic_cas_32() or atomic_cas_64()
  # to use in the source
  AC_CHECK_SIZEOF([pthread_t], [], [#include <pthread.h>])

  # Check for x86 PAUSE instruction
  AC_MSG_CHECKING(for x86 PAUSE instruction)
  # We have to actually try running the test program, because of a bug
  # in Solaris on x86_64, where it wrongly reports that PAUSE is not
  # supported when trying to run an application. See
  # http://bugs.opensolaris.org/bugdatabase/printableBug.do?bug_id=6478684
  # We use ib_ prefix to avoid collisoins if this code is added to
  # mysql's configure.in.
  AC_TRY_RUN(
    [
      int main() {
        __asm__ __volatile__ ("pause");
        return(0);
      }
    ],
    [
      AC_DEFINE([HAVE_IB_PAUSE_INSTRUCTION], [1], [Does x86 PAUSE instruction exist])
      AC_MSG_RESULT(yes)
    ],
    [
      AC_MSG_RESULT(no)
    ],
    [
      AC_MSG_RESULT(no)
    ]
  )
  ])

# vim: set ft=config: