sim/common/aclocal.m4

   1 # This file contains common code used by all simulators.
   2 #
   3 # SIM_AC_COMMON invokes AC macros used by all simulators and by the common
   4 # directory.  It is intended to be invoked before any target specific stuff.
   5 # SIM_AC_OUTPUT is a cover function to AC_OUTPUT to generate the Makefile.
   6 # It is intended to be invoked last.
   7 #
   8 # The simulator's configure.in should look like:
   9 #
  10 # dnl Process this file with autoconf to produce a configure script.
  11 # sinclude(../common/aclocal.m4)
  12 # AC_PREREQ(2.5)dnl
  13 # AC_INIT(Makefile.in)
  14 #
  15 # SIM_AC_COMMON
  16 #
  17 # ... target specific stuff ...
  18 #
  19 # SIM_AC_OUTPUT
  20
  21 # Include global overrides and fixes for Autoconf.
  22 m4_include(../../config/override.m4)
  23 sinclude([../../config/zlib.m4])
  24
  25 AC_DEFUN([SIM_AC_COMMON],
  26 [
  27 # autoconf.info says this should be called right after AC_INIT.
  28 AC_CONFIG_HEADER(ifelse([$1],,config.h,[$1]):config.in)
  29 AC_CANONICAL_SYSTEM
  30 AC_ARG_PROGRAM
  31 AC_PROG_CC
  32 AC_PROG_INSTALL
  33
  34 # Put a plausible default for CC_FOR_BUILD in Makefile.
  35 if test "x$cross_compiling" = "xno"; then
  36   CC_FOR_BUILD='$(CC)'
  37 else
  38   CC_FOR_BUILD=gcc
  39 fi
  40 AC_SUBST(CC_FOR_BUILD)
  41
  42 AC_SUBST(CFLAGS)
  43 AC_SUBST(HDEFINES)
  44 AR=${AR-ar}
  45 AC_SUBST(AR)
  46 AC_PROG_RANLIB
  47
  48 dnl We don't use gettext, but bfd does.  So we do the appropriate checks
  49 dnl to see if there are intl libraries we should link against.
  50 ALL_LINGUAS=
  51 ZW_GNU_GETTEXT_SISTER_DIR(../../intl)
  52
  53 # Check for common headers.
  54 # FIXME: Seems to me this can cause problems for i386-windows hosts.
  55 # At one point there were hardcoded AC_DEFINE's if ${host} = i386-*-windows*.
  56 AC_CHECK_HEADERS(stdlib.h string.h strings.h unistd.h time.h)
  57 AC_CHECK_HEADERS(sys/time.h sys/resource.h)
  58 AC_CHECK_HEADERS(fcntl.h fpu_control.h)
  59 AC_CHECK_HEADERS(dlfcn.h errno.h sys/stat.h)
  60 AC_CHECK_FUNCS(getrusage time sigaction __setfpucw)
  61
  62 # Check for socket libraries
  63 AC_CHECK_LIB(socket, bind)
  64 AC_CHECK_LIB(nsl, gethostbyname)
  65
  66 . ${srcdir}/../../bfd/configure.host
  67
  68 dnl Standard (and optional) simulator options.
  69 dnl Eventually all simulators will support these.
  70 dnl Do not add any here that cannot be supported by all simulators.
  71 dnl Do not add similar but different options to a particular simulator,
  72 dnl all shall eventually behave the same way.
  73
  74
  75 dnl We don't use automake, but we still want to support
  76 dnl --enable-maintainer-mode.
  77 USE_MAINTAINER_MODE=no
  78 AC_ARG_ENABLE(maintainer-mode,
  79 [  --enable-maintainer-mode             Enable developer functionality.],
  80 [case "${enableval}" in
  81   yes)  MAINT="" USE_MAINTAINER_MODE=yes ;;
  82   no)   MAINT="#" ;;
  83   *)    AC_MSG_ERROR("--enable-maintainer-mode does not take a value"); MAINT="#" ;;
  84 esac
  85 if test x"$silent" != x"yes" && test x"$MAINT" = x""; then
  86   echo "Setting maintainer mode" 6>&1
  87 fi],[MAINT="#"])dnl
  88 AC_SUBST(MAINT)
  89
  90
  91 dnl This is a generic option to enable special byte swapping
  92 dnl insns on *any* cpu.
  93 AC_ARG_ENABLE(sim-bswap,
  94 [  --enable-sim-bswap                   Use Host specific BSWAP instruction.],
  95 [case "${enableval}" in
  96   yes)  sim_bswap="-DWITH_BSWAP=1 -DUSE_BSWAP=1";;
  97   no)   sim_bswap="-DWITH_BSWAP=0";;
  98   *)    AC_MSG_ERROR("--enable-sim-bswap does not take a value"); sim_bswap="";;
  99 esac
 100 if test x"$silent" != x"yes" && test x"$sim_bswap" != x""; then
 101   echo "Setting bswap flags = $sim_bswap" 6>&1
 102 fi],[sim_bswap=""])dnl
 103 AC_SUBST(sim_bswap)
 104
 105
 106 AC_ARG_ENABLE(sim-cflags,
 107 [  --enable-sim-cflags=opts             Extra CFLAGS for use in building simulator],
 108 [case "${enableval}" in
 109   yes)   sim_cflags="-O2 -fomit-frame-pointer";;
 110   trace) AC_MSG_ERROR("Please use --enable-sim-debug instead."); sim_cflags="";;
 111   no)    sim_cflags="";;
 112   *)     sim_cflags=`echo "${enableval}" | sed -e "s/,/ /g"`;;
 113 esac
 114 if test x"$silent" != x"yes" && test x"$sim_cflags" != x""; then
 115   echo "Setting sim cflags = $sim_cflags" 6>&1
 116 fi],[sim_cflags=""])dnl
 117 AC_SUBST(sim_cflags)
 118
 119
 120 dnl --enable-sim-debug is for developers of the simulator
 121 dnl the allowable values are work-in-progress
 122 AC_ARG_ENABLE(sim-debug,
 123 [  --enable-sim-debug=opts              Enable debugging flags],
 124 [case "${enableval}" in
 125   yes) sim_debug="-DDEBUG=7 -DWITH_DEBUG=7";;
 126   no)  sim_debug="-DDEBUG=0 -DWITH_DEBUG=0";;
 127   *)   sim_debug="-DDEBUG='(${enableval})' -DWITH_DEBUG='(${enableval})'";;
 128 esac
 129 if test x"$silent" != x"yes" && test x"$sim_debug" != x""; then
 130   echo "Setting sim debug = $sim_debug" 6>&1
 131 fi],[sim_debug=""])dnl
 132 AC_SUBST(sim_debug)
 133
 134
 135 dnl --enable-sim-stdio is for users of the simulator
 136 dnl It determines if IO from the program is routed through STDIO (buffered)
 137 AC_ARG_ENABLE(sim-stdio,
 138 [  --enable-sim-stdio                   Specify whether to use stdio for console input/output.],
 139 [case "${enableval}" in
 140   yes)  sim_stdio="-DWITH_STDIO=DO_USE_STDIO";;
 141   no)   sim_stdio="-DWITH_STDIO=DONT_USE_STDIO";;
 142   *)    AC_MSG_ERROR("Unknown value $enableval passed to --enable-sim-stdio"); sim_stdio="";;
 143 esac
 144 if test x"$silent" != x"yes" && test x"$sim_stdio" != x""; then
 145   echo "Setting stdio flags = $sim_stdio" 6>&1
 146 fi],[sim_stdio=""])dnl
 147 AC_SUBST(sim_stdio)
 148
 149
 150 dnl --enable-sim-trace is for users of the simulator
 151 dnl The argument is either a bitmask of things to enable [exactly what is
 152 dnl up to the simulator], or is a comma separated list of names of tracing
 153 dnl elements to enable.  The latter is only supported on simulators that
 154 dnl use WITH_TRACE.
 155 AC_ARG_ENABLE(sim-trace,
 156 [  --enable-sim-trace=opts              Enable tracing flags],
 157 [case "${enableval}" in
 158   yes)  sim_trace="-DTRACE=1 -DWITH_TRACE=-1";;
 159   no)   sim_trace="-DTRACE=0 -DWITH_TRACE=0";;
 160   [[-0-9]]*)
 161         sim_trace="-DTRACE='(${enableval})' -DWITH_TRACE='(${enableval})'";;
 162   [[a-z]]*)
 163         sim_trace=""
 164         for x in `echo "$enableval" | sed -e "s/,/ /g"`; do
 165           if test x"$sim_trace" = x; then
 166             sim_trace="-DWITH_TRACE='(TRACE_$x"
 167           else
 168             sim_trace="${sim_trace}|TRACE_$x"
 169           fi
 170         done
 171         sim_trace="$sim_trace)'" ;;
 172 esac
 173 if test x"$silent" != x"yes" && test x"$sim_trace" != x""; then
 174   echo "Setting sim trace = $sim_trace" 6>&1
 175 fi],[sim_trace=""])dnl
 176 AC_SUBST(sim_trace)
 177
 178
 179 dnl --enable-sim-profile
 180 dnl The argument is either a bitmask of things to enable [exactly what is
 181 dnl up to the simulator], or is a comma separated list of names of profiling
 182 dnl elements to enable.  The latter is only supported on simulators that
 183 dnl use WITH_PROFILE.
 184 AC_ARG_ENABLE(sim-profile,
 185 [  --enable-sim-profile=opts            Enable profiling flags],
 186 [case "${enableval}" in
 187   yes)  sim_profile="-DPROFILE=1 -DWITH_PROFILE=-1";;
 188   no)   sim_profile="-DPROFILE=0 -DWITH_PROFILE=0";;
 189   [[-0-9]]*)
 190         sim_profile="-DPROFILE='(${enableval})' -DWITH_PROFILE='(${enableval})'";;
 191   [[a-z]]*)
 192         sim_profile=""
 193         for x in `echo "$enableval" | sed -e "s/,/ /g"`; do
 194           if test x"$sim_profile" = x; then
 195             sim_profile="-DWITH_PROFILE='(PROFILE_$x"
 196           else
 197             sim_profile="${sim_profile}|PROFILE_$x"
 198           fi
 199         done
 200         sim_profile="$sim_profile)'" ;;
 201 esac
 202 if test x"$silent" != x"yes" && test x"$sim_profile" != x""; then
 203   echo "Setting sim profile = $sim_profile" 6>&1
 204 fi],[sim_profile="-DPROFILE=1 -DWITH_PROFILE=-1"])dnl
 205 AC_SUBST(sim_profile)
 206
 207
 208 dnl Types used by common code
 209 AC_TYPE_SIGNAL
 210
 211 dnl Detect exe extension
 212 AC_EXEEXT
 213
 214 dnl These are available to append to as desired.
 215 sim_link_files=
 216 sim_link_links=
 217
 218 dnl Create tconfig.h either from simulator's tconfig.in or default one
 219 dnl in common.
 220 sim_link_links=tconfig.h
 221 if test -f ${srcdir}/tconfig.in
 222 then
 223   sim_link_files=tconfig.in
 224 else
 225   sim_link_files=../common/tconfig.in
 226 fi
 227
 228 # targ-vals.def points to the libc macro description file.
 229 case "${target}" in
 230 *-*-*) TARG_VALS_DEF=../common/nltvals.def ;;
 231 esac
 232 sim_link_files="${sim_link_files} ${TARG_VALS_DEF}"
 233 sim_link_links="${sim_link_links} targ-vals.def"
 234
 235 ]) dnl End of SIM_AC_COMMON
 236
 237
 238 dnl Additional SIM options that can (optionally) be configured
 239 dnl For optional simulator options, a macro SIM_AC_OPTION_* is defined.
 240 dnl Simulators that wish to use the relevant option specify the macro
 241 dnl in the simulator specific configure.in file between the SIM_AC_COMMON
 242 dnl and SIM_AC_OUTPUT lines.
 243
 244
 245 dnl Specify the running environment.
 246 dnl If the simulator invokes this in its configure.in then without this option
 247 dnl the default is the user environment and all are runtime selectable.
 248 dnl If the simulator doesn't invoke this, only the user environment is
 249 dnl supported.
 250 dnl ??? Until there is demonstrable value in doing something more complicated,
 251 dnl let's not.
 252 AC_DEFUN([SIM_AC_OPTION_ENVIRONMENT],
 253 [
 254 AC_ARG_ENABLE(sim-environment,
 255 [  --enable-sim-environment=environment Specify mixed, user, virtual or operating environment.],
 256 [case "${enableval}" in
 257   all | ALL)             sim_environment="-DWITH_ENVIRONMENT=ALL_ENVIRONMENT";;
 258   user | USER)           sim_environment="-DWITH_ENVIRONMENT=USER_ENVIRONMENT";;
 259   virtual | VIRTUAL)     sim_environment="-DWITH_ENVIRONMENT=VIRTUAL_ENVIRONMENT";;
 260   operating | OPERATING) sim_environment="-DWITH_ENVIRONMENT=OPERATING_ENVIRONMENT";;
 261   *)   AC_MSG_ERROR("Unknown value $enableval passed to --enable-sim-environment");
 262        sim_environment="";;
 263 esac
 264 if test x"$silent" != x"yes" && test x"$sim_environment" != x""; then
 265   echo "Setting sim environment = $sim_environment" 6>&1
 266 fi],
 267 [sim_environment="-DWITH_ENVIRONMENT=ALL_ENVIRONMENT"])dnl
 268 ])
 269 AC_SUBST(sim_environment)
 270
 271
 272 dnl Specify the alignment restrictions of the target architecture.
 273 dnl Without this option all possible alignment restrictions are accommodated.
 274 dnl arg[1] is hardwired target alignment
 275 dnl arg[2] is default target alignment
 276 AC_DEFUN([SIM_AC_OPTION_ALIGNMENT],
 277 wire_alignment="[$1]"
 278 default_alignment="[$2]"
 279 [
 280 AC_ARG_ENABLE(sim-alignment,
 281 [  --enable-sim-alignment=align         Specify strict,  nonstrict or forced alignment of memory accesses.],
 282 [case "${enableval}" in
 283   strict | STRICT)       sim_alignment="-DWITH_ALIGNMENT=STRICT_ALIGNMENT";;
 284   nonstrict | NONSTRICT) sim_alignment="-DWITH_ALIGNMENT=NONSTRICT_ALIGNMENT";;
 285   forced | FORCED)       sim_alignment="-DWITH_ALIGNMENT=FORCED_ALIGNMENT";;
 286   yes) if test x"$wire_alignment" != x; then
 287          sim_alignment="-DWITH_ALIGNMENT=${wire_alignment}"
 288        else
 289          if test x"$default_alignment" != x; then
 290            sim_alignment="-DWITH_ALIGNMENT=${default_alignment}"
 291          else
 292            echo "No hard-wired alignment for target $target" 1>&6
 293            sim_alignment="-DWITH_ALIGNMENT=0"
 294          fi
 295        fi;;
 296   no)  if test x"$default_alignment" != x; then
 297          sim_alignment="-DWITH_DEFAULT_ALIGNMENT=${default_alignment}"
 298        else
 299          if test x"$wire_alignment" != x; then
 300            sim_alignment="-DWITH_DEFAULT_ALIGNMENT=${wire_alignment}"
 301          else
 302            echo "No default alignment for target $target" 1>&6
 303            sim_alignment="-DWITH_DEFAULT_ALIGNMENT=0"
 304          fi
 305        fi;;
 306   *)   AC_MSG_ERROR("Unknown value $enableval passed to --enable-sim-alignment"); sim_alignment="";;
 307 esac
 308 if test x"$silent" != x"yes" && test x"$sim_alignment" != x""; then
 309   echo "Setting alignment flags = $sim_alignment" 6>&1
 310 fi],
 311 [if test x"$default_alignment" != x; then
 312   sim_alignment="-DWITH_DEFAULT_ALIGNMENT=${default_alignment}"
 313 else
 314   if test x"$wire_alignment" != x; then
 315     sim_alignment="-DWITH_ALIGNMENT=${wire_alignment}"
 316   else
 317     sim_alignment=
 318   fi
 319 fi])dnl
 320 ])dnl
 321 AC_SUBST(sim_alignment)
 322
 323
 324 dnl Conditionally compile in assertion statements.
 325 AC_DEFUN([SIM_AC_OPTION_ASSERT],
 326 [
 327 AC_ARG_ENABLE(sim-assert,
 328 [  --enable-sim-assert                  Specify whether to perform random assertions.],
 329 [case "${enableval}" in
 330   yes)  sim_assert="-DWITH_ASSERT=1";;
 331   no)   sim_assert="-DWITH_ASSERT=0";;
 332   *)    AC_MSG_ERROR("--enable-sim-assert does not take a value"); sim_assert="";;
 333 esac
 334 if test x"$silent" != x"yes" && test x"$sim_assert" != x""; then
 335   echo "Setting assert flags = $sim_assert" 6>&1
 336 fi],[sim_assert=""])dnl
 337 ])
 338 AC_SUBST(sim_assert)
 339
 340
 341
 342 dnl --enable-sim-bitsize is for developers of the simulator
 343 dnl It specifies the number of BITS in the target.
 344 dnl arg[1] is the number of bits in a word
 345 dnl arg[2] is the number assigned to the most significant bit
 346 dnl arg[3] is the number of bits in an address
 347 dnl arg[4] is the number of bits in an OpenFirmware cell.
 348 dnl FIXME: this information should be obtained from bfd/archure
 349 AC_DEFUN([SIM_AC_OPTION_BITSIZE],
 350 wire_word_bitsize="[$1]"
 351 wire_word_msb="[$2]"
 352 wire_address_bitsize="[$3]"
 353 wire_cell_bitsize="[$4]"
 354 [AC_ARG_ENABLE(sim-bitsize,
 355 [  --enable-sim-bitsize=N               Specify target bitsize (32 or 64).],
 356 [sim_bitsize=
 357 case "${enableval}" in
 358   64,63 | 64,63,* ) sim_bitsize="-DWITH_TARGET_WORD_BITSIZE=64 -DWITH_TARGET_WORD_MSB=63";;
 359   32,31 | 32,31,* ) sim_bitsize="-DWITH_TARGET_WORD_BITSIZE=32 -DWITH_TARGET_WORD_MSB=31";;
 360   64,0 | 64,0,* ) sim_bitsize="-DWITH_TARGET_WORD_BITSIZE=32 -DWITH_TARGET_WORD_MSB=0";;
 361   32,0 | 64,0,* ) sim_bitsize="-DWITH_TARGET_WORD_BITSIZE=32 -DWITH_TARGET_WORD_MSB=0";;
 362   32) if test x"$wire_word_msb" != x -a x"$wire_word_msb" != x0; then
 363         sim_bitsize="-DWITH_TARGET_WORD_BITSIZE=32 -DWITH_TARGET_WORD_MSB=31"
 364       else
 365         sim_bitsize="-DWITH_TARGET_WORD_BITSIZE=32 -DWITH_TARGET_WORD_MSB=0"
 366       fi ;;
 367   64) if test x"$wire_word_msb" != x -a x"$wire_word_msb" != x0; then
 368         sim_bitsize="-DWITH_TARGET_WORD_BITSIZE=64 -DWITH_TARGET_WORD_MSB=63"
 369       else
 370         sim_bitsize="-DWITH_TARGET_WORD_BITSIZE=64 -DWITH_TARGET_WORD_MSB=0"
 371       fi ;;
 372   *)  AC_MSG_ERROR("--enable-sim-bitsize was given $enableval.  Expected 32 or 64") ;;
 373 esac
 374 # address bitsize
 375 tmp=`echo "${enableval}" | sed -e "s/^[[0-9]]*,*[[0-9]]*,*//"`
 376 case x"${tmp}" in
 377   x ) ;;
 378   x32 | x32,* ) sim_bitsize="${sim_bitsize} -DWITH_TARGET_ADDRESS_BITSIZE=32" ;;
 379   x64 | x64,* ) sim_bitsize="${sim_bitsize} -DWITH_TARGET_ADDRESS_BITSIZE=64" ;;
 380   * ) AC_MSG_ERROR("--enable-sim-bitsize was given address size $enableval.  Expected 32 or 64") ;;
 381 esac
 382 # cell bitsize
 383 tmp=`echo "${enableval}" | sed -e "s/^[[0-9]]*,*[[0-9*]]*,*[[0-9]]*,*//"`
 384 case x"${tmp}" in
 385   x ) ;;
 386   x32 | x32,* ) sim_bitsize="${sim_bitsize} -DWITH_TARGET_CELL_BITSIZE=32" ;;
 387   x64 | x64,* ) sim_bitsize="${sim_bitsize} -DWITH_TARGET_CELL_BITSIZE=64" ;;
 388   * ) AC_MSG_ERROR("--enable-sim-bitsize was given cell size $enableval.  Expected 32 or 64") ;;
 389 esac
 390 if test x"$silent" != x"yes" && test x"$sim_bitsize" != x""; then
 391   echo "Setting bitsize flags = $sim_bitsize" 6>&1
 392 fi],
 393 [sim_bitsize=""
 394 if test x"$wire_word_bitsize" != x; then
 395   sim_bitsize="$sim_bitsize -DWITH_TARGET_WORD_BITSIZE=$wire_word_bitsize"
 396 fi
 397 if test x"$wire_word_msb" != x; then
 398   sim_bitsize="$sim_bitsize -DWITH_TARGET_WORD_MSB=$wire_word_msb"
 399 fi
 400 if test x"$wire_address_bitsize" != x; then
 401   sim_bitsize="$sim_bitsize -DWITH_TARGET_ADDRESS_BITSIZE=$wire_address_bitsize"
 402 fi
 403 if test x"$wire_cell_bitsize" != x; then
 404   sim_bitsize="$sim_bitsize -DWITH_TARGET_CELL_BITSIZE=$wire_cell_bitsize"
 405 fi])dnl
 406 ])
 407 AC_SUBST(sim_bitsize)
 408
 409
 410
 411 dnl --enable-sim-endian={yes,no,big,little} is for simulators
 412 dnl that support both big and little endian targets.
 413 dnl arg[1] is hardwired target endianness.
 414 dnl arg[2] is default target endianness.
 415 AC_DEFUN([SIM_AC_OPTION_ENDIAN],
 416 [
 417 wire_endian="[$1]"
 418 default_endian="[$2]"
 419 AC_ARG_ENABLE(sim-endian,
 420 [  --enable-sim-endian=endian           Specify target byte endian orientation.],
 421 [case "${enableval}" in
 422   b*|B*) sim_endian="-DWITH_TARGET_BYTE_ORDER=BIG_ENDIAN";;
 423   l*|L*) sim_endian="-DWITH_TARGET_BYTE_ORDER=LITTLE_ENDIAN";;
 424   yes)   if test x"$wire_endian" != x; then
 425            sim_endian="-DWITH_TARGET_BYTE_ORDER=${wire_endian}"
 426          else
 427            if test x"$default_endian" != x; then
 428              sim_endian="-DWITH_TARGET_BYTE_ORDER=${default_endian}"
 429            else
 430              echo "No hard-wired endian for target $target" 1>&6
 431              sim_endian="-DWITH_TARGET_BYTE_ORDER=0"
 432            fi
 433          fi;;
 434   no)    if test x"$default_endian" != x; then
 435            sim_endian="-DWITH_DEFAULT_TARGET_BYTE_ORDER=${default_endian}"
 436          else
 437            if test x"$wire_endian" != x; then
 438              sim_endian="-DWITH_DEFAULT_TARGET_BYTE_ORDER=${wire_endian}"
 439            else
 440              echo "No default endian for target $target" 1>&6
 441              sim_endian="-DWITH_DEFAULT_TARGET_BYTE_ORDER=0"
 442            fi
 443          fi;;
 444   *)     AC_MSG_ERROR("Unknown value $enableval for --enable-sim-endian"); sim_endian="";;
 445 esac
 446 if test x"$silent" != x"yes" && test x"$sim_endian" != x""; then
 447   echo "Setting endian flags = $sim_endian" 6>&1
 448 fi],
 449 [if test x"$default_endian" != x; then
 450   sim_endian="-DWITH_DEFAULT_TARGET_BYTE_ORDER=${default_endian}"
 451 else
 452   if test x"$wire_endian" != x; then
 453     sim_endian="-DWITH_TARGET_BYTE_ORDER=${wire_endian}"
 454   else
 455     sim_endian=
 456   fi
 457 fi])dnl
 458 ])
 459 AC_SUBST(sim_endian)
 460
 461
 462 dnl --enable-sim-hostendian is for users of the simulator when
 463 dnl they find that AC_C_BIGENDIAN does not function correctly
 464 dnl (for instance in a canadian cross)
 465 AC_DEFUN([SIM_AC_OPTION_HOSTENDIAN],
 466 [
 467 AC_ARG_ENABLE(sim-hostendian,
 468 [  --enable-sim-hostendian=end          Specify host byte endian orientation.],
 469 [case "${enableval}" in
 470   no)    sim_hostendian="-DWITH_HOST_BYTE_ORDER=0";;
 471   b*|B*) sim_hostendian="-DWITH_HOST_BYTE_ORDER=BIG_ENDIAN";;
 472   l*|L*) sim_hostendian="-DWITH_HOST_BYTE_ORDER=LITTLE_ENDIAN";;
 473   *)     AC_MSG_ERROR("Unknown value $enableval for --enable-sim-hostendian"); sim_hostendian="";;
 474 esac
 475 if test x"$silent" != x"yes" && test x"$sim_hostendian" != x""; then
 476   echo "Setting hostendian flags = $sim_hostendian" 6>&1
 477 fi],[
 478 if test "x$cross_compiling" = "xno"; then
 479   AC_C_BIGENDIAN
 480   if test $ac_cv_c_bigendian = yes; then
 481     sim_hostendian="-DWITH_HOST_BYTE_ORDER=BIG_ENDIAN"
 482   else
 483     sim_hostendian="-DWITH_HOST_BYTE_ORDER=LITTLE_ENDIAN"
 484   fi
 485 else
 486   sim_hostendian="-DWITH_HOST_BYTE_ORDER=0"
 487 fi])dnl
 488 ])
 489 AC_SUBST(sim_hostendian)
 490
 491
 492 dnl --enable-sim-float is for developers of the simulator
 493 dnl It specifies the presence of hardware floating point
 494 dnl And optionally the bitsize of the floating point register.
 495 dnl arg[1] specifies the presence (or absence) of floating point hardware
 496 dnl arg[2] specifies the number of bits in a floating point register
 497 AC_DEFUN([SIM_AC_OPTION_FLOAT],
 498 [
 499 default_sim_float="[$1]"
 500 default_sim_float_bitsize="[$2]"
 501 AC_ARG_ENABLE(sim-float,
 502 [  --enable-sim-float                   Specify that the target processor has floating point hardware.],
 503 [case "${enableval}" in
 504   yes | hard)   sim_float="-DWITH_FLOATING_POINT=HARD_FLOATING_POINT";;
 505   no | soft)    sim_float="-DWITH_FLOATING_POINT=SOFT_FLOATING_POINT";;
 506   32)           sim_float="-DWITH_FLOATING_POINT=HARD_FLOATING_POINT -DWITH_TARGET_FLOATING_POINT_BITSIZE=32";;
 507   64)           sim_float="-DWITH_FLOATING_POINT=HARD_FLOATING_POINT -DWITH_TARGET_FLOATING_POINT_BITSIZE=64";;
 508   *)            AC_MSG_ERROR("Unknown value $enableval passed to --enable-sim-float"); sim_float="";;
 509 esac
 510 if test x"$silent" != x"yes" && test x"$sim_float" != x""; then
 511   echo "Setting float flags = $sim_float" 6>&1
 512 fi],[
 513 sim_float=
 514 if test x"${default_sim_float}" != x""; then
 515   sim_float="-DWITH_FLOATING_POINT=${default_sim_float}"
 516 fi
 517 if test x"${default_sim_float_bitsize}" != x""; then
 518   sim_float="$sim_float -DWITH_TARGET_FLOATING_POINT_BITSIZE=${default_sim_float_bitsize}"
 519 fi
 520 ])dnl
 521 ])
 522 AC_SUBST(sim_float)
 523
 524
 525 dnl The argument is the default cache size if none is specified.
 526 AC_DEFUN([SIM_AC_OPTION_SCACHE],
 527 [
 528 default_sim_scache="ifelse([$1],,0,[$1])"
 529 AC_ARG_ENABLE(sim-scache,
 530 [  --enable-sim-scache=size             Specify simulator execution cache size.],
 531 [case "${enableval}" in
 532   yes)  sim_scache="-DWITH_SCACHE=${default_sim_scache}";;
 533   no)   sim_scache="-DWITH_SCACHE=0" ;;
 534   [[0-9]]*) sim_scache="-DWITH_SCACHE=${enableval}";;
 535   *)    AC_MSG_ERROR("Bad value $enableval passed to --enable-sim-scache");
 536         sim_scache="";;
 537 esac
 538 if test x"$silent" != x"yes" && test x"$sim_scache" != x""; then
 539   echo "Setting scache size = $sim_scache" 6>&1
 540 fi],[sim_scache="-DWITH_SCACHE=${default_sim_scache}"])
 541 ])
 542 AC_SUBST(sim_scache)
 543
 544
 545 dnl The argument is the default model if none is specified.
 546 AC_DEFUN([SIM_AC_OPTION_DEFAULT_MODEL],
 547 [
 548 default_sim_default_model="ifelse([$1],,0,[$1])"
 549 AC_ARG_ENABLE(sim-default-model,
 550 [  --enable-sim-default-model=model     Specify default model to simulate.],
 551 [case "${enableval}" in
 552   yes|no) AC_MSG_ERROR("Missing argument to --enable-sim-default-model");;
 553   *)    sim_default_model="-DWITH_DEFAULT_MODEL='\"${enableval}\"'";;
 554 esac
 555 if test x"$silent" != x"yes" && test x"$sim_default_model" != x""; then
 556   echo "Setting default model = $sim_default_model" 6>&1
 557 fi],[sim_default_model="-DWITH_DEFAULT_MODEL='\"${default_sim_default_model}\"'"])
 558 ])
 559 AC_SUBST(sim_default_model)
 560
 561
 562 dnl --enable-sim-hardware is for users of the simulator
 563 dnl arg[1] Enable sim-hw by default? ("yes" or "no")
 564 dnl arg[2] is a space separated list of devices that override the defaults
 565 dnl arg[3] is a space separated list of extra target specific devices.
 566 AC_DEFUN([SIM_AC_OPTION_HARDWARE],
 567 [
 568 if test x"[$1]" = x"yes"; then
 569   sim_hw_p=yes
 570 else
 571   sim_hw_p=no
 572 fi
 573 if test "[$2]"; then
 574   hardware="core pal glue"
 575 else
 576   hardware="core pal glue [$3]"
 577 fi
 578 sim_hw_cflags="-DWITH_HW=1"
 579 sim_hw="$hardware"
 580 sim_hw_objs="\$(SIM_COMMON_HW_OBJS) `echo $sim_hw | sed -e 's/\([[^ ]][[^ ]]*\)/dv-\1.o/g'`"
 581 AC_ARG_ENABLE(sim-hardware,
 582 [  --enable-sim-hardware=LIST           Specify the hardware to be included in the build.],
 583 [
 584 case "${enableval}" in
 585   yes)  sim_hw_p=yes;;
 586   no)   sim_hw_p=no;;
 587   ,*)   sim_hw_p=yes; hardware="${hardware} `echo ${enableval} | sed -e 's/,/ /'`";;
 588   *,)   sim_hw_p=yes; hardware="`echo ${enableval} | sed -e 's/,/ /'` ${hardware}";;
 589   *)    sim_hw_p=yes; hardware="`echo ${enableval} | sed -e 's/,/ /'`"'';;
 590 esac
 591 if test "$sim_hw_p" != yes; then
 592   sim_hw_objs=
 593   sim_hw_cflags="-DWITH_HW=0"
 594   sim_hw=
 595 else
 596   sim_hw_cflags="-DWITH_HW=1"
 597   # remove duplicates
 598   sim_hw=""
 599   sim_hw_objs="\$(SIM_COMMON_HW_OBJS)"
 600   for i in $hardware ; do
 601     case " $sim_hw " in
 602       *" $i "*) ;;
 603       *) sim_hw="$sim_hw $i" ; sim_hw_objs="$sim_hw_objs dv-$i.o";;
 604     esac
 605   done
 606 fi
 607 if test x"$silent" != x"yes" && test "$sim_hw_p" = "yes"; then
 608   echo "Setting hardware to $sim_hw_cflags, $sim_hw, $sim_hw_objs"
 609 fi],[
 610 if test "$sim_hw_p" != yes; then
 611   sim_hw_objs=
 612   sim_hw_cflags="-DWITH_HW=0"
 613   sim_hw=
 614 fi
 615 if test x"$silent" != x"yes"; then
 616   echo "Setting hardware to $sim_hw_cflags, $sim_hw, $sim_hw_objs"
 617 fi])dnl
 618 ])
 619 AC_SUBST(sim_hw_cflags)
 620 AC_SUBST(sim_hw_objs)
 621 AC_SUBST(sim_hw)
 622
 623
 624 dnl --enable-sim-inline is for users that wish to ramp up the simulator's
 625 dnl performance by inlining functions.
 626 dnl Guarantee that unconfigured simulators do not do any inlining
 627 sim_inline="-DDEFAULT_INLINE=0"
 628 AC_DEFUN([SIM_AC_OPTION_INLINE],
 629 [
 630 default_sim_inline="ifelse([$1],,,-DDEFAULT_INLINE=[$1])"
 631 AC_ARG_ENABLE(sim-inline,
 632 [  --enable-sim-inline=inlines          Specify which functions should be inlined.],
 633 [sim_inline=""
 634 case "$enableval" in
 635   no)           sim_inline="-DDEFAULT_INLINE=0";;
 636   0)            sim_inline="-DDEFAULT_INLINE=0";;
 637   yes | 2)      sim_inline="-DDEFAULT_INLINE=ALL_C_INLINE";;
 638   1)            sim_inline="-DDEFAULT_INLINE=INLINE_LOCALS";;
 639   *) for x in `echo "$enableval" | sed -e "s/,/ /g"`; do
 640        new_flag=""
 641        case "$x" in
 642          *_INLINE=*)    new_flag="-D$x";;
 643          *=*)           new_flag=`echo "$x" | sed -e "s/=/_INLINE=/" -e "s/^/-D/"`;;
 644          *_INLINE)      new_flag="-D$x=ALL_C_INLINE";;
 645          *)             new_flag="-D$x""_INLINE=ALL_C_INLINE";;
 646        esac
 647        if test x"$sim_inline" = x""; then
 648          sim_inline="$new_flag"
 649        else
 650          sim_inline="$sim_inline $new_flag"
 651        fi
 652      done;;
 653 esac
 654 if test x"$silent" != x"yes" && test x"$sim_inline" != x""; then
 655   echo "Setting inline flags = $sim_inline" 6>&1
 656 fi],[
 657 if test "x$cross_compiling" = "xno"; then
 658   if test x"$GCC" != "x" -a x"${default_sim_inline}" != "x" ; then
 659     sim_inline="${default_sim_inline}"
 660     if test x"$silent" != x"yes"; then
 661       echo "Setting inline flags = $sim_inline" 6>&1
 662     fi
 663   else
 664     sim_inline=""
 665   fi
 666 else
 667   sim_inline="-DDEFAULT_INLINE=0"
 668 fi])dnl
 669 ])
 670 AC_SUBST(sim_inline)
 671
 672
 673 AC_DEFUN([SIM_AC_OPTION_PACKAGES],
 674 [
 675 AC_ARG_ENABLE(sim-packages,
 676 [  --enable-sim-packages=list           Specify the packages to be included in the build.],
 677 [packages=disklabel
 678 case "${enableval}" in
 679   yes)  ;;
 680   no)   AC_MSG_ERROR("List of packages must be specified for --enable-sim-packages"); packages="";;
 681   ,*)   packages="${packages}${enableval}";;
 682   *,)   packages="${enableval}${packages}";;
 683   *)    packages="${enableval}"'';;
 684 esac
 685 sim_pk_src=`echo $packages | sed -e 's/,/.c pk_/g' -e 's/^/pk_/' -e 's/$/.c/'`
 686 sim_pk_obj=`echo $sim_pk_src | sed -e 's/\.c/.o/g'`
 687 if test x"$silent" != x"yes" && test x"$packages" != x""; then
 688   echo "Setting packages to $sim_pk_src, $sim_pk_obj"
 689 fi],[packages=disklabel
 690 sim_pk_src=`echo $packages | sed -e 's/,/.c pk_/g' -e 's/^/pk_/' -e 's/$/.c/'`
 691 sim_pk_obj=`echo $sim_pk_src | sed -e 's/\.c/.o/g'`
 692 if test x"$silent" != x"yes"; then
 693   echo "Setting packages to $sim_pk_src, $sim_pk_obj"
 694 fi])dnl
 695 ])
 696 AC_SUBST(sim_packages)
 697
 698
 699 AC_DEFUN([SIM_AC_OPTION_REGPARM],
 700 [
 701 AC_ARG_ENABLE(sim-regparm,
 702 [  --enable-sim-regparm=nr-parm         Pass parameters in registers instead of on the stack - x86/GCC specific.],
 703 [case "${enableval}" in
 704   0*|1*|2*|3*|4*|5*|6*|7*|8*|9*) sim_regparm="-DWITH_REGPARM=${enableval}";;
 705   no)                            sim_regparm="" ;;
 706   yes)                           sim_regparm="-DWITH_REGPARM=3";;
 707   *)   AC_MSG_ERROR("Unknown value $enableval for --enable-sim-regparm"); sim_regparm="";;
 708 esac
 709 if test x"$silent" != x"yes" && test x"$sim_regparm" != x""; then
 710   echo "Setting regparm flags = $sim_regparm" 6>&1
 711 fi],[sim_regparm=""])dnl
 712 ])
 713 AC_SUBST(sim_regparm)
 714
 715
 716 AC_DEFUN([SIM_AC_OPTION_RESERVED_BITS],
 717 [
 718 default_sim_reserved_bits="ifelse([$1],,1,[$1])"
 719 AC_ARG_ENABLE(sim-reserved-bits,
 720 [  --enable-sim-reserved-bits           Specify whether to check reserved bits in instruction.],
 721 [case "${enableval}" in
 722   yes)  sim_reserved_bits="-DWITH_RESERVED_BITS=1";;
 723   no)   sim_reserved_bits="-DWITH_RESERVED_BITS=0";;
 724   *)    AC_MSG_ERROR("--enable-sim-reserved-bits does not take a value"); sim_reserved_bits="";;
 725 esac
 726 if test x"$silent" != x"yes" && test x"$sim_reserved_bits" != x""; then
 727   echo "Setting reserved flags = $sim_reserved_bits" 6>&1
 728 fi],[sim_reserved_bits="-DWITH_RESERVED_BITS=${default_sim_reserved_bits}"])dnl
 729 ])
 730 AC_SUBST(sim_reserved_bits)
 731
 732
 733 AC_DEFUN([SIM_AC_OPTION_SMP],
 734 [
 735 default_sim_smp="ifelse([$1],,5,[$1])"
 736 AC_ARG_ENABLE(sim-smp,
 737 [  --enable-sim-smp=n                   Specify number of processors to configure for (default ${default_sim_smp}).],
 738 [case "${enableval}" in
 739   yes)  sim_smp="-DWITH_SMP=5" ; sim_igen_smp="-N 5";;
 740   no)   sim_smp="-DWITH_SMP=0" ; sim_igen_smp="-N 0";;
 741   *)    sim_smp="-DWITH_SMP=$enableval" ; sim_igen_smp="-N $enableval";;
 742 esac
 743 if test x"$silent" != x"yes" && test x"$sim_smp" != x""; then
 744   echo "Setting smp flags = $sim_smp" 6>&1
 745 fi],[sim_smp="-DWITH_SMP=${default_sim_smp}" ; sim_igen_smp="-N ${default_sim_smp}"
 746 if test x"$silent" != x"yes"; then
 747   echo "Setting smp flags = $sim_smp" 6>&1
 748 fi])dnl
 749 ])
 750 AC_SUBST(sim_smp)
 751
 752
 753 AC_DEFUN([SIM_AC_OPTION_STDCALL],
 754 [
 755 AC_ARG_ENABLE(sim-stdcall,
 756 [  --enable-sim-stdcall=type            Use an alternative function call/return mechanism - x86/GCC specific.],
 757 [case "${enableval}" in
 758   no)           sim_stdcall="" ;;
 759   std*)         sim_stdcall="-DWITH_STDCALL=1";;
 760   yes)          sim_stdcall="-DWITH_STDCALL=1";;
 761   *)   AC_MSG_ERROR("Unknown value $enableval for --enable-sim-stdcall"); sim_stdcall="";;
 762 esac
 763 if test x"$silent" != x"yes" && test x"$sim_stdcall" != x""; then
 764   echo "Setting function call flags = $sim_stdcall" 6>&1
 765 fi],[sim_stdcall=""])dnl
 766 ])
 767 AC_SUBST(sim_stdcall)
 768
 769
 770 AC_DEFUN([SIM_AC_OPTION_XOR_ENDIAN],
 771 [
 772 default_sim_xor_endian="ifelse([$1],,8,[$1])"
 773 AC_ARG_ENABLE(sim-xor-endian,
 774 [  --enable-sim-xor-endian=n            Specify number bytes involved in XOR bi-endian mode (default ${default_sim_xor_endian}).],
 775 [case "${enableval}" in
 776   yes)  sim_xor_endian="-DWITH_XOR_ENDIAN=8";;
 777   no)   sim_xor_endian="-DWITH_XOR_ENDIAN=0";;
 778   *)    sim_xor_endian="-DWITH_XOR_ENDIAN=$enableval";;
 779 esac
 780 if test x"$silent" != x"yes" && test x"$sim_xor_endian" != x""; then
 781   echo "Setting xor-endian flag = $sim_xor_endian" 6>&1
 782 fi],[sim_xor_endian="-DWITH_XOR_ENDIAN=${default_sim_xor_endian}"])dnl
 783 ])
 784 AC_SUBST(sim_xor_endian)
 785
 786
 787 dnl --enable-build-warnings is for developers of the simulator.
 788 dnl it enables extra GCC specific warnings.
 789 AC_DEFUN([SIM_AC_OPTION_WARNINGS],
 790 [
 791 # NOTE: Don't add -Wall or -Wunused, they both include
 792 # -Wunused-parameter which reports bogus warnings.
 793 # NOTE: If you add to this list, remember to update
 794 # gdb/doc/gdbint.texinfo.
 795 build_warnings="-Wimplicit -Wreturn-type -Wcomment -Wtrigraphs \
 796 -Wformat -Wparentheses -Wpointer-arith"
 797 # GCC supports -Wuninitialized only with -O or -On, n != 0.
 798 if test x${CFLAGS+set} = xset; then
 799   case "${CFLAGS}" in
 800     *"-O0"* ) ;;
 801     *"-O"* )
 802       build_warnings="${build_warnings} -Wuninitialized"
 803     ;;
 804   esac
 805 else
 806   build_warnings="${build_warnings} -Wuninitialized"
 807 fi
 808 # Up for debate: -Wswitch -Wcomment -trigraphs -Wtrigraphs
 809 # -Wunused-function -Wunused-label -Wunused-variable -Wunused-value
 810 # -Wchar-subscripts -Wtraditional -Wshadow -Wcast-qual
 811 # -Wcast-align -Wwrite-strings -Wconversion -Wstrict-prototypes
 812 # -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls
 813 # -Woverloaded-virtual -Winline -Werror"
 814 AC_ARG_ENABLE(build-warnings,
 815 [  --enable-build-warnings Enable build-time compiler warnings if gcc is used],
 816 [case "${enableval}" in
 817   yes)  ;;
 818   no)   build_warnings="-w";;
 819   ,*)   t=`echo "${enableval}" | sed -e "s/,/ /g"`
 820         build_warnings="${build_warnings} ${t}";;
 821   *,)   t=`echo "${enableval}" | sed -e "s/,/ /g"`
 822         build_warnings="${t} ${build_warnings}";;
 823   *)    build_warnings=`echo "${enableval}" | sed -e "s/,/ /g"`;;
 824 esac
 825 if test x"$silent" != x"yes" && test x"$build_warnings" != x""; then
 826   echo "Setting compiler warning flags = $build_warnings" 6>&1
 827 fi])dnl
 828 AC_ARG_ENABLE(sim-build-warnings,
 829 [  --enable-gdb-build-warnings Enable SIM specific build-time compiler warnings if gcc is used],
 830 [case "${enableval}" in
 831   yes)  ;;
 832   no)   build_warnings="-w";;
 833   ,*)   t=`echo "${enableval}" | sed -e "s/,/ /g"`
 834         build_warnings="${build_warnings} ${t}";;
 835   *,)   t=`echo "${enableval}" | sed -e "s/,/ /g"`
 836         build_warnings="${t} ${build_warnings}";;
 837   *)    build_warnings=`echo "${enableval}" | sed -e "s/,/ /g"`;;
 838 esac
 839 if test x"$silent" != x"yes" && test x"$build_warnings" != x""; then
 840   echo "Setting GDB specific compiler warning flags = $build_warnings" 6>&1
 841 fi])dnl
 842 WARN_CFLAGS=""
 843 WERROR_CFLAGS=""
 844 if test "x${build_warnings}" != x -a "x$GCC" = xyes
 845 then
 846     AC_MSG_CHECKING(compiler warning flags)
 847     # Separate out the -Werror flag as some files just cannot be
 848     # compiled with it enabled.
 849     for w in ${build_warnings}; do
 850         case $w in
 851         -Werr*) WERROR_CFLAGS=-Werror ;;
 852         *) # Check that GCC accepts it
 853             saved_CFLAGS="$CFLAGS"
 854             CFLAGS="$CFLAGS $w"
 855             AC_TRY_COMPILE([],[],WARN_CFLAGS="${WARN_CFLAGS} $w",)
 856             CFLAGS="$saved_CFLAGS"
 857         esac
 858     done
 859     AC_MSG_RESULT(${WARN_CFLAGS}${WERROR_CFLAGS})
 860 fi
 861 ])
 862 AC_SUBST(WARN_CFLAGS)
 863 AC_SUBST(WERROR_CFLAGS)
 864
 865
 866 dnl Generate the Makefile in a target specific directory.
 867 dnl Substitutions aren't performed on the file in AC_SUBST_FILE,
 868 dnl so this is a cover macro to tuck the details away of how we cope.
 869 dnl We cope by having autoconf generate two files and then merge them into
 870 dnl one afterwards.  The two pieces of the common fragment are inserted into
 871 dnl the target's fragment at the appropriate points.
 872
 873 AC_DEFUN([SIM_AC_OUTPUT],
 874 [
 875 AC_LINK_FILES($sim_link_files, $sim_link_links)
 876 dnl Make @cgen_breaks@ non-null only if the sim uses CGEN.
 877 cgen_breaks=""
 878 if grep CGEN_MAINT $srcdir/Makefile.in >/dev/null; then
 879 cgen_breaks="break cgen_rtx_error";
 880 fi
 881 AC_SUBST(cgen_breaks)
 882 AC_CONFIG_FILES(Makefile.sim:Makefile.in)
 883 AC_CONFIG_FILES(Make-common.sim:../common/Make-common.in)
 884 AC_CONFIG_FILES(.gdbinit:../common/gdbinit.in)
 885 AC_CONFIG_COMMANDS([Makefile],
 886 [echo "Merging Makefile.sim+Make-common.sim into Makefile ..."
 887  rm -f Makesim1.tmp Makesim2.tmp Makefile
 888  sed -n -e '/^## COMMON_PRE_/,/^## End COMMON_PRE_/ p' <Make-common.sim >Makesim1.tmp
 889  sed -n -e '/^## COMMON_POST_/,/^## End COMMON_POST_/ p' <Make-common.sim >Makesim2.tmp
 890  sed -e '/^## COMMON_PRE_/ r Makesim1.tmp' \
 891         -e '/^## COMMON_POST_/ r Makesim2.tmp' \
 892         <Makefile.sim >Makefile
 893  rm -f Makefile.sim Make-common.sim Makesim1.tmp Makesim2.tmp
 894 ])
 895 AC_CONFIG_COMMANDS([stamp-h], [echo > stamp-h])
 896 AC_OUTPUT
 897 ])
 898
 899 sinclude(../../config/gettext-sister.m4)
 900 sinclude(../../config/acx.m4)
 901
 902 dnl --enable-cgen-maint support
 903 AC_DEFUN([SIM_AC_OPTION_CGEN_MAINT],
 904 [
 905 cgen_maint=no
 906 dnl Default is to use one in build tree.
 907 cgen=guile
 908 cgendir='$(srcdir)/../../cgen'
 909 dnl Having --enable-maintainer-mode take arguments is another way to go.
 910 dnl ??? One can argue --with is more appropriate if one wants to specify
 911 dnl a directory name, but what we're doing here is an enable/disable kind
 912 dnl of thing and specifying both --enable and --with is klunky.
 913 dnl If you reeely want this to be --with, go ahead and change it.
 914 AC_ARG_ENABLE(cgen-maint,
 915 [  --enable-cgen-maint[=DIR]    build cgen generated files],
 916 [case "${enableval}" in
 917   yes)  cgen_maint=yes ;;
 918   no)   cgen_maint=no ;;
 919   *)
 920         # argument is cgen install directory (not implemented yet).
 921         # Having a `share' directory might be more appropriate for the .scm,
 922         # .cpu, etc. files.
 923         cgendir=${cgen_maint}/lib/cgen
 924         cgen=guile
 925         ;;
 926 esac])dnl
 927 dnl AM_CONDITIONAL(CGEN_MAINT, test x${cgen_maint} != xno)
 928 if test x${cgen_maint} != xno ; then
 929   CGEN_MAINT=''
 930 else
 931   CGEN_MAINT='#'
 932 fi
 933 AC_SUBST(CGEN_MAINT)
 934 AC_SUBST(cgendir)
 935 AC_SUBST(cgen)
 936 ])