OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [acinclude.m4] - Blame information for rev 841

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
dnl See whether we need a declaration for a function.
2
dnl The result is highly dependent on the INCLUDES passed in, so make sure
3
dnl to use a different cache variable name in this macro if it is invoked
4
dnl in a different context somewhere else.
5
dnl gcc_AC_CHECK_DECL(SYMBOL,
6
dnl     [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND [, INCLUDES]]])
7
AC_DEFUN([gcc_AC_CHECK_DECL],
8
[AC_MSG_CHECKING([whether $1 is declared])
9
AC_CACHE_VAL(gcc_cv_have_decl_$1,
10
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([$4],
11
[#ifndef $1
12
char *(*pfn) = (char *(*)) $1 ;
13
#endif])], eval "gcc_cv_have_decl_$1=yes", eval "gcc_cv_have_decl_$1=no")])
14
if eval "test \"`echo '$gcc_cv_have_decl_'$1`\" = yes"; then
15
  AC_MSG_RESULT(yes) ; ifelse([$2], , :, [$2])
16
else
17
  AC_MSG_RESULT(no) ; ifelse([$3], , :, [$3])
18
fi
19
])dnl
20
 
21
dnl Check multiple functions to see whether each needs a declaration.
22
dnl Arrange to define HAVE_DECL_<FUNCTION> to 0 or 1 as appropriate.
23
dnl gcc_AC_CHECK_DECLS(SYMBOLS,
24
dnl     [ACTION-IF-NEEDED [, ACTION-IF-NOT-NEEDED [, INCLUDES]]])
25
AC_DEFUN([gcc_AC_CHECK_DECLS],
26
[AC_FOREACH([gcc_AC_Func], [$1],
27
  [AH_TEMPLATE(AS_TR_CPP(HAVE_DECL_[]gcc_AC_Func),
28
  [Define to 1 if we found a declaration for ']gcc_AC_Func[', otherwise
29
   define to 0.])])dnl
30
for ac_func in $1
31
do
32
  ac_tr_decl=AS_TR_CPP([HAVE_DECL_$ac_func])
33
gcc_AC_CHECK_DECL($ac_func,
34
  [AC_DEFINE_UNQUOTED($ac_tr_decl, 1) $2],
35
  [AC_DEFINE_UNQUOTED($ac_tr_decl, 0) $3],
36
dnl It is possible that the include files passed in here are local headers
37
dnl which supply a backup declaration for the relevant prototype based on
38
dnl the definition of (or lack of) the HAVE_DECL_ macro.  If so, this test
39
dnl will always return success.  E.g. see libiberty.h's handling of
40
dnl `basename'.  To avoid this, we define the relevant HAVE_DECL_ macro to
41
dnl 1 so that any local headers used do not provide their own prototype
42
dnl during this test.
43
#undef $ac_tr_decl
44
#define $ac_tr_decl 1
45
  $4
46
)
47
done
48
])
49
 
50
dnl 'make compare' can be significantly faster, if cmp itself can
51
dnl skip bytes instead of using tail.  The test being performed is
52
dnl "if cmp --ignore-initial=2 t1 t2 && ! cmp --ignore-initial=1 t1 t2"
53
dnl but we need to sink errors and handle broken shells.  We also test
54
dnl for the parameter format "cmp file1 file2 skip1 skip2" which is
55
dnl accepted by cmp on some systems.
56
AC_DEFUN([gcc_AC_PROG_CMP_IGNORE_INITIAL],
57
[AC_CACHE_CHECK([for cmp's capabilities], gcc_cv_prog_cmp_skip,
58
[ echo abfoo >t1
59
  echo cdfoo >t2
60
  gcc_cv_prog_cmp_skip=slowcompare
61
  if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
62
    if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
63
      :
64
    else
65
      gcc_cv_prog_cmp_skip=gnucompare
66
    fi
67
  fi
68
  if test $gcc_cv_prog_cmp_skip = slowcompare ; then
69
    if cmp t1 t2 2 2 > /dev/null 2>&1; then
70
      if cmp t1 t2 1 1 > /dev/null 2>&1; then
71
        :
72
      else
73
        gcc_cv_prog_cmp_skip=fastcompare
74
      fi
75
    fi
76
  fi
77
  rm t1 t2
78
])
79
make_compare_target=$gcc_cv_prog_cmp_skip
80
AC_SUBST(make_compare_target)
81
])
82
 
83
dnl See if symbolic links work and if not, try to substitute either hard links or simple copy.
84
AC_DEFUN([gcc_AC_PROG_LN_S],
85
[AC_MSG_CHECKING(whether ln -s works)
86
AC_CACHE_VAL(gcc_cv_prog_LN_S,
87
[rm -f conftestdata_t
88
echo >conftestdata_f
89
if ln -s conftestdata_f conftestdata_t 2>/dev/null
90
then
91
  gcc_cv_prog_LN_S="ln -s"
92
else
93
  if ln conftestdata_f conftestdata_t 2>/dev/null
94
  then
95
    gcc_cv_prog_LN_S=ln
96
  else
97
    if cp -p conftestdata_f conftestdata_t 2>/dev/null
98
    then
99
      gcc_cv_prog_LN_S="cp -p"
100
    else
101
      gcc_cv_prog_LN_S=cp
102
    fi
103
  fi
104
fi
105
rm -f conftestdata_f conftestdata_t
106
])dnl
107
LN_S="$gcc_cv_prog_LN_S"
108
if test "$gcc_cv_prog_LN_S" = "ln -s"; then
109
  AC_MSG_RESULT(yes)
110
else
111
  if test "$gcc_cv_prog_LN_S" = "ln"; then
112
    AC_MSG_RESULT([no, using ln])
113
  else
114
    AC_MSG_RESULT([no, and neither does ln, so using $gcc_cv_prog_LN_S])
115
  fi
116
fi
117
AC_SUBST(LN_S)dnl
118
])
119
 
120
dnl Define MKDIR_TAKES_ONE_ARG if mkdir accepts only one argument instead
121
dnl of the usual 2.
122
AC_DEFUN([gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG],
123
[AC_CACHE_CHECK([if mkdir takes one argument], gcc_cv_mkdir_takes_one_arg,
124
[AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
125
#include <sys/types.h>
126
#ifdef HAVE_SYS_STAT_H
127
# include <sys/stat.h>
128
#endif
129
#ifdef HAVE_UNISTD_H
130
# include <unistd.h>
131
#endif
132
#ifdef HAVE_DIRECT_H
133
# include <direct.h>
134
#endif], [mkdir ("foo", 0);])],
135
        gcc_cv_mkdir_takes_one_arg=no, gcc_cv_mkdir_takes_one_arg=yes)])
136
if test $gcc_cv_mkdir_takes_one_arg = yes ; then
137
  AC_DEFINE(MKDIR_TAKES_ONE_ARG, 1, [Define if host mkdir takes a single argument.])
138
fi
139
])
140
 
141
AC_DEFUN([gcc_AC_PROG_INSTALL],
142
[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
143
# Find a good install program.  We prefer a C program (faster),
144
# so one script is as good as another.  But avoid the broken or
145
# incompatible versions:
146
# SysV /etc/install, /usr/sbin/install
147
# SunOS /usr/etc/install
148
# IRIX /sbin/install
149
# AIX /bin/install
150
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
151
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
152
# ./install, which can be erroneously created by make from ./install.sh.
153
AC_MSG_CHECKING(for a BSD compatible install)
154
if test -z "$INSTALL"; then
155
AC_CACHE_VAL(ac_cv_path_install,
156
[  IFS="${IFS=  }"; ac_save_IFS="$IFS"; IFS="${IFS}:"
157
  for ac_dir in $PATH; do
158
    # Account for people who put trailing slashes in PATH elements.
159
    case "$ac_dir/" in
160
    /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
161
    *)
162
      # OSF1 and SCO ODT 3.0 have their own names for install.
163
      for ac_prog in ginstall scoinst install; do
164
        if test -f $ac_dir/$ac_prog; then
165
          if test $ac_prog = install &&
166
            grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
167
            # AIX install.  It has an incompatible calling convention.
168
            # OSF/1 installbsd also uses dspmsg, but is usable.
169
            :
170
          else
171
            ac_cv_path_install="$ac_dir/$ac_prog -c"
172
            break 2
173
          fi
174
        fi
175
      done
176
      ;;
177
    esac
178
  done
179
  IFS="$ac_save_IFS"
180
])dnl
181
  if test "${ac_cv_path_install+set}" = set; then
182
    INSTALL="$ac_cv_path_install"
183
  else
184
    # As a last resort, use the slow shell script.  We don't cache a
185
    # path for INSTALL within a source directory, because that will
186
    # break other packages using the cache if that directory is
187
    # removed, or if the path is relative.
188
    INSTALL="$ac_install_sh"
189
  fi
190
fi
191
dnl We do special magic for INSTALL instead of AC_SUBST, to get
192
dnl relative paths right.
193
AC_MSG_RESULT($INSTALL)
194
AC_SUBST(INSTALL)dnl
195
 
196
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
197
# It thinks the first close brace ends the variable substitution.
198
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
199
AC_SUBST(INSTALL_PROGRAM)dnl
200
 
201
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
202
AC_SUBST(INSTALL_DATA)dnl
203
])
204
 
205
# mmap(2) blacklisting.  Some platforms provide the mmap library routine
206
# but don't support all of the features we need from it.
207
AC_DEFUN([gcc_AC_FUNC_MMAP_BLACKLIST],
208
[
209
AC_CHECK_HEADER([sys/mman.h],
210
                [gcc_header_sys_mman_h=yes], [gcc_header_sys_mman_h=no])
211
AC_CHECK_FUNC([mmap], [gcc_func_mmap=yes], [gcc_func_mmap=no])
212
if test "$gcc_header_sys_mman_h" != yes \
213
 || test "$gcc_func_mmap" != yes; then
214
   gcc_cv_func_mmap_file=no
215
   gcc_cv_func_mmap_dev_zero=no
216
   gcc_cv_func_mmap_anon=no
217
else
218
   AC_CACHE_CHECK([whether read-only mmap of a plain file works],
219
  gcc_cv_func_mmap_file,
220
  [# Add a system to this blacklist if
221
   # mmap(0, stat_size, PROT_READ, MAP_PRIVATE, fd, 0) doesn't return a
222
   # memory area containing the same data that you'd get if you applied
223
   # read() to the same fd.  The only system known to have a problem here
224
   # is VMS, where text files have record structure.
225
   case "$host_os" in
226
     vms* | ultrix*)
227
        gcc_cv_func_mmap_file=no ;;
228
     *)
229
        gcc_cv_func_mmap_file=yes;;
230
   esac])
231
   AC_CACHE_CHECK([whether mmap from /dev/zero works],
232
  gcc_cv_func_mmap_dev_zero,
233
  [# Add a system to this blacklist if it has mmap() but /dev/zero
234
   # does not exist, or if mmapping /dev/zero does not give anonymous
235
   # zeroed pages with both the following properties:
236
   # 1. If you map N consecutive pages in with one call, and then
237
   #    unmap any subset of those pages, the pages that were not
238
   #    explicitly unmapped remain accessible.
239
   # 2. If you map two adjacent blocks of memory and then unmap them
240
   #    both at once, they must both go away.
241
   # Systems known to be in this category are Windows (all variants),
242
   # VMS, and Darwin.
243
   case "$host_os" in
244
     vms* | cygwin* | pe | mingw* | darwin* | ultrix* | hpux10* | hpux11.00)
245
        gcc_cv_func_mmap_dev_zero=no ;;
246
     *)
247
        gcc_cv_func_mmap_dev_zero=yes;;
248
   esac])
249
 
250
   # Unlike /dev/zero, the MAP_ANON(YMOUS) defines can be probed for.
251
   AC_CACHE_CHECK([for MAP_ANON(YMOUS)], gcc_cv_decl_map_anon,
252
    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
253
[#include <sys/types.h>
254
#include <sys/mman.h>
255
#include <unistd.h>
256
 
257
#ifndef MAP_ANONYMOUS
258
#define MAP_ANONYMOUS MAP_ANON
259
#endif
260
],
261
[int n = MAP_ANONYMOUS;])],
262
    gcc_cv_decl_map_anon=yes,
263
    gcc_cv_decl_map_anon=no)])
264
 
265
   if test $gcc_cv_decl_map_anon = no; then
266
     gcc_cv_func_mmap_anon=no
267
   else
268
     AC_CACHE_CHECK([whether mmap with MAP_ANON(YMOUS) works],
269
     gcc_cv_func_mmap_anon,
270
  [# Add a system to this blacklist if it has mmap() and MAP_ANON or
271
   # MAP_ANONYMOUS, but using mmap(..., MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)
272
   # doesn't give anonymous zeroed pages with the same properties listed
273
   # above for use of /dev/zero.
274
   # Systems known to be in this category are Windows, VMS, and SCO Unix.
275
   case "$host_os" in
276
     vms* | cygwin* | pe | mingw* | sco* | udk* )
277
        gcc_cv_func_mmap_anon=no ;;
278
     *)
279
        gcc_cv_func_mmap_anon=yes;;
280
   esac])
281
   fi
282
fi
283
 
284
if test $gcc_cv_func_mmap_file = yes; then
285
  AC_DEFINE(HAVE_MMAP_FILE, 1,
286
            [Define if read-only mmap of a plain file works.])
287
fi
288
if test $gcc_cv_func_mmap_dev_zero = yes; then
289
  AC_DEFINE(HAVE_MMAP_DEV_ZERO, 1,
290
            [Define if mmap of /dev/zero works.])
291
fi
292
if test $gcc_cv_func_mmap_anon = yes; then
293
  AC_DEFINE(HAVE_MMAP_ANON, 1,
294
            [Define if mmap with MAP_ANON(YMOUS) works.])
295
fi
296
])
297
 
298
dnl Locate a program and check that its version is acceptable.
299
dnl AC_PROG_CHECK_VER(var, name, version-switch,
300
dnl                  version-extract-regexp, version-glob)
301
AC_DEFUN([gcc_AC_CHECK_PROG_VER],
302
[AC_REQUIRE([gcc_AC_BUILD_EXEEXT])
303
AC_CHECK_PROG([$1], [$2], [$2])
304
if test -n "[$]$1"; then
305
  # Found it, now check the version.
306
  AC_CACHE_CHECK(for modern $2, gcc_cv_prog_$2_modern,
307
[changequote(<<,>>)dnl
308
  ac_prog_version=`<<$>>$1 $3 2>&1 |
309
                   sed -n 's/^.*patsubst(<<$4>>,/,\/).*$/\1/p'`
310
changequote([,])dnl
311
  echo "configure:__oline__: version of $2 is $ac_prog_version" >&AS_MESSAGE_LOG_FD
312
changequote(<<,>>)dnl
313
  case $ac_prog_version in
314
    '')     gcc_cv_prog_$2_modern=no;;
315
    <<$5>>)
316
            gcc_cv_prog_$2_modern=yes;;
317
    *)      gcc_cv_prog_$2_modern=no;;
318
  esac
319
changequote([,])dnl
320
])
321
else
322
  gcc_cv_prog_$2_modern=no
323
fi
324
])
325
 
326
dnl Determine if enumerated bitfields are unsigned.   ISO C says they can
327
dnl be either signed or unsigned.
328
dnl
329
AC_DEFUN([gcc_AC_C_ENUM_BF_UNSIGNED],
330
[AC_CACHE_CHECK(for unsigned enumerated bitfields, gcc_cv_enum_bf_unsigned,
331
[AC_RUN_IFELSE([AC_LANG_SOURCE([#include <stdlib.h>
332
enum t { BLAH = 128 } ;
333
struct s_t { enum t member : 8; } s ;
334
int main(void)
335
{
336
        s.member = BLAH;
337
        if (s.member < 0) exit(1);
338
        exit(0);
339
 
340
}])], gcc_cv_enum_bf_unsigned=yes, gcc_cv_enum_bf_unsigned=no, gcc_cv_enum_bf_unsigned=yes)])
341
if test $gcc_cv_enum_bf_unsigned = yes; then
342
  AC_DEFINE(ENUM_BITFIELDS_ARE_UNSIGNED, 1,
343
    [Define if enumerated bitfields are treated as unsigned values.])
344
fi])
345
 
346
dnl Probe number of bits in a byte.
347
dnl Note C89 requires CHAR_BIT >= 8.
348
dnl
349
AC_DEFUN([gcc_AC_C_CHAR_BIT],
350
[AC_CACHE_CHECK(for CHAR_BIT, gcc_cv_decl_char_bit,
351
[AC_EGREP_CPP(found,
352
[#ifdef HAVE_LIMITS_H
353
#include <limits.h>
354
#endif
355
#ifdef CHAR_BIT
356
found
357
#endif], gcc_cv_decl_char_bit=yes, gcc_cv_decl_char_bit=no)
358
])
359
if test $gcc_cv_decl_char_bit = no; then
360
  AC_CACHE_CHECK(number of bits in a byte, gcc_cv_c_nbby,
361
[i=8
362
 gcc_cv_c_nbby=
363
 while test $i -lt 65; do
364
   AC_COMPILE_IFELSE([AC_LANG_PROGRAM(,
365
     [switch(0) {
366
  case (unsigned char)((unsigned long)1 << $i) == ((unsigned long)1 << $i):
367
  case (unsigned char)((unsigned long)1<<($i-1)) == ((unsigned long)1<<($i-1)):
368
  ; }])],
369
     [gcc_cv_c_nbby=$i; break])
370
   i=`expr $i + 1`
371
 done
372
 test -z "$gcc_cv_c_nbby" && gcc_cv_c_nbby=failed
373
])
374
if test $gcc_cv_c_nbby = failed; then
375
  AC_MSG_ERROR(cannot determine number of bits in a byte)
376
else
377
  AC_DEFINE_UNQUOTED(CHAR_BIT, $gcc_cv_c_nbby,
378
  [Define as the number of bits in a byte, if \`limits.h' doesn't.])
379
fi
380
fi])
381
 
382
AC_DEFUN([gcc_AC_INITFINI_ARRAY],
383
[AC_ARG_ENABLE(initfini-array,
384
        [  --enable-initfini-array      use .init_array/.fini_array sections],
385
        [], [
386
AC_CACHE_CHECK(for .preinit_array/.init_array/.fini_array support,
387
                 gcc_cv_initfini_array, [dnl
388
  AC_RUN_IFELSE([AC_LANG_SOURCE([
389
static int x = -1;
390
int main (void) { return x; }
391
int foo (void) { x = 0; }
392
int (*fp) (void) __attribute__ ((section (".init_array"))) = foo;])],
393
             [gcc_cv_initfini_array=yes], [gcc_cv_initfini_array=no],
394
             [gcc_cv_initfini_array=no])])
395
  enable_initfini_array=$gcc_cv_initfini_array
396
])
397
if test $enable_initfini_array = yes; then
398
  AC_DEFINE(HAVE_INITFINI_ARRAY, 1,
399
    [Define .init_array/.fini_array sections are available and working.])
400
fi])
401
 
402
dnl # _gcc_COMPUTE_GAS_VERSION
403
dnl # Used by gcc_GAS_VERSION_GTE_IFELSE
404
dnl #
405
dnl # WARNING:
406
dnl # gcc_cv_as_gas_srcdir must be defined before this.
407
dnl # This gross requirement will go away eventually.
408
AC_DEFUN([_gcc_COMPUTE_GAS_VERSION],
409
[gcc_cv_as_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
410
for f in $gcc_cv_as_bfd_srcdir/configure \
411
         $gcc_cv_as_gas_srcdir/configure \
412
         $gcc_cv_as_gas_srcdir/configure.in \
413
         $gcc_cv_as_gas_srcdir/Makefile.in ; do
414
  gcc_cv_gas_version=`sed -n -e 's/^[[  ]]*\(VERSION=[[0-9]]*\.[[0-9]]*.*\)/\1/p' < $f`
415
  if test x$gcc_cv_gas_version != x; then
416
    break
417
  fi
418
done
419
gcc_cv_gas_major_version=`expr "$gcc_cv_gas_version" : "VERSION=\([[0-9]]*\)"`
420
gcc_cv_gas_minor_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.\([[0-9]]*\)"`
421
gcc_cv_gas_patch_version=`expr "$gcc_cv_gas_version" : "VERSION=[[0-9]]*\.[[0-9]]*\.\([[0-9]]*\)"`
422
case $gcc_cv_gas_patch_version in
423
  "") gcc_cv_gas_patch_version="0" ;;
424
esac
425
gcc_cv_gas_vers=`expr \( \( $gcc_cv_gas_major_version \* 1000 \) \
426
                            + $gcc_cv_gas_minor_version \) \* 1000 \
427
                            + $gcc_cv_gas_patch_version`
428
]) []dnl # _gcc_COMPUTE_GAS_VERSION
429
 
430
dnl # gcc_GAS_VERSION_GTE_IFELSE([elf,] major, minor, patchlevel,
431
dnl #                     [command_if_true = :], [command_if_false = :])
432
dnl # Check to see if the version of GAS is greater than or
433
dnl # equal to the specified version.
434
dnl #
435
dnl # The first ifelse() shortens the shell code if the patchlevel
436
dnl # is unimportant (the usual case).  The others handle missing
437
dnl # commands.  Note that the tests are structured so that the most
438
dnl # common version number cases are tested first.
439
AC_DEFUN([_gcc_GAS_VERSION_GTE_IFELSE],
440
[ifelse([$1], elf,
441
 [if test $in_tree_gas_is_elf = yes \
442
  &&],
443
 [if]) test $gcc_cv_gas_vers -ge `expr \( \( $2 \* 1000 \) + $3 \) \* 1000 + $4`
444
  then dnl
445
ifelse([$5],,:,[$5])[]dnl
446
ifelse([$6],,,[
447
  else $6])
448
fi])
449
 
450
AC_DEFUN([gcc_GAS_VERSION_GTE_IFELSE],
451
[AC_REQUIRE([_gcc_COMPUTE_GAS_VERSION])dnl
452
ifelse([$1], elf, [_gcc_GAS_VERSION_GTE_IFELSE($@)],
453
                  [_gcc_GAS_VERSION_GTE_IFELSE(,$@)])])
454
 
455
dnl gcc_GAS_CHECK_FEATURE(description, cv, [[elf,]major,minor,patchlevel],
456
dnl [extra switches to as], [assembler input],
457
dnl [extra testing logic], [command if feature available])
458
dnl
459
dnl Checks for an assembler feature.  If we are building an in-tree
460
dnl gas, the feature is available if the associated assembler version
461
dnl is greater than or equal to major.minor.patchlevel.  If not, then
462
dnl ASSEMBLER INPUT is fed to the assembler and the feature is available
463
dnl if assembly succeeds.  If EXTRA TESTING LOGIC is not the empty string,
464
dnl then it is run instead of simply setting CV to "yes" - it is responsible
465
dnl for doing so, if appropriate.
466
AC_DEFUN([gcc_GAS_CHECK_FEATURE],
467
[AC_CACHE_CHECK([assembler for $1], [$2],
468
 [[$2]=no
469
  ifelse([$3],,,[dnl
470
  if test $in_tree_gas = yes; then
471
    gcc_GAS_VERSION_GTE_IFELSE($3, [[$2]=yes])
472
  el])if test x$gcc_cv_as != x; then
473
    echo ifelse(m4_substr([$5],0,1),[$], "[$5]", '[$5]') > conftest.s
474
    if AC_TRY_COMMAND([$gcc_cv_as $4 -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD])
475
    then
476
        ifelse([$6],, [$2]=yes, [$6])
477
    else
478
      echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
479
      cat conftest.s >&AS_MESSAGE_LOG_FD
480
    fi
481
    rm -f conftest.o conftest.s
482
  fi])
483
ifelse([$7],,,[dnl
484
if test $[$2] = yes; then
485
  $7
486
fi])])
487
 
488
dnl GCC_TARGET_TEMPLATE(KEY)
489
dnl ------------------------
490
dnl Define KEY as a valid configure key on the target machine.
491
 
492
m4_define([GCC_TARGET_TEMPLATE],
493
[m4_define([GCC_TARGET_TEMPLATE($1)],[])])
494
 
495
dnl AH_TEMPLATE(KEY, DESCRIPTION)
496
dnl -----------------------------
497
dnl Issue an autoheader template for KEY, i.e., a comment composed of
498
dnl DESCRIPTION (properly wrapped), and then #undef KEY.  Redefinition
499
dnl of the macro in autoheader.m4, to support definition of only a few
500
dnl keys while compiling target libraries.
501
 
502
m4_define([AH_TEMPLATE],
503
[AH_VERBATIM([$1],m4_text_wrap([$2 */], [   ], [/* ])
504
m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[#ifndef USED_FOR_TARGET
505
])[#undef $1]m4_ifdef([GCC_TARGET_TEMPLATE($1)],[],[
506
#endif
507
]))])
508
 
509
dnl Make sure that build_exeext is looked for
510
AC_DEFUN([gcc_AC_BUILD_EXEEXT], [
511
ac_executable_extensions="$build_exeext"])
512
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.