[mirror_frr.git] / m4 / ax_sys_weak_alias.m4

# ===========================================================================
# 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 preferred. 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_cv_sys_weak_alias_attribute = yes], [
    test $ax_sys_weak_alias = no && 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_cv_sys_weak_alias_pragma = yes], [
    test $ax_sys_weak_alias = no && 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_cv_sys_weak_alias_hpsecondary = yes], [
    test $ax_sys_weak_alias = no && 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_cv_sys_weak_alias_criduplicate = yes], [
    test $ax_sys_weak_alias = no && 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);
@%:@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
@%:@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])
  ])
])
Commit	Line	Data
327c4cdf DV	1	# ===========================================================================
	2	# http://www.gnu.org/software/autoconf-archive/ax_sys_weak_alias.html
	3	# ===========================================================================
	4	#
	5	# SYNOPSIS
	6	#
	7	# AX_SYS_WEAK_ALIAS
	8	#
	9	# DESCRIPTION
	10	#
	11	# Determines whether weak aliases are supported on the system, and if so,
	12	# what scheme is used to declare them. Also checks to see if aliases can
	13	# cross object file boundaries, as some systems don't permit them to.
	14	#
	15	# Most systems permit something called a "weak alias" or "weak symbol."
	16	# These aliases permit a library to provide a stub form of a routine
	17	# defined in another library, thus allowing the first library to operate
	18	# even if the other library is not linked. This macro will check for
	19	# support of weak aliases, figure out what schemes are available, and
	20	# determine some characteristics of the weak alias support -- primarily,
	21	# whether a weak alias declared in one object file may be referenced from
	22	# another object file.
	23	#
	24	# There are four known schemes of declaring weak symbols; each scheme is
0437e105	25	# checked in turn, and the first one found is preferred. Note that only one
327c4cdf DV	26	# of the mentioned preprocessor macros will be defined!
	27	#
	28	# 1. Function attributes
	29	#
	30	# This scheme was first introduced by the GNU C compiler, and attaches
	31	# attributes to particular functions. It is among the easiest to use, and
	32	# so is the first one checked. If this scheme is detected, the
	33	# preprocessor macro HAVE_SYS_WEAK_ALIAS_ATTRIBUTE will be defined to 1.
	34	# This scheme is used as in the following code fragment:
	35	#
	36	# void __weakf(int c)
	37	# {
	38	# /* Function definition... */
	39	# }
	40	#
	41	# void weakf(int c) __attribute__((weak, alias("__weakf")));
	42	#
	43	# 2. #pragma weak
	44	#
	45	# This scheme is in use by many compilers other than the GNU C compiler.
	46	# It is also particularly easy to use, and fairly portable -- well, as
	47	# portable as these things get. If this scheme is detected first, the
	48	# preprocessor macro HAVE_SYS_WEAK_ALIAS_PRAGMA will be defined to 1. This
	49	# scheme is used as in the following code fragment:
	50	#
	51	# extern void weakf(int c);
	52	# #pragma weak weakf = __weakf
	53	# void __weakf(int c)
	54	# {
	55	# /* Function definition... */
	56	# }
	57	#
	58	# 3. #pragma _HP_SECONDARY_DEF
	59	#
	60	# This scheme appears to be in use by the HP compiler. As it is rather
	61	# specialized, this is one of the last schemes checked. If it is the first
	62	# one detected, the preprocessor macro HAVE_SYS_WEAK_ALIAS_HPSECONDARY
	63	# will be defined to 1. This scheme is used as in the following code
	64	# fragment:
	65	#
	66	# extern void weakf(int c);
	67	# #pragma _HP_SECONDARY_DEF __weakf weakf
	68	# void __weakf(int c)
	69	# {
	70	# /* Function definition... */
	71	# }
	72	#
	73	# 4. #pragma _CRI duplicate
	74	#
	75	# This scheme appears to be in use by the Cray compiler. As it is rather
	76	# specialized, it too is one of the last schemes checked. If it is the
	77	# first one detected, the preprocessor macro
	78	# HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE will be defined to 1. This scheme is
	79	# used as in the following code fragment:
	80	#
	81	# extern void weakf(int c);
	82	# #pragma _CRI duplicate weakf as __weakf
	83	# void __weakf(int c)
	84	# {
	85	# /* Function definition... */
	86	# }
	87	#
	88	# In addition to the preprocessor macros listed above, if any scheme is
	89	# found, the preprocessor macro HAVE_SYS_WEAK_ALIAS will also be defined
90	# to 1.
91	#
92	# Once a weak aliasing scheme has been found, a check will be performed to
93	# see if weak aliases are honored across object file boundaries. If they
94	# are, the HAVE_SYS_WEAK_ALIAS_CROSSFILE preprocessor macro is defined to
95	# 1.
96	#
97	# This Autoconf macro also makes two substitutions. The first, WEAK_ALIAS,
98	# contains the name of the scheme found (one of "attribute", "pragma",
99	# "hpsecondary", or "criduplicate"), or "no" if no weak aliasing scheme
100	# was found. The second, WEAK_ALIAS_CROSSFILE, is set to "yes" or "no"
101	# depending on whether or not weak aliases may cross object file
102	# boundaries.
103	#
104	# LICENSE
105	#
106	# Copyright (c) 2008 Kevin L. Mitchell <klmitch@mit.edu>
107	#
108	# Copying and distribution of this file, with or without modification, are
109	# permitted in any medium without royalty provided the copyright notice
110	# and this notice are preserved. This file is offered as-is, without any
111	# warranty.
112
113	#serial 6
114
115	AU_ALIAS([KLM_SYS_WEAK_ALIAS], [AX_SYS_WEAK_ALIAS])
116	AC_DEFUN([AX_SYS_WEAK_ALIAS], [
117	# starting point: no aliasing scheme yet...
118	ax_sys_weak_alias=no
119
120	# Figure out what kind of aliasing may be supported...
121	_AX_SYS_WEAK_ALIAS_ATTRIBUTE
122	_AX_SYS_WEAK_ALIAS_PRAGMA
123	_AX_SYS_WEAK_ALIAS_HPSECONDARY
124	_AX_SYS_WEAK_ALIAS_CRIDUPLICATE
125
126	# Do we actually support aliasing?
127	AC_CACHE_CHECK([how to create weak aliases with $CC],
128	[ax_cv_sys_weak_alias],
129	[ax_cv_sys_weak_alias=$ax_sys_weak_alias])
130
131	# OK, set a #define
132	AS_IF([test $ax_cv_sys_weak_alias != no], [
133	AC_DEFINE([HAVE_SYS_WEAK_ALIAS], 1,
134	[Define this if your system can create weak aliases])
135	])
136
137	# Can aliases cross object file boundaries?
138	_AX_SYS_WEAK_ALIAS_CROSSFILE
139
140	# OK, remember the results
141	AC_SUBST([WEAK_ALIAS], [$ax_cv_sys_weak_alias])
142	AC_SUBST([WEAK_ALIAS_CROSSFILE], [$ax_cv_sys_weak_alias_crossfile])
143	])
144
145	AC_DEFUN([_AX_SYS_WEAK_ALIAS_ATTRIBUTE],
146	[ # Test whether compiler accepts __attribute__ form of weak aliasing
147	AC_CACHE_CHECK([whether $CC accepts function __attribute__((weak,alias()))],
148	[ax_cv_sys_weak_alias_attribute], [
149	# We add -Werror if it's gcc to force an error exit if the weak attribute
150	# isn't understood
151	AS_IF([test $GCC = yes], [
152	save_CFLAGS=$CFLAGS
153	CFLAGS=-Werror])
154
155	# Try linking with a weak alias...
156	AC_LINK_IFELSE([
157	AC_LANG_PROGRAM([
158	void __weakf(int c) {}
159	void weakf(int c) __attribute__((weak, alias("__weakf")));],
160	[weakf(0)])],
161	[ax_cv_sys_weak_alias_attribute=yes],
162	[ax_cv_sys_weak_alias_attribute=no])
163
164	# Restore original CFLAGS
165	AS_IF([test $GCC = yes], [
166	CFLAGS=$save_CFLAGS])
167	])
168
169	# What was the result of the test?
b2baffe8 DL	170	AS_IF([test $ax_cv_sys_weak_alias_attribute = yes], [
b2baffe8 DL	171	test $ax_sys_weak_alias = no && ax_sys_weak_alias=attribute
327c4cdf DV	172	AC_DEFINE([HAVE_SYS_WEAK_ALIAS_ATTRIBUTE], 1,
	173	[Define this if weak aliases may be created with __attribute__])
	174	])
	175	])
	176
	177	AC_DEFUN([_AX_SYS_WEAK_ALIAS_PRAGMA],
	178	[ # Test whether compiler accepts #pragma form of weak aliasing
	179	AC_CACHE_CHECK([whether $CC supports @%:@pragma weak],
	180	[ax_cv_sys_weak_alias_pragma], [
	181
	182	# Try linking with a weak alias...
	183	AC_LINK_IFELSE([
	184	AC_LANG_PROGRAM([
	185	extern void weakf(int c);
	186	@%:@pragma weak weakf = __weakf
	187	void __weakf(int c) {}],
	188	[weakf(0)])],
	189	[ax_cv_sys_weak_alias_pragma=yes],
	190	[ax_cv_sys_weak_alias_pragma=no])
	191	])
	192
	193	# What was the result of the test?
b2baffe8 DL	194	AS_IF([test $ax_cv_sys_weak_alias_pragma = yes], [
b2baffe8 DL	195	test $ax_sys_weak_alias = no && ax_sys_weak_alias=pragma
327c4cdf DV	196	AC_DEFINE([HAVE_SYS_WEAK_ALIAS_PRAGMA], 1,
	197	[Define this if weak aliases may be created with @%:@pragma weak])
	198	])
	199	])
	200
	201	AC_DEFUN([_AX_SYS_WEAK_ALIAS_HPSECONDARY],
	202	[ # Test whether compiler accepts _HP_SECONDARY_DEF pragma from HP...
	203	AC_CACHE_CHECK([whether $CC supports @%:@pragma _HP_SECONDARY_DEF],
	204	[ax_cv_sys_weak_alias_hpsecondary], [
	205
	206	# Try linking with a weak alias...
	207	AC_LINK_IFELSE([
	208	AC_LANG_PROGRAM([
	209	extern void weakf(int c);
	210	@%:@pragma _HP_SECONDARY_DEF __weakf weakf
	211	void __weakf(int c) {}],
	212	[weakf(0)])],
	213	[ax_cv_sys_weak_alias_hpsecondary=yes],
	214	[ax_cv_sys_weak_alias_hpsecondary=no])
	215	])
	216
	217	# What was the result of the test?
b2baffe8 DL	218	AS_IF([test $ax_cv_sys_weak_alias_hpsecondary = yes], [
b2baffe8 DL	219	test $ax_sys_weak_alias = no && ax_sys_weak_alias=hpsecondary
327c4cdf DV	220	AC_DEFINE([HAVE_SYS_WEAK_ALIAS_HPSECONDARY], 1,
	221	[Define this if weak aliases may be created with @%:@pragma _HP_SECONDARY_DEF])
	222	])
	223	])
	224
	225	AC_DEFUN([_AX_SYS_WEAK_ALIAS_CRIDUPLICATE],
	226	[ # Test whether compiler accepts "_CRI duplicate" pragma from Cray
	227	AC_CACHE_CHECK([whether $CC supports @%:@pragma _CRI duplicate],
	228	[ax_cv_sys_weak_alias_criduplicate], [
	229
	230	# Try linking with a weak alias...
	231	AC_LINK_IFELSE([
	232	AC_LANG_PROGRAM([
	233	extern void weakf(int c);
	234	@%:@pragma _CRI duplicate weakf as __weakf
	235	void __weakf(int c) {}],
	236	[weakf(0)])],
	237	[ax_cv_sys_weak_alias_criduplicate=yes],
	238	[ax_cv_sys_weak_alias_criduplicate=no])
	239	])
	240
	241	# What was the result of the test?
b2baffe8 DL	242	AS_IF([test $ax_cv_sys_weak_alias_criduplicate = yes], [
b2baffe8 DL	243	test $ax_sys_weak_alias = no && ax_sys_weak_alias=criduplicate
327c4cdf DV	244	AC_DEFINE([HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE], 1,
	245	[Define this if weak aliases may be created with @%:@pragma _CRI duplicate])
	246	])
	247	])
	248
	249	dnl Note: This macro is modeled closely on AC_LINK_IFELSE, and in fact
	250	dnl depends on some implementation details of that macro, particularly
	251	dnl its use of _AC_MSG_LOG_CONFTEST to log the failed test program and
	252	dnl its use of ac_link for running the linker.
	253	AC_DEFUN([_AX_SYS_WEAK_ALIAS_CROSSFILE],
	254	[ # Check to see if weak aliases can cross object file boundaries
	255	AC_CACHE_CHECK([whether $CC supports weak aliases across object file boundaries],
	256	[ax_cv_sys_weak_alias_crossfile], [
	257	AS_IF([test $ax_cv_sys_weak_alias = no],
	258	[ax_cv_sys_weak_alias_crossfile=no], [
	259	dnl Must build our own test files...
	260	# conftest1 contains our weak alias definition...
	261	cat >conftest1.$ac_ext <<_ACEOF
	262	/* confdefs.h. */
	263	_ACEOF
	264	cat confdefs.h >>conftest1.$ac_ext
	265	cat >>conftest1.$ac_ext <<_ACEOF
	266	/* end confdefs.h. */
	267
	268	@%:@ifndef HAVE_SYS_WEAK_ALIAS_ATTRIBUTE
	269	extern void weakf(int c);
327c4cdf DV	270	@%:@if defined(HAVE_SYS_WEAK_ALIAS_PRAGMA)
	271	@%:@pragma weak weakf = __weakf
	272	@%:@elif defined(HAVE_SYS_WEAK_ALIAS_HPSECONDARY)
	273	@%:@pragma _HP_SECONDARY_DEF __weakf weakf
	274	@%:@elif defined(HAVE_SYS_WEAK_ALIAS_CRIDUPLICATE)
	275	@%:@pragma _CRI duplicate weakf as __weakf
	276	@%:@endif
b2baffe8	277	@%:@endif
327c4cdf DV	278	void __weakf(int c) {}
	279	@%:@ifdef HAVE_SYS_WEAK_ALIAS_ATTRIBUTE
	280	void weakf(int c) __attribute((weak, alias("__weakf")));
	281	@%:@endif
	282	_ACEOF
	283	# And conftest2 contains our main routine that calls it
	284	cat >conftest2.$ac_ext <<_ACEOF
	285	/* confdefs.h. */
	286	_ACEOF
	287	cat confdefs.h >> conftest2.$ac_ext
	288	cat >>conftest2.$ac_ext <<_ACEOF
	289	/* end confdefs.h. */
	290
	291	extern void weakf(int c);
	292	int
	293	main ()
	294	{
	295	weakf(0);
	296	return 0;
	297	}
	298	_ACEOF
	299	# We must remove the object files (if any) ourselves...
	300	rm -f conftest2.$ac_objext conftest$ac_exeext
	301
	302	# Change ac_link to compile 2 files together
	303	save_aclink=$ac_link
	304	ac_link=`echo "$ac_link" \| \
	305	sed -e 's/conftest\(\.\$ac_ext\)/conftest1\1 conftest2\1/'`
	306	dnl Substitute our own routine for logging the conftest
	307	m4_pushdef([_AC_MSG_LOG_CONFTEST],
	308	[echo "$as_me: failed program was:" >&AS_MESSAGE_LOG_FD
	309	echo ">>> conftest1.$ac_ext" >&AS_MESSAGE_LOG_FD
	310	sed "s/^/\| /" conftest1.$ac_ext >&AS_MESSAGE_LOG_FD
	311	echo ">>> conftest2.$ac_ext" >&AS_MESSAGE_LOG_FD
	312	sed "s/^/\| /" conftest2.$ac_ext >&AS_MESSAGE_LOG_FD
	313	])dnl
	314	# Since we created the files ourselves, don't use SOURCE argument
	315	AC_LINK_IFELSE(, [ax_cv_sys_weak_alias_crossfile=yes],
	316	[ax_cv_sys_weak_alias_crossfile=no])
	317	dnl Restore _AC_MSG_LOG_CONFTEST
	318	m4_popdef([_AC_MSG_LOG_CONFTEST])dnl
	319	# Restore ac_link
	320	ac_link=$save_aclink
	321
	322	# We must remove the object files (if any) and C files ourselves...
	323	rm -f conftest1.$ac_ext conftest2.$ac_ext \
	324	conftest1.$ac_objext conftest2.$ac_objext
	325	])
	326	])
	327
	328	# What were the results of the test?
	329	AS_IF([test $ax_cv_sys_weak_alias_crossfile = yes], [
	330	AC_DEFINE([HAVE_SYS_WEAK_ALIAS_CROSSFILE], 1,
	331	[Define this if weak aliases in other files are honored])
	332	])
	333	])