# ===========================================================================

#     http://www.gnu.org/software/autoconf-archive/ax_sys_weak_alias.html

# ===========================================================================

#

# SYNOPSIS

#

#   AX_SYS_WEAK_ALIAS

#

# DESCRIPTION

#

#   Determines whether weak aliases are supported on the system, and if so,

#   what scheme is used to declare them. Also checks to see if aliases can

#   cross object file boundaries, as some systems don't permit them to.

#

#   Most systems permit something called a "weak alias" or "weak symbol."

#   These aliases permit a library to provide a stub form of a routine

#   defined in another library, thus allowing the first library to operate

#   even if the other library is not linked. This macro will check for

#   support of weak aliases, figure out what schemes are available, and

#   determine some characteristics of the weak alias support -- primarily,

#   whether a weak alias declared in one object file may be referenced from

#   another object file.

#

#   There are four known schemes of declaring weak symbols; each scheme is

#   checked in turn, and the first one found is prefered. Note that only one

#   of the mentioned preprocessor macros will be defined!

#

#   1. Function attributes

#

#   This scheme was first introduced by the GNU C compiler, and attaches

#   attributes to particular functions. It is among the easiest to use, and

#   so is the first one checked. If this scheme is detected, the

#   preprocessor macro HAVE_SYS_WEAK_ALIAS_ATTRIBUTE will be defined to 1.

#   This scheme is used as in the following code fragment:

#

#     void __weakf(int c)

#     {

#       /* Function definition... */

#     }

#

#     void weakf(int c) __attribute__((weak, alias("__weakf")));

#

#   2. #pragma weak

#

#   This scheme is in use by many compilers other than the GNU C compiler.

#   It is also particularly easy to use, and fairly portable -- well, as

#   portable as these things get. If this scheme is detected first, the

#   preprocessor macro HAVE_SYS_WEAK_ALIAS_PRAGMA will be defined to 1. This

#   scheme is used as in the following code fragment:

#

#     extern void weakf(int c);

#     #pragma weak weakf = __weakf

#     void __weakf(int c)

#     {

#       /* Function definition... */

#     }

#

#   3. #pragma _HP_SECONDARY_DEF

#

#   This scheme appears to be in use by the HP compiler. As it is rather

#   specialized, this is one of the last schemes checked. If it is the first

#   one detected, the preprocessor macro HAVE_SYS_WEAK_ALIAS_HPSECONDARY

#   will be defined to 1. This scheme is used as in the following code

#   fragment:

#

#     extern void weakf(int c);

#     #pragma _HP_SECONDARY_DEF __weakf weakf

#     void __weakf(int c)

#     {

#       /* Function definition... */

#     }

#

#   4. #pragma _CRI duplicate

#

#   This scheme appears to be in use by the Cray compiler. As it is rather

#   specialized, it too is one of the last schemes checked. If it is the

#   first one detected, the preprocessor macro

#   HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE will be defined to 1. This scheme is

#   used as in the following code fragment:

#

#     extern void weakf(int c);

#     #pragma _CRI duplicate weakf as __weakf

#     void __weakf(int c)

#     {

#       /* Function definition... */

#     }

#

#   In addition to the preprocessor macros listed above, if any scheme is

#   found, the preprocessor macro HAVE_SYS_WEAK_ALIAS will also be defined

#   to 1.

#

#   Once a weak aliasing scheme has been found, a check will be performed to

#   see if weak aliases are honored across object file boundaries. If they

#   are, the HAVE_SYS_WEAK_ALIAS_CROSSFILE preprocessor macro is defined to

#   1.

#

#   This Autoconf macro also makes two substitutions. The first, WEAK_ALIAS,

#   contains the name of the scheme found (one of "attribute", "pragma",

#   "hpsecondary", or "criduplicate"), or "no" if no weak aliasing scheme

#   was found. The second, WEAK_ALIAS_CROSSFILE, is set to "yes" or "no"

#   depending on whether or not weak aliases may cross object file

#   boundaries.

#

# LICENSE

#

#   Copyright (c) 2008 Kevin L. Mitchell <klmitch@mit.edu>

#

#   Copying and distribution of this file, with or without modification, are

#   permitted in any medium without royalty provided the copyright notice

#   and this notice are preserved. This file is offered as-is, without any

#   warranty.

#serial 6

AU_ALIAS([KLM_SYS_WEAK_ALIAS], [AX_SYS_WEAK_ALIAS])

AC_DEFUN([AX_SYS_WEAK_ALIAS], [

  # starting point: no aliasing scheme yet...

  ax_sys_weak_alias=no

  # Figure out what kind of aliasing may be supported...

  _AX_SYS_WEAK_ALIAS_ATTRIBUTE

  _AX_SYS_WEAK_ALIAS_PRAGMA

  _AX_SYS_WEAK_ALIAS_HPSECONDARY

  _AX_SYS_WEAK_ALIAS_CRIDUPLICATE

  # Do we actually support aliasing?

  AC_CACHE_CHECK([how to create weak aliases with $CC],

                 [ax_cv_sys_weak_alias],

                 [ax_cv_sys_weak_alias=$ax_sys_weak_alias])

  # OK, set a #define

  AS_IF([test $ax_cv_sys_weak_alias != no], [

    AC_DEFINE([HAVE_SYS_WEAK_ALIAS], 1,

              [Define this if your system can create weak aliases])

  ])

  # Can aliases cross object file boundaries?

  _AX_SYS_WEAK_ALIAS_CROSSFILE

  # OK, remember the results

  AC_SUBST([WEAK_ALIAS], [$ax_cv_sys_weak_alias])

  AC_SUBST([WEAK_ALIAS_CROSSFILE], [$ax_cv_sys_weak_alias_crossfile])

])

AC_DEFUN([_AX_SYS_WEAK_ALIAS_ATTRIBUTE],

[ # Test whether compiler accepts __attribute__ form of weak aliasing

  AC_CACHE_CHECK([whether $CC accepts function __attribute__((weak,alias()))],

  [ax_cv_sys_weak_alias_attribute], [

    # We add -Werror if it's gcc to force an error exit if the weak attribute

    # isn't understood

    AS_IF([test $GCC = yes], [

      save_CFLAGS=$CFLAGS

      CFLAGS=-Werror])

    # Try linking with a weak alias...

    AC_LINK_IFELSE([

      AC_LANG_PROGRAM([

void __weakf(int c) {}

void weakf(int c) __attribute__((weak, alias("__weakf")));],

        [weakf(0)])],

      [ax_cv_sys_weak_alias_attribute=yes],

      [ax_cv_sys_weak_alias_attribute=no])

    # Restore original CFLAGS

    AS_IF([test $GCC = yes], [

      CFLAGS=$save_CFLAGS])

  ])

  # What was the result of the test?

  AS_IF([test $ax_sys_weak_alias = no &&

         test $ax_cv_sys_weak_alias_attribute = yes], [

    ax_sys_weak_alias=attribute

    AC_DEFINE([HAVE_SYS_WEAK_ALIAS_ATTRIBUTE], 1,

              [Define this if weak aliases may be created with __attribute__])

  ])

])

AC_DEFUN([_AX_SYS_WEAK_ALIAS_PRAGMA],

[ # Test whether compiler accepts #pragma form of weak aliasing

  AC_CACHE_CHECK([whether $CC supports @%:@pragma weak],

  [ax_cv_sys_weak_alias_pragma], [

    # Try linking with a weak alias...

    AC_LINK_IFELSE([

      AC_LANG_PROGRAM([

extern void weakf(int c);

@%:@pragma weak weakf = __weakf

void __weakf(int c) {}],

        [weakf(0)])],

      [ax_cv_sys_weak_alias_pragma=yes],

      [ax_cv_sys_weak_alias_pragma=no])

  ])

  # What was the result of the test?

  AS_IF([test $ax_sys_weak_alias = no &&

         test $ax_cv_sys_weak_alias_pragma = yes], [

    ax_sys_weak_alias=pragma

    AC_DEFINE([HAVE_SYS_WEAK_ALIAS_PRAGMA], 1,

              [Define this if weak aliases may be created with @%:@pragma weak])

  ])

])

AC_DEFUN([_AX_SYS_WEAK_ALIAS_HPSECONDARY],

[ # Test whether compiler accepts _HP_SECONDARY_DEF pragma from HP...

  AC_CACHE_CHECK([whether $CC supports @%:@pragma _HP_SECONDARY_DEF],

  [ax_cv_sys_weak_alias_hpsecondary], [

    # Try linking with a weak alias...

    AC_LINK_IFELSE([

      AC_LANG_PROGRAM([

extern void weakf(int c);

@%:@pragma _HP_SECONDARY_DEF __weakf weakf

void __weakf(int c) {}],

        [weakf(0)])],

      [ax_cv_sys_weak_alias_hpsecondary=yes],

      [ax_cv_sys_weak_alias_hpsecondary=no])

  ])

  # What was the result of the test?

  AS_IF([test $ax_sys_weak_alias = no &&

         test $ax_cv_sys_weak_alias_hpsecondary = yes], [

    ax_sys_weak_alias=hpsecondary

    AC_DEFINE([HAVE_SYS_WEAK_ALIAS_HPSECONDARY], 1,

              [Define this if weak aliases may be created with @%:@pragma _HP_SECONDARY_DEF])

  ])

])

AC_DEFUN([_AX_SYS_WEAK_ALIAS_CRIDUPLICATE],

[ # Test whether compiler accepts "_CRI duplicate" pragma from Cray

  AC_CACHE_CHECK([whether $CC supports @%:@pragma _CRI duplicate],

  [ax_cv_sys_weak_alias_criduplicate], [

    # Try linking with a weak alias...

    AC_LINK_IFELSE([

      AC_LANG_PROGRAM([

extern void weakf(int c);

@%:@pragma _CRI duplicate weakf as __weakf

void __weakf(int c) {}],

        [weakf(0)])],

      [ax_cv_sys_weak_alias_criduplicate=yes],

      [ax_cv_sys_weak_alias_criduplicate=no])

  ])

  # What was the result of the test?

  AS_IF([test $ax_sys_weak_alias = no &&

         test $ax_cv_sys_weak_alias_criduplicate = yes], [

    ax_sys_weak_alias=criduplicate

    AC_DEFINE([HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE], 1,

              [Define this if weak aliases may be created with @%:@pragma _CRI duplicate])

  ])

])

dnl Note: This macro is modeled closely on AC_LINK_IFELSE, and in fact

dnl depends on some implementation details of that macro, particularly

dnl its use of _AC_MSG_LOG_CONFTEST to log the failed test program and

dnl its use of ac_link for running the linker.

AC_DEFUN([_AX_SYS_WEAK_ALIAS_CROSSFILE],

[ # Check to see if weak aliases can cross object file boundaries

  AC_CACHE_CHECK([whether $CC supports weak aliases across object file boundaries],

  [ax_cv_sys_weak_alias_crossfile], [

    AS_IF([test $ax_cv_sys_weak_alias = no],

          [ax_cv_sys_weak_alias_crossfile=no], [

dnl Must build our own test files...

      # conftest1 contains our weak alias definition...

      cat >conftest1.$ac_ext <<_ACEOF

/* confdefs.h.  */

_ACEOF

      cat confdefs.h >>conftest1.$ac_ext

      cat >>conftest1.$ac_ext <<_ACEOF

/* end confdefs.h.  */

@%:@ifndef HAVE_SYS_WEAK_ALIAS_ATTRIBUTE

extern void weakf(int c);

@%:@endif

@%:@if defined(HAVE_SYS_WEAK_ALIAS_PRAGMA)

@%:@pragma weak weakf = __weakf

@%:@elif defined(HAVE_SYS_WEAK_ALIAS_HPSECONDARY)

@%:@pragma _HP_SECONDARY_DEF __weakf weakf

@%:@elif defined(HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE)

@%:@pragma _CRI duplicate weakf as __weakf

@%:@endif

void __weakf(int c) {}

@%:@ifdef HAVE_SYS_WEAK_ALIAS_ATTRIBUTE

void weakf(int c) __attribute((weak, alias("__weakf")));

@%:@endif

_ACEOF

      # And conftest2 contains our main routine that calls it

      cat >conftest2.$ac_ext <<_ACEOF

/* confdefs.h.  */

_ACEOF

      cat confdefs.h >> conftest2.$ac_ext

      cat >>conftest2.$ac_ext <<_ACEOF

/* end confdefs.h.  */

extern void weakf(int c);

int

main ()

{

  weakf(0);

  return 0;

}

_ACEOF

      # We must remove the object files (if any) ourselves...

      rm -f conftest2.$ac_objext conftest$ac_exeext

      # Change ac_link to compile *2* files together

      save_aclink=$ac_link

      ac_link=`echo "$ac_link" | \

               sed -e 's/conftest\(\.\$ac_ext\)/conftest1\1 conftest2\1/'`

dnl Substitute our own routine for logging the conftest

m4_pushdef([_AC_MSG_LOG_CONFTEST],

[echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD

echo ">>> conftest1.$ac_ext" >&AS_MESSAGE_LOG_FD

sed "s/^/| /" conftest1.$ac_ext >&AS_MESSAGE_LOG_FD

echo ">>> conftest2.$ac_ext" >&AS_MESSAGE_LOG_FD

sed "s/^/| /" conftest2.$ac_ext >&AS_MESSAGE_LOG_FD

])dnl

      # Since we created the files ourselves, don't use SOURCE argument

      AC_LINK_IFELSE(, [ax_cv_sys_weak_alias_crossfile=yes],

                     [ax_cv_sys_weak_alias_crossfile=no])

dnl Restore _AC_MSG_LOG_CONFTEST

m4_popdef([_AC_MSG_LOG_CONFTEST])dnl

      # Restore ac_link

      ac_link=$save_aclink

      # We must remove the object files (if any) and C files ourselves...

      rm -f conftest1.$ac_ext conftest2.$ac_ext \

            conftest1.$ac_objext conftest2.$ac_objext

    ])

  ])

  # What were the results of the test?

  AS_IF([test $ax_cv_sys_weak_alias_crossfile = yes], [

    AC_DEFINE([HAVE_SYS_WEAK_ALIAS_CROSSFILE], 1,

              [Define this if weak aliases in other files are honored])

  ])

])