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