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="[$2]"
 575 else
 576   hardware="core pal glue"
 577 fi
 578 hardware="$hardware [$3]"
 579 sim_hw_cflags="-DWITH_HW=1"
 580 sim_hw="$hardware"
 581 sim_hw_objs="\$(SIM_COMMON_HW_OBJS) `echo $sim_hw | sed -e 's/\([[^ ]][[^ ]]*\)/dv-\1.o/g'`"
 582 AC_ARG_ENABLE(sim-hardware,
 583 [  --enable-sim-hardware=LIST           Specify the hardware to be included in the build.],
 584 [
 585 case "${enableval}" in
 586   yes)  sim_hw_p=yes;;
 587   no)   sim_hw_p=no;;
 588   ,*)   sim_hw_p=yes; hardware="${hardware} `echo ${enableval} | sed -e 's/,/ /'`";;
 589   *,)   sim_hw_p=yes; hardware="`echo ${enableval} | sed -e 's/,/ /'` ${hardware}";;
 590   *)    sim_hw_p=yes; hardware="`echo ${enableval} | sed -e 's/,/ /'`"'';;
 591 esac
 592 if test "$sim_hw_p" != yes; then
 593   sim_hw_objs=
 594   sim_hw_cflags="-DWITH_HW=0"
 595   sim_hw=
 596 else
 597   sim_hw_cflags="-DWITH_HW=1"
 598   # remove duplicates
 599   sim_hw=""
 600   sim_hw_objs="\$(SIM_COMMON_HW_OBJS)"
 601   for i in $hardware ; do
 602     case " $sim_hw " in
 603       *" $i "*) ;;
 604       *) sim_hw="$sim_hw $i" ; sim_hw_objs="$sim_hw_objs dv-$i.o";;
 605     esac
 606   done
 607 fi
 608 if test x"$silent" != x"yes" && test "$sim_hw_p" = "yes"; then
 609   echo "Setting hardware to $sim_hw_cflags, $sim_hw, $sim_hw_objs"
 610 fi],[
 611 if test "$sim_hw_p" != yes; then
 612   sim_hw_objs=
 613   sim_hw_cflags="-DWITH_HW=0"
 614   sim_hw=
 615 fi
 616 if test x"$silent" != x"yes"; then
 617   echo "Setting hardware to $sim_hw_cflags, $sim_hw, $sim_hw_objs"
 618 fi])dnl
 619 ])
 620 AC_SUBST(sim_hw_cflags)
 621 AC_SUBST(sim_hw_objs)
 622 AC_SUBST(sim_hw)
 623
 624
 625 dnl --enable-sim-inline is for users that wish to ramp up the simulator's
 626 dnl performance by inlining functions.
 627 dnl Guarantee that unconfigured simulators do not do any inlining
 628 sim_inline="-DDEFAULT_INLINE=0"
 629 AC_DEFUN([SIM_AC_OPTION_INLINE],
 630 [
 631 default_sim_inline="ifelse([$1],,,-DDEFAULT_INLINE=[$1])"
 632 AC_ARG_ENABLE(sim-inline,
 633 [  --enable-sim-inline=inlines          Specify which functions should be inlined.],
 634 [sim_inline=""
 635 case "$enableval" in
 636   no)           sim_inline="-DDEFAULT_INLINE=0";;
 637   0)            sim_inline="-DDEFAULT_INLINE=0";;
 638   yes | 2)      sim_inline="-DDEFAULT_INLINE=ALL_C_INLINE";;
 639   1)            sim_inline="-DDEFAULT_INLINE=INLINE_LOCALS";;
 640   *) for x in `echo "$enableval" | sed -e "s/,/ /g"`; do
 641        new_flag=""
 642        case "$x" in
 643          *_INLINE=*)    new_flag="-D$x";;
 644          *=*)           new_flag=`echo "$x" | sed -e "s/=/_INLINE=/" -e "s/^/-D/"`;;
 645          *_INLINE)      new_flag="-D$x=ALL_C_INLINE";;
 646          *)             new_flag="-D$x""_INLINE=ALL_C_INLINE";;
 647        esac
 648        if test x"$sim_inline" = x""; then
 649          sim_inline="$new_flag"
 650        else
 651          sim_inline="$sim_inline $new_flag"
 652        fi
 653      done;;
 654 esac
 655 if test x"$silent" != x"yes" && test x"$sim_inline" != x""; then
 656   echo "Setting inline flags = $sim_inline" 6>&1
 657 fi],[
 658 if test "x$cross_compiling" = "xno"; then
 659   if test x"$GCC" != "x" -a x"${default_sim_inline}" != "x" ; then
 660     sim_inline="${default_sim_inline}"
 661     if test x"$silent" != x"yes"; then
 662       echo "Setting inline flags = $sim_inline" 6>&1
 663     fi
 664   else
 665     sim_inline=""
 666   fi
 667 else
 668   sim_inline="-DDEFAULT_INLINE=0"
 669 fi])dnl
 670 ])
 671 AC_SUBST(sim_inline)
 672
 673
 674 AC_DEFUN([SIM_AC_OPTION_PACKAGES],
 675 [
 676 AC_ARG_ENABLE(sim-packages,
 677 [  --enable-sim-packages=list           Specify the packages to be included in the build.],
 678 [packages=disklabel
 679 case "${enableval}" in
 680   yes)  ;;
 681   no)   AC_MSG_ERROR("List of packages must be specified for --enable-sim-packages"); packages="";;
 682   ,*)   packages="${packages}${enableval}";;
 683   *,)   packages="${enableval}${packages}";;
 684   *)    packages="${enableval}"'';;
 685 esac
 686 sim_pk_src=`echo $packages | sed -e 's/,/.c pk_/g' -e 's/^/pk_/' -e 's/$/.c/'`
 687 sim_pk_obj=`echo $sim_pk_src | sed -e 's/\.c/.o/g'`
 688 if test x"$silent" != x"yes" && test x"$packages" != x""; then
 689   echo "Setting packages to $sim_pk_src, $sim_pk_obj"
 690 fi],[packages=disklabel
 691 sim_pk_src=`echo $packages | sed -e 's/,/.c pk_/g' -e 's/^/pk_/' -e 's/$/.c/'`
 692 sim_pk_obj=`echo $sim_pk_src | sed -e 's/\.c/.o/g'`
 693 if test x"$silent" != x"yes"; then
 694   echo "Setting packages to $sim_pk_src, $sim_pk_obj"
 695 fi])dnl
 696 ])
 697 AC_SUBST(sim_packages)
 698
 699
 700 AC_DEFUN([SIM_AC_OPTION_REGPARM],
 701 [
 702 AC_ARG_ENABLE(sim-regparm,
 703 [  --enable-sim-regparm=nr-parm         Pass parameters in registers instead of on the stack - x86/GCC specific.],
 704 [case "${enableval}" in
 705   0*|1*|2*|3*|4*|5*|6*|7*|8*|9*) sim_regparm="-DWITH_REGPARM=${enableval}";;
 706   no)                            sim_regparm="" ;;
 707   yes)                           sim_regparm="-DWITH_REGPARM=3";;
 708   *)   AC_MSG_ERROR("Unknown value $enableval for --enable-sim-regparm"); sim_regparm="";;
 709 esac
 710 if test x"$silent" != x"yes" && test x"$sim_regparm" != x""; then
 711   echo "Setting regparm flags = $sim_regparm" 6>&1
 712 fi],[sim_regparm=""])dnl
 713 ])
 714 AC_SUBST(sim_regparm)
 715
 716
 717 AC_DEFUN([SIM_AC_OPTION_RESERVED_BITS],
 718 [
 719 default_sim_reserved_bits="ifelse([$1],,1,[$1])"
 720 AC_ARG_ENABLE(sim-reserved-bits,
 721 [  --enable-sim-reserved-bits           Specify whether to check reserved bits in instruction.],
 722 [case "${enableval}" in
 723   yes)  sim_reserved_bits="-DWITH_RESERVED_BITS=1";;
 724   no)   sim_reserved_bits="-DWITH_RESERVED_BITS=0";;
 725   *)    AC_MSG_ERROR("--enable-sim-reserved-bits does not take a value"); sim_reserved_bits="";;
 726 esac
 727 if test x"$silent" != x"yes" && test x"$sim_reserved_bits" != x""; then
 728   echo "Setting reserved flags = $sim_reserved_bits" 6>&1
 729 fi],[sim_reserved_bits="-DWITH_RESERVED_BITS=${default_sim_reserved_bits}"])dnl
 730 ])
 731 AC_SUBST(sim_reserved_bits)
 732
 733
 734 AC_DEFUN([SIM_AC_OPTION_SMP],
 735 [
 736 default_sim_smp="ifelse([$1],,5,[$1])"
 737 AC_ARG_ENABLE(sim-smp,
 738 [  --enable-sim-smp=n                   Specify number of processors to configure for (default ${default_sim_smp}).],
 739 [case "${enableval}" in
 740   yes)  sim_smp="-DWITH_SMP=5" ; sim_igen_smp="-N 5";;
 741   no)   sim_smp="-DWITH_SMP=0" ; sim_igen_smp="-N 0";;
 742   *)    sim_smp="-DWITH_SMP=$enableval" ; sim_igen_smp="-N $enableval";;
 743 esac
 744 if test x"$silent" != x"yes" && test x"$sim_smp" != x""; then
 745   echo "Setting smp flags = $sim_smp" 6>&1
 746 fi],[sim_smp="-DWITH_SMP=${default_sim_smp}" ; sim_igen_smp="-N ${default_sim_smp}"
 747 if test x"$silent" != x"yes"; then
 748   echo "Setting smp flags = $sim_smp" 6>&1
 749 fi])dnl
 750 ])
 751 AC_SUBST(sim_smp)
 752
 753
 754 AC_DEFUN([SIM_AC_OPTION_STDCALL],
 755 [
 756 AC_ARG_ENABLE(sim-stdcall,
 757 [  --enable-sim-stdcall=type            Use an alternative function call/return mechanism - x86/GCC specific.],
 758 [case "${enableval}" in
 759   no)           sim_stdcall="" ;;
 760   std*)         sim_stdcall="-DWITH_STDCALL=1";;
 761   yes)          sim_stdcall="-DWITH_STDCALL=1";;
 762   *)   AC_MSG_ERROR("Unknown value $enableval for --enable-sim-stdcall"); sim_stdcall="";;
 763 esac
 764 if test x"$silent" != x"yes" && test x"$sim_stdcall" != x""; then
 765   echo "Setting function call flags = $sim_stdcall" 6>&1
 766 fi],[sim_stdcall=""])dnl
 767 ])
 768 AC_SUBST(sim_stdcall)
 769
 770
 771 AC_DEFUN([SIM_AC_OPTION_XOR_ENDIAN],
 772 [
 773 default_sim_xor_endian="ifelse([$1],,8,[$1])"
 774 AC_ARG_ENABLE(sim-xor-endian,
 775 [  --enable-sim-xor-endian=n            Specify number bytes involved in XOR bi-endian mode (default ${default_sim_xor_endian}).],
 776 [case "${enableval}" in
 777   yes)  sim_xor_endian="-DWITH_XOR_ENDIAN=8";;
 778   no)   sim_xor_endian="-DWITH_XOR_ENDIAN=0";;
 779   *)    sim_xor_endian="-DWITH_XOR_ENDIAN=$enableval";;
 780 esac
 781 if test x"$silent" != x"yes" && test x"$sim_xor_endian" != x""; then
 782   echo "Setting xor-endian flag = $sim_xor_endian" 6>&1
 783 fi],[sim_xor_endian="-DWITH_XOR_ENDIAN=${default_sim_xor_endian}"])dnl
 784 ])
 785 AC_SUBST(sim_xor_endian)
 786
 787
 788 dnl --enable-build-warnings is for developers of the simulator.
 789 dnl it enables extra GCC specific warnings.
 790 AC_DEFUN([SIM_AC_OPTION_WARNINGS],
 791 [
 792 # NOTE: Don't add -Wall or -Wunused, they both include
 793 # -Wunused-parameter which reports bogus warnings.
 794 # NOTE: If you add to this list, remember to update
 795 # gdb/doc/gdbint.texinfo.
 796 build_warnings="-Wimplicit -Wreturn-type -Wcomment -Wtrigraphs \
 797 -Wformat -Wparentheses -Wpointer-arith"
 798 # GCC supports -Wuninitialized only with -O or -On, n != 0.
 799 if test x${CFLAGS+set} = xset; then
 800   case "${CFLAGS}" in
 801     *"-O0"* ) ;;
 802     *"-O"* )
 803       build_warnings="${build_warnings} -Wuninitialized"
 804     ;;
 805   esac
 806 else
 807   build_warnings="${build_warnings} -Wuninitialized"
 808 fi
 809 # Up for debate: -Wswitch -Wcomment -trigraphs -Wtrigraphs
 810 # -Wunused-function -Wunused-label -Wunused-variable -Wunused-value
 811 # -Wchar-subscripts -Wtraditional -Wshadow -Wcast-qual
 812 # -Wcast-align -Wwrite-strings -Wconversion -Wstrict-prototypes
 813 # -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls
 814 # -Woverloaded-virtual -Winline -Werror"
 815 AC_ARG_ENABLE(build-warnings,
 816 [  --enable-build-warnings Enable build-time compiler warnings if gcc is used],
 817 [case "${enableval}" in
 818   yes)  ;;
 819   no)   build_warnings="-w";;
 820   ,*)   t=`echo "${enableval}" | sed -e "s/,/ /g"`
 821         build_warnings="${build_warnings} ${t}";;
 822   *,)   t=`echo "${enableval}" | sed -e "s/,/ /g"`
 823         build_warnings="${t} ${build_warnings}";;
 824   *)    build_warnings=`echo "${enableval}" | sed -e "s/,/ /g"`;;
 825 esac
 826 if test x"$silent" != x"yes" && test x"$build_warnings" != x""; then
 827   echo "Setting compiler warning flags = $build_warnings" 6>&1
 828 fi])dnl
 829 AC_ARG_ENABLE(sim-build-warnings,
 830 [  --enable-gdb-build-warnings Enable SIM specific build-time compiler warnings if gcc is used],
 831 [case "${enableval}" in
 832   yes)  ;;
 833   no)   build_warnings="-w";;
 834   ,*)   t=`echo "${enableval}" | sed -e "s/,/ /g"`
 835         build_warnings="${build_warnings} ${t}";;
 836   *,)   t=`echo "${enableval}" | sed -e "s/,/ /g"`
 837         build_warnings="${t} ${build_warnings}";;
 838   *)    build_warnings=`echo "${enableval}" | sed -e "s/,/ /g"`;;
 839 esac
 840 if test x"$silent" != x"yes" && test x"$build_warnings" != x""; then
 841   echo "Setting GDB specific compiler warning flags = $build_warnings" 6>&1
 842 fi])dnl
 843 WARN_CFLAGS=""
 844 WERROR_CFLAGS=""
 845 if test "x${build_warnings}" != x -a "x$GCC" = xyes
 846 then
 847     AC_MSG_CHECKING(compiler warning flags)
 848     # Separate out the -Werror flag as some files just cannot be
 849     # compiled with it enabled.
 850     for w in ${build_warnings}; do
 851         case $w in
 852         -Werr*) WERROR_CFLAGS=-Werror ;;
 853         *) # Check that GCC accepts it
 854             saved_CFLAGS="$CFLAGS"
 855             CFLAGS="$CFLAGS $w"
 856             AC_TRY_COMPILE([],[],WARN_CFLAGS="${WARN_CFLAGS} $w",)
 857             CFLAGS="$saved_CFLAGS"
 858         esac
 859     done
 860     AC_MSG_RESULT(${WARN_CFLAGS}${WERROR_CFLAGS})
 861 fi
 862 ])
 863 AC_SUBST(WARN_CFLAGS)
 864 AC_SUBST(WERROR_CFLAGS)
 865
 866
 867 dnl Generate the Makefile in a target specific directory.
 868 dnl Substitutions aren't performed on the file in AC_SUBST_FILE,
 869 dnl so this is a cover macro to tuck the details away of how we cope.
 870 dnl We cope by having autoconf generate two files and then merge them into
 871 dnl one afterwards.  The two pieces of the common fragment are inserted into
 872 dnl the target's fragment at the appropriate points.
 873
 874 AC_DEFUN([SIM_AC_OUTPUT],
 875 [
 876 AC_LINK_FILES($sim_link_files, $sim_link_links)
 877 dnl Make @cgen_breaks@ non-null only if the sim uses CGEN.
 878 cgen_breaks=""
 879 if grep CGEN_MAINT $srcdir/Makefile.in >/dev/null; then
 880 cgen_breaks="break cgen_rtx_error";
 881 fi
 882 AC_SUBST(cgen_breaks)
 883 AC_CONFIG_FILES(Makefile.sim:Makefile.in)
 884 AC_CONFIG_FILES(Make-common.sim:../common/Make-common.in)
 885 AC_CONFIG_FILES(.gdbinit:../common/gdbinit.in)
 886 AC_CONFIG_COMMANDS([Makefile],
 887 [echo "Merging Makefile.sim+Make-common.sim into Makefile ..."
 888  rm -f Makesim1.tmp Makesim2.tmp Makefile
 889  sed -n -e '/^## COMMON_PRE_/,/^## End COMMON_PRE_/ p' <Make-common.sim >Makesim1.tmp
 890  sed -n -e '/^## COMMON_POST_/,/^## End COMMON_POST_/ p' <Make-common.sim >Makesim2.tmp
 891  sed -e '/^## COMMON_PRE_/ r Makesim1.tmp' \
 892         -e '/^## COMMON_POST_/ r Makesim2.tmp' \
 893         <Makefile.sim >Makefile
 894  rm -f Makefile.sim Make-common.sim Makesim1.tmp Makesim2.tmp
 895 ])
 896 AC_CONFIG_COMMANDS([stamp-h], [echo > stamp-h])
 897 AC_OUTPUT
 898 ])
 899
 900 sinclude(../../config/gettext-sister.m4)
 901 sinclude(../../config/acx.m4)
 902
 903 dnl --enable-cgen-maint support
 904 AC_DEFUN([SIM_AC_OPTION_CGEN_MAINT],
 905 [
 906 cgen_maint=no
 907 dnl Default is to use one in build tree.
 908 cgen=guile
 909 cgendir='$(srcdir)/../../cgen'
 910 dnl Having --enable-maintainer-mode take arguments is another way to go.
 911 dnl ??? One can argue --with is more appropriate if one wants to specify
 912 dnl a directory name, but what we're doing here is an enable/disable kind
 913 dnl of thing and specifying both --enable and --with is klunky.
 914 dnl If you reeely want this to be --with, go ahead and change it.
 915 AC_ARG_ENABLE(cgen-maint,
 916 [  --enable-cgen-maint[=DIR]    build cgen generated files],
 917 [case "${enableval}" in
 918   yes)  cgen_maint=yes ;;
 919   no)   cgen_maint=no ;;
 920   *)
 921         # argument is cgen install directory (not implemented yet).
 922         # Having a `share' directory might be more appropriate for the .scm,
 923         # .cpu, etc. files.
 924         cgendir=${cgen_maint}/lib/cgen
 925         cgen=guile
 926         ;;
 927 esac])dnl
 928 dnl AM_CONDITIONAL(CGEN_MAINT, test x${cgen_maint} != xno)
 929 if test x${cgen_maint} != xno ; then
 930   CGEN_MAINT=''
 931 else
 932   CGEN_MAINT='#'
 933 fi
 934 AC_SUBST(CGEN_MAINT)
 935 AC_SUBST(cgendir)
 936 AC_SUBST(cgen)
 937 ])