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