import gdb-19990422 snapshot
authorStan Shebs <shebs@codesourcery.com>
Mon, 26 Apr 1999 18:34:20 +0000 (18:34 +0000)
committerStan Shebs <shebs@codesourcery.com>
Mon, 26 Apr 1999 18:34:20 +0000 (18:34 +0000)
354 files changed:
gdb/ChangeLog
gdb/ChangeLog-97
gdb/ChangeLog-98
gdb/Makefile.in
gdb/NEWS
gdb/README
gdb/a29k-tdep.c
gdb/a68v-nat.c
gdb/acconfig.h
gdb/acinclude.m4
gdb/aclocal.m4
gdb/alpha-tdep.c
gdb/altos-xdep.c
gdb/annotate.c
gdb/annotate.h
gdb/arc-tdep.c
gdb/arm-tdep.c
gdb/arm-xdep.c
gdb/ax-gdb.c
gdb/ax-gdb.h
gdb/ax-general.c
gdb/ax.h
gdb/bcache.c
gdb/bcache.h
gdb/blockframe.c
gdb/breakpoint.c
gdb/breakpoint.h
gdb/c-typeprint.c
gdb/coffread.c
gdb/config.in
gdb/config/a29k/tm-a29k.h
gdb/config/alpha/nm-linux.h
gdb/config/alpha/tm-alpha.h
gdb/config/alpha/xm-alphalinux.h
gdb/config/alpha/xm-alphaosf.h
gdb/config/arm/tm-arm.h
gdb/config/d10v/tm-d10v.h
gdb/config/fr30/tm-fr30.h
gdb/config/h8300/tm-h8300.h
gdb/config/i386/go32.mh
gdb/config/i386/nm-i386sco5.h
gdb/config/i386/tm-fbsd.h
gdb/config/i386/tm-i386.h
gdb/config/i386/xm-go32.h
gdb/config/m32r/tm-m32r.h
gdb/config/mn10200/tm-mn10200.h
gdb/config/mn10300/tm-mn10300.h
gdb/config/nm-gnu.h
gdb/config/pa/nm-hppah.h
gdb/config/pa/tm-hppa.h
gdb/config/powerpc/nm-aix.h
gdb/config/powerpc/tm-macos.h
gdb/config/powerpc/tm-ppc-aix.h
gdb/config/powerpc/tm-ppc-eabi.h
gdb/config/powerpc/xm-aix.h
gdb/config/rs6000/tm-rs6000-aix4.h
gdb/config/sh/tm-sh.h
gdb/config/sparc/tm-sparc.h
gdb/config/v850/tm-v850.h
gdb/configure
gdb/configure.host
gdb/configure.in
gdb/configure.tgt
gdb/convex-xdep.c
gdb/corefile.c
gdb/corelow.c
gdb/cxux-nat.c
gdb/d10v-tdep.c
gdb/dbug-rom.c
gdb/dbxread.c
gdb/defs.h
gdb/doc/ChangeLog
gdb/doc/HPPA-cfg.texi
gdb/doc/all-cfg.texi
gdb/doc/gdb.texinfo
gdb/doc/gdbint.texinfo
gdb/doc/remote.texi
gdb/doc/stabs.texinfo
gdb/dwarf2read.c
gdb/exec.c
gdb/expprint.c
gdb/expression.h
gdb/findvar.c
gdb/fr30-tdep.c
gdb/frame.h
gdb/gdbarch.c
gdb/gdbarch.h
gdb/gdbtypes.c
gdb/gdbtypes.h
gdb/gnu-nat.c
gdb/gnu-nat.h
gdb/h8300-tdep.c
gdb/hp300ux-nat.c
gdb/hppa-tdep.c
gdb/hppab-nat.c
gdb/hppah-nat.c
gdb/i386-tdep.c
gdb/i386aix-nat.c
gdb/i386mach-nat.c
gdb/i386v4-nat.c
gdb/i960-tdep.c
gdb/infcmd.c
gdb/inferior.h
gdb/inflow.c
gdb/infrun.c
gdb/inftarg.c
gdb/jv-typeprint.c
gdb/jv-valprint.c
gdb/language.h
gdb/m32r-rom.c
gdb/m32r-stub.c
gdb/m32r-tdep.c
gdb/m68k-tdep.c
gdb/m88k-nat.c
gdb/main.c
gdb/maint.c
gdb/mdebugread.c
gdb/mips-tdep.c
gdb/mn10200-tdep.c
gdb/mn10300-tdep.c
gdb/monitor.c
gdb/objfiles.c
gdb/objfiles.h
gdb/parse.c
gdb/printcmd.c
gdb/procfs.c
gdb/ptx4-nat.c
gdb/pyr-xdep.c
gdb/remote-e7000.c
gdb/remote-mips.c
gdb/remote-sds.c
gdb/remote-sim.c
gdb/remote.c
gdb/reply_mig_hack.awk
gdb/rom68k-rom.c
gdb/rs6000-nat.c
gdb/rs6000-tdep.c
gdb/ser-e7kpc.c
gdb/ser-tcp.c
gdb/ser-unix.c
gdb/sh-tdep.c
gdb/sh3-rom.c
gdb/sol-thread.c
gdb/solib.c
gdb/source.c
gdb/sparc-tdep.c
gdb/stabsread.c
gdb/stack.c
gdb/sun3-nat.c
gdb/sun386-nat.c
gdb/symfile.c
gdb/symm-nat.c
gdb/symmisc.c
gdb/symtab.c
gdb/symtab.h
gdb/target.c
gdb/target.h
gdb/testsuite/ChangeLog
gdb/testsuite/config/monitor.exp
gdb/testsuite/configure
gdb/testsuite/gdb.base/a2-run.exp
gdb/testsuite/gdb.base/break.exp
gdb/testsuite/gdb.base/call-ar-st.c
gdb/testsuite/gdb.base/call-ar-st.exp
gdb/testsuite/gdb.base/call-strs.exp
gdb/testsuite/gdb.base/commands.exp
gdb/testsuite/gdb.base/condbreak.exp
gdb/testsuite/gdb.base/default.exp
gdb/testsuite/gdb.base/display.exp
gdb/testsuite/gdb.base/ena-dis-br.exp
gdb/testsuite/gdb.base/ending-run.exp
gdb/testsuite/gdb.base/miscexprs.c
gdb/testsuite/gdb.base/miscexprs.exp
gdb/testsuite/gdb.base/sigall.exp
gdb/testsuite/gdb.base/signals.exp
gdb/testsuite/gdb.base/smoke.exp
gdb/testsuite/gdb.base/step-test.exp
gdb/testsuite/gdb.base/watchpoint.exp
gdb/testsuite/gdb.c++/classes.exp
gdb/testsuite/gdb.c++/demangle.exp
gdb/testsuite/gdb.c++/derivation.exp
gdb/testsuite/gdb.c++/method.exp
gdb/testsuite/gdb.c++/misc.cc
gdb/testsuite/gdb.c++/overload.cc
gdb/testsuite/gdb.c++/ovldbreak.exp
gdb/testsuite/gdb.c++/ref-types.exp
gdb/testsuite/gdb.c++/ref-types2.exp
gdb/testsuite/gdb.chill/tests1.ch
gdb/testsuite/gdb.chill/tests2.ch
gdb/testsuite/gdb.chill/tests2.exp
gdb/testsuite/gdb.hp/ambiguous.exp
gdb/testsuite/gdb.hp/attach.exp
gdb/testsuite/gdb.hp/attach2.exp
gdb/testsuite/gdb.hp/classes-hp.exp
gdb/testsuite/gdb.hp/ctti.exp
gdb/testsuite/gdb.hp/dbx.exp
gdb/testsuite/gdb.hp/exception.exp
gdb/testsuite/gdb.hp/foll-exec.exp
gdb/testsuite/gdb.hp/foll-fork.exp
gdb/testsuite/gdb.hp/foll-vfork.exp
gdb/testsuite/gdb.hp/hwwatchbus.exp
gdb/testsuite/gdb.hp/inherit-hp.exp
gdb/testsuite/gdb.hp/more-steps.exp
gdb/testsuite/gdb.hp/namespace.exp
gdb/testsuite/gdb.hp/optimize.exp
gdb/testsuite/gdb.hp/pxdb.exp
gdb/testsuite/gdb.hp/reg-test.exp
gdb/testsuite/gdb.hp/sized-enum.exp
gdb/testsuite/gdb.hp/so-thresh.exp
gdb/testsuite/gdb.hp/start-stop.exp
gdb/testsuite/gdb.hp/templ-hp.exp
gdb/testsuite/gdb.hp/thr-lib.exp
gdb/testsuite/gdb.hp/thr-stg.exp
gdb/testsuite/gdb.hp/virtfun-hp.exp
gdb/testsuite/gdb.hp/watch-cmd.exp
gdb/testsuite/gdb.hp/watch-hp.exp
gdb/testsuite/gdb.hp/xdb1.exp
gdb/testsuite/gdb.hp/xdb2.exp
gdb/testsuite/gdb.hp/xdb3.exp
gdb/testsuite/gdb.stabs/weird.exp
gdb/testsuite/lib/gdb.exp
gdb/thread.c
gdb/top.c
gdb/top.h
gdb/tracepoint.c
gdb/typeprint.c
gdb/umax-xdep.c
gdb/utils.c
gdb/v850-tdep.c
gdb/valops.c
gdb/valprint.c
gdb/value.h
gdb/values.c
gdb/win32-nat.c
readline/ChangeLog
sim/ChangeLog
sim/arm/ChangeLog
sim/arm/Makefile.in
sim/arm/armemu.c
sim/arm/thumbemu.c
sim/arm/wrapper.c
sim/common/ChangeLog
sim/common/cgen-ops.h
sim/common/cgen-run.c
sim/common/cgen-trace.c
sim/common/cgen-types.h
sim/common/cgen-utils.c
sim/common/nrun.c
sim/common/run.c
sim/common/sim-core.c
sim/common/sim-core.h
sim/common/sim-events.c
sim/common/sim-io.c
sim/common/sim-memopt.c
sim/common/sim-model.h
sim/common/sim-n-core.h
sim/configure
sim/configure.in
sim/d10v/ChangeLog
sim/d10v/Makefile.in
sim/d10v/interp.c
sim/d10v/simops.c
sim/d30v/ChangeLog
sim/d30v/cpu.h
sim/d30v/d30v-insns
sim/d30v/engine.c
sim/d30v/tconfig.in
sim/erc32/ChangeLog
sim/erc32/configure
sim/erc32/configure.in
sim/fr30/ChangeLog
sim/fr30/arch.c
sim/fr30/arch.h
sim/fr30/configure
sim/fr30/configure.in
sim/fr30/cpu.c
sim/fr30/cpu.h
sim/fr30/decode.c
sim/fr30/devices.c
sim/fr30/fr30-sim.h
sim/fr30/fr30.c
sim/fr30/model.c
sim/fr30/sem-switch.c
sim/fr30/sem.c
sim/fr30/sim-if.c
sim/fr30/traps.c
sim/h8300/ChangeLog
sim/h8300/compile.c
sim/i960/ChangeLog
sim/i960/README
sim/i960/TODO
sim/i960/arch.c
sim/i960/arch.h
sim/i960/cpu.c
sim/i960/cpu.h
sim/i960/decode.c
sim/i960/decode.h
sim/i960/devices.c
sim/i960/i960-desc.c
sim/i960/i960-desc.h
sim/i960/i960-opc.h
sim/i960/i960-sim.h
sim/i960/i960.c
sim/i960/model.c
sim/i960/sem-switch.c
sim/i960/sem.c
sim/i960/sim-if.c
sim/m32r/ChangeLog
sim/m32r/arch.c
sim/m32r/arch.h
sim/m32r/cpu.c
sim/m32r/cpu.h
sim/m32r/decode.c
sim/m32r/devices.c
sim/m32r/m32r-sim.h
sim/m32r/m32r.c
sim/m32r/model.c
sim/m32r/sem-switch.c
sim/m32r/sem.c
sim/m32r/sim-if.c
sim/m32r/traps.c
sim/mips/ChangeLog
sim/mips/configure
sim/mips/configure.in
sim/mips/interp.c
sim/mips/mips.igen
sim/mn10200/ChangeLog
sim/mn10200/Makefile.in
sim/mn10200/interp.c
sim/mn10300/ChangeLog
sim/mn10300/Makefile.in
sim/mn10300/dv-mn103int.c
sim/mn10300/dv-mn103tim.c
sim/mn10300/interp.c
sim/mn10300/mn10300.igen
sim/ppc/ChangeLog
sim/ppc/dc-complex
sim/ppc/igen.c
sim/ppc/interrupts.c
sim/ppc/interrupts.h
sim/ppc/ppc-instructions
sim/ppc/psim.c
sim/ppc/sim_calls.c
sim/sh/ChangeLog
sim/sh/gencode.c
sim/sh/interp.c
sim/testsuite/ChangeLog
sim/testsuite/d30v-elf/ChangeLog
sim/testsuite/d30v-elf/do-flags.S
sim/testsuite/sim/fr30/and.cgs
sim/testsuite/sim/fr30/ldub.cgs
sim/testsuite/sim/fr30/stb.cgs
sim/testsuite/sim/fr30/sth.cgs
sim/testsuite/sim/m32r/nop.cgs

index 0ae5117e62421445955fcd36d6409b4e775f3136..500a28aed19942623202bab7abd8e8b0d0147fef 100644 (file)
-1999-04-07  Jim Blandy  <jimb@zwingli.cygnus.com>
+1999-04-22  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+        * README: Note that readline is not installed as a part of
+        make install.
+
+Thu Apr 22 21:02:28 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * value.h (get_saved_register): Cleanup prototype.
+       * findvar.c (default_get_saved_register): Rename function
+       get_saved_register.
+       (GET_SAVED_REGISTER): Define as default_get_saved_register when
+       undefined.
+       (get_saved_register): Always declare. Call GET_SAVED_REGISTER.
+
+       * sparc-tdep.c (sparc_get_saved_register): Rename function
+       get_saved_register.
+       * config/sparc/tm-sparc.h (GET_SAVED_REGISTER): Update.
+       * a29k-tdep.c (a29k_get_saved_register): Rename function
+       get_saved_register.
+       * config/a29k/tm-a29k.h (GET_SAVED_REGISTER): Update.
+
+       * config/d10v/tm-d10v.h, config/powerpc/tm-ppc-eabi.h,
+       config/h8300/tm-h8300.h, config/m32r/tm-m32r.h,
+       config/mn10200/tm-mn10200.h, config/mn10300/tm-mn10300.h,
+       config/sh/tm-sh.h, config/tic80/tm-tic80.h, config/v850/tm-v850.h:
+       Update macro GET_SAVED_REGISTER so that it calls
+       generic_get_saved_register.
+       * v850-tdep.c, tic80-tdep.c, sh-tdep.c, mn10300-tdep.c,
+       mn10200-tdep.c, m32r-tdep.c, h8300-tdep.c, rs6000-tdep.c: Delete
+       function get_saved_register.
+
+Thu Apr 22 11:07:21 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * config/v850/tm-v850.h, config/tic80/tm-tic80.h,
+       config/sh/tm-sh.h, config/powerpc/tm-ppc-eabi.h,
+       config/mn10300/tm-mn10300.h, config/mn10200/tm-mn10200.h,
+       config/m32r/tm-m32r.h, config/h8300/tm-h8300.h,
+       config/fr30/tm-fr30.h, config/d10v/tm-d10v.h: Give the
+       USE_GENERIC_DUMMY_FRAMES macro the value one.
+       * inferior.h (USE_GENERIC_DUMMY_FRAMES): Default to a value of
+       zero.
+
+       * blockframe.c (generic_find_dummy_frame,
+       generic_pc_in_call_dummy, generic_read_register_dummy,
+       generic_push_dummy_frame, generic_pop_current_frame,
+       generic_pop_dummy_frame, generic_frame_chain_valid,
+       generic_get_saved_register): Always define.
+
+       * breakpoint.c (frame_in_dummy): Convert #ifdef
+       USE_GENERIC_DUMMY_FRAMES to runtime test.
+
+       * rs6000-tdep.c (pop_frame, push_arguments, push_arguments,
+       push_arguments, frame_saved_pc, rs6000_frame_chain,
+       rs6000_frame_chain): Convert #ifdef USE_GENERIC_DUMMY_FRAMES to
+       runtime test.
+       (get_saved_register): Always define.
+
+Wed Apr 21 14:45:44 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * gdbarch.c (enum set_arch): Declare.
+       (set_arch): Add type parameter.  Only disable
+       ``target_architecture_auto'' when set_arch_manual.
+       (set_architecture, set_architecture_from_arch_mach,
+       set_architecture_from_file): Update.
+
+Wed Apr 21 10:48:53 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * frame.h (generic_pc_in_call_dummy):  Make signature consistent
+       with other pc_in_call_dummy functions by adding SP parameter.
+       * blockframe.c (generic_pc_in_call_dummy): Update.  Pass SP and
+       not FP to generic_find_dummy_frame().
+       * breakpoint.c (frame_in_dummy): Update.
+       * config/v850/tm-v850.h, config/tic80/tm-tic80.h,
+       config/sh/tm-sh.h, config/mn10300/tm-mn10300.h,
+       config/mn10200/tm-mn10200.h, config/m32r/tm-m32r.h,
+       config/h8300/tm-h8300.h, config/fr30/tm-fr30.h,
+       config/d10v/tm-d10v.h: Update PC_IN_CALL_DUMMY definition.
+
+Tue Apr 20 12:15:45 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * config/d10v/tm-d10v.h (GDB_TARGET_IS_D10V): Move from here.
+       * gdbarch.h (GDB_TARGET_IS_D10V): To here.  Implement using
+       TARGET_ARCHITECTURE.
+       (D10V_MAKE_DADDR, D10V_MAKE_IADDR): Provide fatal default
+       definitions.
+
+       * valops.c (value_at): Replace #ifdef GDB_TARGET_IS_D10V code with
+       runtime test.
+       (value_fetch_lazy): Ditto.
+       * values.c (unpack_long): Ditto.
+       * printcmd.c (print_frame_args): Ditto.
+
+1999-04-15  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * infrun.c (wait_for_inferior) [HAVE_STEPPABLE_WATCHPOINT,
+       HAVE_NONSTEPPABLE_WATCHPOINT, HAVE_CONTINUABLE_WATCHPOINT]: Test
+       at runtime instead of compile time.
+
+1999-04-14  Philippe De Muyter  <phdm@macqel.be>
+
+       * breakpoint.c (maintenance_info_breakpoints): Function made
+       static to match previous prototype.
+
+       * coffread.c (coff_record_line): Static function removed.
+       (enter_linenos): Call `record_line' instead of `coff_record_line'.
+       (FILE-LEVEL, coff_start_symtab, coff_end_symtab): `coff_record_line'
+       -related stuff removed.
+       (coff_symfile_read): Redundant statement removed.
+       (coff_symtab_read): `record_line' is now called with the first line
+       number of each function, given by the ".bf" symbol.  This solves
+       the line-number bug for one-line functions.
+
+Wed Apr 14 11:09:45 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * stabsread.c (BELIEVE_PCC_PROMOTION_TYPE): Provide default.
+       (define_symbol): Change #if BELIEVE_PCC_PROMOTION_TYPE and #if
+       BELIEVE_PCC_PROMOTION to if().
+
+1999-04-13  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * configure.in (HAVE_MULTIPLE_PROC_FDS): Don't define if we're
+       on a Solaris host (of any architecture).
+       * configure: Regenerated.
+
+1999-04-13  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * rom68k-rom.c (init_rom68k_cmds): Fix an accidental substitution
+       in monitor command strings, fix some formatting mistakes.
+
+1999-04-13  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * configure.tgt (arm-*-*): Whack another vestige of wingdb.
+
+1999-04-12  James Ingham  <jingham@cygnus.com>
+
+       * arm-tdep.c (arm_pop_frame): don't clobber the previous frame's
+       stack pointer (stored in frame->framereg's register) BEFORE
+       reading it.  This was causing "return" to behave very oddly.
+
+1999-04-12  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * NEWS: Mention tic80.
+
+1999-04-12  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+       * a68v-nat.c: Remove reference to 'extern char registers[]' throughout.
+       * altos-xdep.c: Ditto.
+       * arm-xdep.c: Ditto.
+       * convex-xdep.c:  Ditto.
+       * cxux-nat.c: Ditto.
+       * hp300ux-nat.c: Ditto.
+       * hppab-nat.c: Ditto.
+       * i386aix-nat.c: Ditto.
+       * i386mach-nat.c: Ditto.
+       * m88k-nat.c: Ditto.
+       * ptx4-nat.c: Ditto.
+       * pyr-xdep.c: Ditto.
+       * rs6000-nat.c: Ditto.
+       * sun3-nat.c: Ditto.
+       * sun386-nat.c: Ditto.
+       * symm-nat.c: Ditto.
+       * umax-xdep.c: Ditto.
+       * i386v4-nat.c: Ditto. Also include inferior.h.
+       * m68k-tdep.c: Ditto. Also include inferior.h.
+
+Mon Apr 12 15:57:16 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * inferior.h (CALL_DUMMY_STACK_ADJUST, CALL_DUMMY_STACK_ADJUST_P):
+       Provide default definitions.
+       * valops.c (hand_function_call): Replace #ifdef
+       CALL_DUMMY_STACK_ADJUST with if (CALL_DUMMY_STACK_ADJUST_P).
+
+1999-04-09  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * ax-gdb.c, ax-gdb.h, ax-general.c, ax.h: Remove RCS Id strings.
+       They're a pain.
 
        * GDB 4.18 released.
+       * Makefile.in (VERSION): Bump to 4.18.1.
 
-1999-04-06  Jim Blandy  <jimb@zwingli.cygnus.com>
+Thu Apr  8 16:04:34 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * inferior.h (CALL_DUMMY_P, CALL_DUMMY_WORDS,
+       SIZEOF_CALL_DUMMY_WORDS): Define macros.
+       (PUSH_DUMMY_FRAME, FIX_CALL_DUMMY, STORE_STRUCT_RETURN): Provide
+       fatal default.
+
+       * inferior.h, gdbarch.c (call_dummy_words,
+       sizeof_call_dummy_words): Declare/Define variables.
+       * valops.c (value_arg_coerce, find_function_addr,
+       call_function_by_hand): Always define.
+       (hand_function_call): Rename CALL_DUMMY version of
+       call_function_by_hand.  Make static.  Add prototype.
+       (hand_function_call): Update.  Allocate space for *dummy and
+       *dummy1 using alloca.
+       * breakpoint.c (frame_in_dummy): Update.
 
-       * README: Change revision numbers in text to "4.18".
-       * Makefile.in (VERSION): Set to 4.18.
+1999-04-08  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * monitor.c (monitor_read_memory): If a MO_GETMEM_NEEDS_RANGE 
+       monitor, increase the end address by one byte.
+
+1999-04-08  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * dbug-rom.c (init_dbug_cmds): Fix strings in 
+        dbug_cmds.{step,clr_break,clr_all_break,fill} to send correct
+       commands to the monitor.
+
+1999-04-08  Keith Seitz  <keiths@cygnus.com>
+
+       * m32r-stub.c (branchDestination): Undo overly ambitious
+       sed script's conversion of cast from "char" to "unsigned char".
+       Return offset should now be properly computed.
+
+Thu Apr  8 14:13:19 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * inferior.h (CALL_DUMMY_BREAKPOINT_OFFSET_P): New macro.
+       Non-zero when CALL_DUMMY_BREAKPOINT_OFFSET is valid.
+
+       * infcmd.c (breakpoint_auto_delete_contents): Always define.
+       (run_stack_dummy): Update.
+       * infrun.c (wait_for_inferior): Update
+
+1999-04-07  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * MAINTAINERS: Mark Alexander can no longer maintain
+       h8300 and other embedded targets, sniff.
 
 1999-04-06  Stan Shebs  <shebs@andros.cygnus.com>
 
+       * inftarg.c (child_wait): Initialize execd_pathname.
+       * target.c (debug_to_has_execd): Handle NULL execd_pathname.
+
        * solib.c (clear_solib): Don't call disable_breakpoints_in_shlibs,
        this breaks rerunning on sun4 native.
 
-1999-04-05  Stan Shebs  <shebs@andros.cygnus.com>
+1999-04-06  Jim Blandy  <jimb@zwingli.cygnus.com>
 
-       * NEWS: Incorporate suggestions from David Taylor and Jason Molenda.
-       
-1999-04-02  Jim Blandy  <jimb@zwingli.cygnus.com>
+       * config/sparc/nm-linux.h: Don't redefine PT_ATTACH to use the
+       deprecated PTRACE_SUNATTACH compatibility commands.  The
+       definitions from <sys/ptrace.h> are fine.
+
+1999-04-06  Martin Hunt  <hunt@cygnus.com>
+
+       * annotate.h: Declare annotate_signal_hook.
+
+       * annotate.c (annotate_signal): Add a call to 
+       annotate_signal_hook().
+
+1999-04-06  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * dwarf2read.c (dwarf_decode_lines): Don't call record_line when
+       we hit a DW_LNE_end_sequence instruction.
 
        * README: Note that GDB requires an ANSI C compiler, and explain
        how to get GCC.
 
        * README: Update.
-       It says we provide HTML documentation, but we don't.
-       The instructions for building the .info files were wrong.
-       It didn't mention that texinfo.tex was provided with GDB.
-       It didn't mention the intl, texinfo, etc, or util directories.
-       (Perhaps util would be best left unmentioned.)
-       It didn't mention the --enable-build-warnings flag, or the --host
-           flag.
-       It didn't mention remote-array.c or remote-d10v.c.
-       It had an old address for reporting bugs.  It's now gdb@gnu.org.
-       It mentioned xxgdb, which is obsolete, but didn't mention DDD.  
 
-       * config/sparc/nm-linux.h: Don't redefine PT_ATTACH to use the
-       deprecated PTRACE_SUNATTACH compatibility commands.  The
-       definitions from <sys/ptrace.h> are fine.
-
-1999-04-01  Stan Shebs  <shebs@andros.cygnus.com>
+1999-04-05  Stan Shebs  <shebs@andros.cygnus.com>
 
        * NEWS: Add more notes about user-visible changes.
 
+Mon Apr  5 14:56:59 1999  Michael Snyder  <msnyder@cleaver.cygnus.com>
+
+       * target.c (target_signal_to_string): check for signal
+       number in range; otherwise if the target board returns
+       a bogus signal number we might core dump (per David Taylor).
+
+1999-04-05  David Taylor  <taylor@ryobi.cygnus.com>
+
+       * utils.c (fputs_maybe_filtered): test value of
+       pagination_enabled before paginating.
+
+1999-04-02  James Ingham  <jingham@cygnus.com>
+
+       * blockframe.c (get_prev_frame): Remove the redundant
+       get_prev_frame_info.  It is now exactly the same as
+       get_prev_frame, so there is no reason to have both functions.
+       
+       * rs6000-tdep.c (rs6000_init_extra_frame_info): 
+         frame.h: 
+         a29k-tdep.c (init_extra_frame_info): 
+         config/a29k/tm-a29k.h: 
+         i386-tdep.c:
+        Change all references to get_prev_frame_info to get_prev_frame.
+       
+1999-04-02  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * bcache.c, bcache.h, breakpoint.c, defs.h, expprint.c,
+       expression.h, gdbarch.c, gdbtypes.c, gdbtypes.h, gnu-nat.c,
+       gnu-nat.h, hppa-tdep.c, maint.c, monitor.c, objfiles.h, parse.c,
+       remote-mips.c, remote-sds.c, remote.c, sol-thread.c, symmisc.c,
+       symtab.h, target.c, top.c, typeprint.c, config/nm-gnu.h: Evaporate
+       the unused MAINTENANCE_CMDS conditional.
+
+1999-04-02  James Ingham  <jingham@cygnus.com>
+
+       * config/arm/tm-arm.h: (EXTRACT_STRUCT_VALUE_ADDRESS): This needs
+       to call extract_address, not just cast the first 4 bytes, since
+       the result will be passed to value_at which expects host-byte
+       order. 
+
+       * arm-tdep.c (arm_scan_prologue): The prologue_start address was
+       directly &'ed with 0x03fffffc, rather than using
+       ADDR_BITS_REMOVE.  This would cause inferior function calls to
+       report the stack incorrectly on return.
+
+
+1999-04-02  Keith Seitz  <keiths@cygnus.com>
+
+       * top.c (ui_loop_hook): Change declaration. Now returns an int.
+       * win32-nat.c (child_wait): Timeout WaitForDebugEvent and call
+       the ui_loop_hook if there was no debug event.
+       * top.c (ui_loop_hook): Change to return an int and include
+       on all non-Cygwin builds.
+       * v850ice.c: Change prototype of ui_loop_hook.
+       (v850ice_wait): Update call to ui_loop_hook.
+       * ser-unix.c (hardwire_readchar): Enable ui_loop_hook callbacks
+       for non-Cygwin builds. Check return status of ui_loop_hook and
+       return a timeout if told to detach. Add more documentation.
+       * ser-tcp.c (tcp_readchar): Break up timeouts into one second
+       intervals and call ui_loop_hook so that other UIs can
+       keep up to date. If ui_loop_hook returns non-zero, then
+       return SERIAL_TIMEOUT to facilitate detaching from the
+       target.
+       * remote.c (remote_interrupted_already): Remove.
+       (remote_interrupt_twice): Revive.
+       (remote_interrupt): Call remote_stop to interrupt the target
+       and install remote_interrupt_twice to take more severe
+       actions if this fails.
+       (remote_stop): Only attempt to stop the target. This separates
+       the command line from other UIs.
+       * remote-sim.c (gdb_os_poll_quit): Add a call to ui_loop_hook,
+       if it is defined.
+
 1999-04-01  Jim Blandy  <jimb@zwingli.cygnus.com>
 
        Fix for cross-debugging on an AIX host from Johanna Svenningsson:
        * ax-gdb.h (enum axs_lvalue_kind): Remove trailing comma from enum.
-       * ax.h (enum agent_op, enum agent_flaws): Same.
+       * ax.h (enum agent_op): Same.
        * tracepoint.h (enum actionline_type): Same.
        * config/xm-aix4.h: Add declaration for termdef.
 
        * jv-lang.h (dynamics_objfile): Remove decl, conflicts with static
        decl in jv-lang.c.
 
-1999-03-31  Jim Blandy  <jimb@zwingli.cygnus.com>
+       * infrun.c (follow_inferior_fork): Add ifdefs around
+       SOLIB_REMOVE_INFERIOR_HOOK.
 
-       Mon Mar 29 14:40:44 1999  David Taylor  <taylor@ryobi.cygnus.com>
+Wed Mar 31 11:39:49 1999  David Taylor  <taylor@ryobi.cygnus.com>
 
        * valops.c (search_struct_field): revert HP merge change
        to this function -- it causes messages to be printed about
        (search_struct_field_aux): delete -- added as part of HP merge
        change; with aforementioned change it is no longer called.
 
-1999-03-26  Jim Blandy  <jimb@zwingli.cygnus.com>
+1999-03-30  Stan Shebs  <shebs@andros.cygnus.com>
 
-       Merged change from Keith Seitz:
-       
-       1999-03-16  Keith Seitz  <keiths@cygnus.com>
+       Make more HPUX-specific code generic.
+       * infrun.c: Include top.h.
+       (MAY_SWITCH_FROM_INFERIOR_PID, MAY_FOLLOW_EXEC,
+       USE_THREAD_STEP_NEEDED): New native macros.
+       (may_switch_from_inferior_pid, may_follow_exec,
+       use_thread_step_needed): New globals.
+       (follow_inferior_fork): Remove HPUXHPPA ifdef.
+       (follow_exec): Ditto, also save run target and re-push instead of
+       always pushing child_ops, add ifdefs around SOLIB_RESTART and
+       SOLIB_CREATE_INFERIOR_HOOK.
+       (wait_for_inferior): Use new globals instead of ifdefing HPUXHPPA,
+       always use printf_filtered to report new threads.
+       (normal_stop): Ditto.
+       * target.h, target.c (find_run_target): New function.
+       * config/pa/nm-hppah.h: Define new macros.
 
-        * remote.c (reomte_binary_checked): New file global.
-        (check_binary_download): New function to check if
-        stub supports binary downloading that works with
-        stubs that are not eight bit clean.
-        (remote_write_bytes): Check for binary download capability
-        and use it if available.
-        Remove references to global remote_binary_length. What a hack.
-        (putpkt_binary): New function.
-       (putpkt): Call putpkt_binary.
-       Use xor to escape trouble characters.
-       * m32r-stub.c (bin2mem): Follow escape char convention change.
+1999-03-29  Stan Shebs  <shebs@andros.cygnus.com>
 
-       Applied patch from Stu Grossman:
+       * top.h: Include setjmp.h here.
+       * main.c, top.c: Don't include it here.
 
-       Mon Feb 22 12:32:19 1999  Per Bothner  <bothner@cygnus.com>
+1999-03-29  Keith Seitz  <keiths@cygnus.com>
 
-       * jv-valprint.c (java_val_print):  Restore line that somehow got lost.
+       * symtab.c (decode_line_1): Take out change which breaks symbols
+       which include class names and methods, e.g., "Foo::bar".
+
+1999-03-26  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * configure.tgt (i[3456]86-*-sysv4.2MP, i[3456]86-*-sysv4.2uw2*):
+       Recognize both, as i[3456]86-*-sysv4.2*.
+       (i[3456]86-*-sysv5*): Recognize.
+
+       * infrun.c (wait_for_inferior): Remove most #if 0 segments.
+
+Fri Mar 26 17:27:27 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * blockframe.c (pc_in_call_dummy_on_stack): Fix.  Had copied code
+       from at_entry_point.
+
+Thu Mar 25 19:30:02 1999  Andrew Cagney  <cagney@amy.cygnus.com>
+
+       * gdbarch.c: Include all headers.
+
+       * inferior.h, blockframe.c (pc_in_call_dummy_before_text_end,
+       pc_in_call_dummy_after_text_end, pc_in_call_dummy_on_stack,
+       pc_in_call_dummy_at_entry_point): Convert PC_IN_CALL_DUMMY macro's
+       into functions.
+
+Tue Mar 23 17:22:57 1999  Philippe De Muyter  <phdm@macqel.be>
+
+       * remote.c, parse.c: Include ctype.h.
 
 1999-03-24  Stan Shebs  <shebs@andros.cygnus.com>
 
-       * Makefile (VERSION): Bump to 4.17.87.
+       * configure.host (mips-dec-mach3*): Use mipsm3 not mach3.
 
        Attempt to sort out SCO-related configs.
        * configure.host (i[3456]86-*-sysv4.2*): Use instead of
        * configure.tgt (i[3456]86-*-sco3.2v5*, i[3456]86-*-sco3.2v4*):
        Recognize.
 
+Wed Mar 24 16:19:01 1999  Christopher Faylor <cgf@cygnus.com>
+
+       * MAINTAINERS: Add DJ Delorie (dj@cygnus.com) as the djgpp
+       maintainer.
+
+Wed Mar 24 21:19:57 1999  Andrew Cagney  <cagney@amy.cygnus.com>
+
+       * target.h (enum target_signal): Do not hardwire values of MACH
+       signals.
+
+1999-03-14  Ken Raeburn  <raeburn@raeburn.org>
+
+       * target.h (enum target_signal): Add TARGET_SIGNAL_INFO.
+       * target.c (signals): Add SIGINFO description.
+       (target_signal_from_host, target_signal_to_host): Translate
+       SIGINFO to/from TARGET_SIGNAL_INFO.
+
 Wed Mar 24 01:01:27 1999  Andrew Cagney  <cagney@sludge.cygnus.com>
 
        * rs6000-tdep.c (rs6000_software_single_step): Change SIGNAL to
        unsigned int.
 
-       From Rodney Brown <rodneybrown@pmsc.com>:
+       From Rodney Brown <rodneybrown@pmsc.com>
        * target.h (enum thread_control_capabilities), breakpoint.h (enum
        bptype), breakpoint.c (enum insertion_state_t): Strict ISO-C
        doesn't allow trailing comma in enum definition.
        
-1999-03-23  Jason Molenda  (jsm@bugshack.cygnus.com)
+Mon Mar 22 15:56:04 1999  Andrew Cagney  <cagney@b1.cygnus.com>
 
-        * hppa-tdep.c (pa_register_look_aside): Remove CPU_HPPA_RISC_20
-        check, test for presence of struct save_state_t and the ss_wide 
-        member directly.
-        * configure.in:  Remove CPU_HPPA_RISC_20 test.  Add tests for
-        HAVE_STRUCT_SAVE_STATE_T and HAVE_STRUCT_MEMBER_SS_WIDE.
-        * acconfig.h: Add HAVE_STRUCT_SAVE_STATE_T HAVE_STRUCT_MEMBER_SS_WIDE.
-        * configure, config.in: Regenerated.
+       * blockframe.c (inside_entry_file, inside_entry_func): Convert #if
+       CALL_DUMMY_LOCATION to if.
+       * valops.c (call_function_by_hand): Ditto.
+       * infcmd.c (run_stack_dummy): Ditto.
+       * inferior.h (CALL_DUMMY_ADDRESS, CALL_DUMMY_START_OFFSET,
+       CALL_DUMMY_BREAKPOINT_OFFSET): Provide default.
 
-Tue Mar 23 17:22:57 1999  Philippe De Muyter  <phdm@macqel.be>
+1999-03-23  Jason Molenda  (jsm@bugshack.cygnus.com)
 
-       * remote.c, parse.c: Include ctype.h.
+       * hppa-tdep.c (pa_register_look_aside): Remove CPU_HPPA_RISC_20
+       check, test for presence of struct save_state_t and the ss_wide 
+       member directly.
+       * configure.in:  Remove CPU_HPPA_RISC_20 test.  Add tests for
+       HAVE_STRUCT_SAVE_STATE_T and HAVE_STRUCT_MEMBER_SS_WIDE.
+       * acconfig.h: Add HAVE_STRUCT_SAVE_STATE_T HAVE_STRUCT_MEMBER_SS_WIDE.
+       * configure, config.in: Regenerated.
 
 Mon Mar 22 13:25:13 1999  Michael Snyder  <msnyder@cleaver.cygnus.com>
 
        * infttrace.c (proc_wait): rename to ptrace_wait.
 
+1999-03-18  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * dwarf2read.c: Correctly recognize location expressions that
+       designate LOC_REF_ARG arguments.  Doc fixes.
+       (isderef): New global.  (Yuck.)
+       (dwarf2_complex_location_expr): New complaint.
+       (read_func_scope): Reject frame_base attributes that use the
+       `deref' opcode as too complex.
+       (new_symbol): If both regoff and isderef are set, and the base
+       register is the frame pointer, then it's a LOC_REF_ARG argument.
+       (decode_locdesc): Recognize the `deref' opcode in location
+       expressions.  Complain if it's not the last op in the expression.
+
+       * config/fr30/tm-fr30.h (COERCE_FLOAT_TO_DOUBLE): #define this to
+       be true, or else value_arg_coere won't respect the (accurate)
+       information we have about whether a function is prototyped.
+
+1999-03-17  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * config/fr30/tm-fr30.h (STACK_ALIGN): Define this here, so
+       calling functions by hand with odd-sized arguments doesn't munge
+       the stack.
+
 1999-03-17  Jason Molenda  (jsm@bugshack.cygnus.com)
 
        * configure.in (HAVE_MULTIPLE_PROC_FDS): Don't define for Solaris
        hosts--gdb doesn't support this yet.
        * configure: Regenerated.
 
+1999-03-16  Keith Seitz  <keiths@cygnus.com>
+
+        * remote.c (remote_binary_checked): New file global.
+        (check_binary_download): New function to check if
+        stub supports binary downloading that works with
+        stubs that are not eight bit clean.
+        (remote_write_bytes): Check for binary download capability
+        and use it if available.
+        Remove references to global remote_binary_length. What a hack.
+        (putpkt_binary): New function.
+       (putpkt): Call putpkt_binary.
+       Use xor to escape trouble characters.
+       * m32r-stub.c (bin2mem): Follow escape char convention change.
+
 Tue Mar 16 01:11:33 1999  Andrew Cagney  <cagney@rhino.cygnus.com>
 
        * target.h (struct target_ops), target.c (debug_to_query),
        remote.c (pack_hex_byte, remote_query): Promote char parameters to
        int.  Stops compile problems with pedantic ISO-C compilers.
-
+       
 Tue Mar 16 15:29:04 1999  Stan Shebs  <shebs@andros.cygnus.com>
 
+       * go32-xdep.c: Remove, no longer used by anything.
+       * Makefile.in: Remove references.
+
        * jv-lang.c, jv-lang.h (java_primitive_type): Declare argument
        as int instead of char.
 
-1999-03-15  Jim Blandy  <jimb@zwingli.cygnus.com>
+Mon Mar 15 11:42:43 1999  Andrew Cagney  <cagney@b1.cygnus.com>
 
-       Merged changes for binary downloads from Michael Snyder:
+       * d10v-tdep.c (push_stack_item, pop_stack_item): New function.
+       (d10v_push_arguments): Use.
        
-       Fri Mar 12 13:11:48 1999  Michael Snyder  <msnyder@cleaver.cygnus.com>
+       From Martin M. Hunt  <hunt@cygnus.com>:
+       * d10v-tdep.c (d10v_push_arguments): When arguments
+       must be pushed onto the stack, they go on in
+       reverse order.
+
+1999-03-16  Jim Blandy  <jimb@zwingli.cygnus.com>
 
-        * remote.c (remote_write_bytes): fix 'X' packet protocol so that it
-        can't overwrite the end of its buffer with escaped characters.
+       * symtab.c (make_symbol_overload_list): Don't try to stuff minimal
+       or partial symbols into the overload list; we don't know their
+       types.  (Thanks to Rajiv Mirani.)
+
+1999-03-15  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * acinclude.m4 (--with-itclconfig, --with-itkconfig, --with-tixconfig):
+       Fix whitespace so --help messages line up.
+       * configure.in (--with-cpu): Fix capitalization for --help messages.
+       * configure, aclocal.m4: Regenerated.
+
+Mon Mar 15 11:39:03 1999  Ian Carmichael  <iancarm@cygnus.com>
+
+        Support building gdb w/o simulator:
+        * configure.in: Support --disable-sim. Check for sim directory.
+        * Makefile.in (IGNORE_SIM, IGNORE_SIM_OBS): New.
+        * acconfig.h (WITH_SIM): Define.
+        * configure, config.in: Regenerate.
+
+Mon Mar 15 08:01:33 1999  Elena Zannoni  <ezannoni@cygnus.com>
+
+        Patch from Andreas Schwab  <schwab@issan.cs.uni-dortmund.de>
+
+       * top.c (read_command_lines): Reset control_level to 0.
+       (define_command): Don't do it here.
+
+Sun Mar 14 16:12:15 1999  Andrew Cagney  <cagney@rhino.cygnus.com>
+
+       * hppah-nat.c (store_inferior_registers): Delete extern
+       registers[] declaration.
+
+Sun Mar 14 19:17:30 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * infrun.c (write_inferior_status_register): New function. Provide
+       update access to an inf_status register buffer.  Only used by HP.
+       * inferior.h (write_inferior_status_register): Add prototype.
+
+       * hppa-tdep.c (push_dummy_frame): Use
+       write_inferior_status_register when hacking around a sleeping
+       inferior.  Accidently fix byte-order problem.
+
+Sun Mar 14 16:40:10 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * config/pa/tm-hppa.h (PUSH_DUMMY_FRAME): Fix parameter. Address
+       not needed.
+
+Fri Mar 12 13:11:48 1999  Michael Snyder  <msnyder@cleaver.cygnus.com>
+
+       * remote.c (remote_write_bytes): fix 'X' packet protocol so that it
+       can't overwrite the end of its buffer with escaped characters.
 
 1999-03-12  Jim Blandy  <jimb@zwingli.cygnus.com>
 
-       Merged changes for HP/UX 9 from Jason Molenda:
+        Alpha patches from Richard Henderson:
 
-       1999-03-08  Jason Molenda  (jsm@bugshack.cygnus.com)
+       * alpha-tdep.c (alpha_skip_prologue): Recognize subq.
 
-       * infttrace.c (hppa_get_process_events): Removed. Function only 
-       usable on HPUX 10 and above.  It is not called by any other part
-       of GDB.
-       * hppah-nat.c (hppa_get_process_events): Ditto.
-       (child_pid_to_exec_file): Only call ptrace with PT_GET_PROCESS_PATHNAME
-       if that symbol has been defined.
-       * config/pa/nm-hppah.h: Don't set up prototypes et al for 
-       hppa_get_process_events.
+       * config/alpha/tm-alpha.h (REGISTER_NAMES): No f31, but fpcr.
+       (FPCR_REGNUM): New.
+       (REGISTER_CONVERTIBLE): Don't convert fpcr.
+       (REGISTER_VIRTUAL_TYPE): Don't make fpcr a double.
 
-       * config/pa/hppahpux.mh (TERM_LIB): Do not initialize, let autoconf
-       determine best library automatically.
-       * config/pa/hpux1020.mh: Ditto.
-       * config/pa/hpux1100.mh: Ditto.
-       * configure.in (TERM_LIB): Also check for libHcurses.
-       * configure: Regenerated.
+       * stabsread.c (define_symbol): Only consider live range extension
+       if we have an open parenthesis.
 
-       Merged changes to accomodate the Hurd:
-       
-        Thu Mar 11 18:05:11 1999  Michael Snyder  <msnyder@cleaver.cygnus.com>
+1999-03-11  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * monitor.c (monitor_fetch_register): Print RDEBUG info correctly
+       when the register name is null.
+
+Thu Mar 11 19:33:07 1999  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * infrun.c (wait_for_inferior): Change #if DECR_PC_AFTER_BREAK
+       uses to expressions, remove redundant extern decls.
+
+Thu Mar 11 18:05:11 1999  Michael Snyder  <msnyder@cleaver.cygnus.com>
 
        * infptrace.c (proc_wait): Rename to ptrace_wait.
        * inftarg.c (child_wait): call ptrace_wait instead of proc_wait.
        * inferior.h: Declare ptrace_wait instead of proc_wait.
 
-1999-03-11  Jim Blandy  <jimb@zwingli.cygnus.com>
-
-       * Makefile.in (VERSION): click to 4.17.86, for next snapshot.
+Thu Mar 11 11:46:25 1999  Andrew Cagney  <cagney@amy.cygnus.com>
+
+       * breakpoint.c (create_solib_load_unload_event_breakpoint,
+       create_fork_vfork_event_catchpoint, tcatch_command,
+       create_exception_catchpoint, break_at_finish_at_depth_command_1,
+       catch_fork_command_1, ep_skip_leading_whitespace,
+       break_at_finish_command_1, catch_exec_command_1,
+       catch_exception_command_1, stop_command, stopin_command,
+       stopat_command, ep_parse_optional_filename,
+       ep_find_event_name_end, ep_parse_optional_if_clause,
+       catch_fork_command_1), stack.c (show_and_print_stack_frame_stub,
+       print_stack_frame_stub, print_only_stack_frame_stub,
+       backtrace_command_1, backtrace_full_command, func_command),
+       valprint.c (print_decimal), source.c (print_source_lines_base):
+       Add prototype.
+
+       * stack.c (print_stack_frame_stub, show_and_print_stack_frame_stub,
+       print_only_stack_frame_stub): Make param void*.
+
+Wed Mar 10 19:33:28 1999  Geoffrey Noer  <noer@cygnus.com>
+
+       * win32-nat.c: If old Cygwin Win32 API headers aren't being used,
+        define some gdb-specific defines that shouldn't have been in the
+        global headers.
+
+Wed Mar 10 21:20:25 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * findvar.c (registers, register_valid): Replace array with pointer.
+       (build_findvar): New function.  Allocate space for REGISTERS and
+       REGISTER_VALID.
+       (_initialize_findvar): Call build_findvar.
+       
+       * inferior.h (registers, register_valid): Replace array with
+       pointer.
+
+       * inferior.h (struct inferior_status): Move definition from here.
+
+       * infrun.c (struct inferior_status): To here.
+       (struct inferior_status): Change ``stop_registers'' and
+       ``registers'' to pointers.
+       (xmalloc_inferior_status, free_inferior_status): New functions.
+       (restore_inferior_status): Call free_inferior_status.
+       (save_inferior_status): Call xmalloc_inferior_status.
+       (discard_inferior_status): New function, discard inf_status
+       buffer.  Call free_inferior_status.
+       
+       * inferior.h (stop_registers): Replace array with pointer.
+       * infrun.c (stop_registers): Update.
+       (build_infrun): Initialize stop_registers.
+       (_initialize_infrun): Call build_infrun.
+
+Wed Mar 10 14:50:42 1999  Andrew Cagney  <cagney@amy.cygnus.com>
+
+       * alpha-tdep.c (alpha_linux_sigtramp_offset): Only compile when
+       LINUXALPHA target. Hack.
+
+       * infrun.c (set_follow_fork_mode_command): Make static.  Add
+       prototype.
+       * tracepoint.c (add_register): Ditto.
+       * valprint.c (strcat_longest): Comment out.  Does not appear to be
+       used.
+       * valops.c (find_method_list): Make static.  Add prototype.
+       * thread.c (target_find_new_threads): Make static.  Add prototype.
+       * stack.c (stack_publish_stopped_with_no_frame,
+       select_and_maybe_print_frame): Comment out.  Does not appear to be
+       used.
+       (current_frame_command): Add prototype.
+       * breakpoint.c (break_at_finish_command,
+       break_at_finish_at_depth_command, tbreak_at_finish_command): Make
+       static.  Add prototype.
+       * findvar.c (read_relative_register_raw_bytes_for_frame): Ditto.
+
+Wed Mar 10 23:38:54 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * corefile.c (registers): Delete redundant variable declaration.
+       * inferior.h (run_stack_dummy): Change array argument to pointer.
+       * infcmd.c (run_stack_dummy): Update.
+       * value.h (value_being_returned): Change RETBUF to a pointer.
+       * values.c (value_being_returned): Update.
+
+Wed Mar 10 11:08:16 1999  Andrew Cagney  <cagney@amy.cygnus.com>
+
+       * source.c (list_command): GCC suggested explicit braces to avoid
+       ambiguous `else'.
+
+       * jv-typeprint.c: Include "c-lang.h".
+       * Makefile.in (jv-typeprint.o): Add dependency.
+       * jv-valprint.c: Include "gdbcore.h", "annotate.h".
+       * Makefile.in (jv-valprint.o): Add dependencies.
+       * objfiles.c: Include "breakpoint.h".
+       * Makefile.in (objfiles.o): Add dependency.
+       * main.c: Include <unistd.h>.
+       * parse.c: Include <ctype.h>.
+       * remote.c: Include <ctype.h>.
+       * ser-tcp.c: Include <unistd.h>.
+       * ax-general.c: Include "value.h".
+       * Makefile.in (ax-general.o): Add dependency.
+
+       * alpha-tdep.c (alpha_push_arguments): Make ``i'' an int instead
+       of a register.
+       * frame.h (show_and_print_stack_frame): Add function prototype.
+       * language.h (language_enum): Add function prototype.
+       * value.h (find_overload_match): Add function prototype.
+
+       * defs.h, utils.c (subset_compare): Rename subsetCompare. Add
+       prototype.
+       * stack.c (backtrace_command): Update.
+
+Wed Mar 10 13:58:36 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * configure.in (AC_CHECK_HEADERS): Check for <sys/select.h>
+       * configure, config.in: Re-generate.
+       * inflow.c: Conditionally include <sys/select.h>.
+
+Wed Mar 10 13:44:38 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * frame.h (struct dummy_frame): Move from here.
+       * blockframe.c (struct dummy_frame): To here.
+
+       * blockframe.c (struct dummy_frame): Replace ``regs'' with pointer
+       ``registers''.
+       (generic_pop_dummy_frame): Free it.
+       (generic_push_dummy_frame): Allocate dummy frame register buffer.
+
+Wed Mar 10 11:08:16 1999  Andrew Cagney  <cagney@amy.cygnus.com>
+
+       * thread.c (_initialize_thread): Delete redundant ``extern struct
+       cmd_list_element *cmdlist''.
+       * printcmd.c (print_command_1): Ditto for ``objectprint'';
+
+1999-03-09  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * MAINTAINERS: New file, list of maintainers and areas they
+       maintain.
 
 1999-03-09  Rodney Brown  <RodneyBrown@pmsc.com>
 
@@ -201,11 +772,185 @@ Tue Mar 16 15:29:04 1999  Stan Shebs  <shebs@andros.cygnus.com>
        * config/i386/tm-i386v42mp.h: Remove HAVE_PSTATUS_T,
        HAVE_NO_PRRUN_T; now set by configure.
 
+Tue Mar  9 16:29:24 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * i386-tdep.c (gdb_print_insn_i386): Abort when disassembly_flavor
+       undefined..
+
+       * fr30-tdep.c (_initialize_fr30_tdep): Add prototype.  Fix
+       coding style.
+
+       * target.c (debug_to_enable_exception_callback,
+       debug_to_get_current_exception_event): Return result of call to
+       debug_target().
+
+1999-03-09  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       Another HURD fix from Mark Kettenis:
+       * gnu-nat.c: Include <string.h>.  Remove declaration of strerror.
+       Include <bits/waitflags.h> instead of <waitflags.h> and define
+       _SYS_WAIT_H to prevent the warning that we should not include it.
+       (gnu_create_inferior): Change return type of attach_to_child to
+       void.  Do not return INFERIOR_PID.
+       (gnu_pid_to_exec_file): Change return type to char *.
+       Return NULL.
+
+       Fix for the HURD from Mark Kettenis:
+       * configure.in: Add AC_PROG_AWK.  Needed by the machine-dependent
+       makefile fragments for the Hurd.
+       * Makefile.in (AWK): Add.  Set by configure.
+       * configure: Regenerated.
+
+1999-03-08  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * infttrace.c (hppa_get_process_events): Removed. Function only
+       usable on HPUX 10 and above.  It is not called by any other part
+       of GDB.
+       * hppah-nat.c (hppa_get_process_events): Ditto.
+       (child_pid_to_exec_file): Only call ptrace with
+       PT_GET_PROCESS_PATHNAME if that symbol has been defined.
+       * config/pa/nm-hppah.h: Don't set up prototypes et al for 
+       hppa_get_process_events.
+
+       * config/pa/hppahpux.mh (TERM_LIB): Do not initialize, let autoconf
+       determine best library automatically.
+       * config/pa/hpux1020.mh: Ditto.
+       * config/pa/hpux1100.mh: Ditto.
+       * configure.in (TERM_LIB): Also check for libHcurses.
+       * configure: Regenerated.
+
+Thu Mar  4 17:16:04 1999  Michael Snyder  <msnyder@cleaver.cygnus.com>
+
+       * m32r-stub.c: add support for crc "Compare" command.
+
 1999-03-04  Jim Blandy  <jimb@zwingli.cygnus.com>
 
-       Merged changes from Jason Molenda:
+       * fr30-tdep.c (fr30_store_return_value): Allocate zeroes
+       dynamically, to save BSS space, and to remove assumptions about
+       the size of the largest value we'll return.
+
+       * config/fr30/tm-fr30.h (fr30_store_return_value): Use PARAMS in
+       prototype.
+
+Thu Mar  4 08:37:35 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * sh3-rom.c (sh3_supply_register, sh3_supply_register),
+       mips-tdep.c (mips_push_arguments), m32r-rom.c
+       (m32r_upload_command), m32r-tdep.c (decode_prologue), monitor.c
+       (longlong_hexchars), tracepoint.c (validate_actionline,
+       read_actions), mdebugread.c
+       (parse_symbol), jv-typeprint.c
+       (java_type_print_base, java_type_print_base), mdebugread.c
+       (parse_symbol), top.c (source_command), utils.c
+       (floatformat_to_doublest): GCC suggest explicit braces to avoid
+       ambiguous `else'.
        
-       1999-02-24  Jason Molenda  (jsm@bugshack.cygnus.com)
+       * tracepoint.c (map_args_over_tracepoints, trace_actions_command),
+       m32r-rom.c (m32r_supply_register), win32-nat.c
+       (handle_output_debug_string, child_continue), i960-tdep.c
+       (pop_frame), m32r-rom.c (m32r_upload_command): GCC suggested
+       parentheses around assignment used as truth value.
+
+       * remote-sds.c (sds_wait), monitor.c (monitor_fetch_register),
+       ser-e7kpc.c, (dosasync_write), arc-tdep.c (arc_get_frame_setup):
+       GCC suggested parentheses around operands.
+
+       * c-typeprint.c (c_type_print_base): GCC suggested enclosing
+       "while" expression in paren.
+
+Wed Mar  3 18:14:33 1999  Andrew Cagney  <cagney@chook.cygnus.com>
+
+       * sol-thread.c (save_inferior_pid): Cast the saved pid to void*.
+       (restore_inferior_pid): Takes void* as required by make_cleanup.
+       Casts pid back to an int.
+
+       * procfs.c (make_cleanup_close_proc_file,
+       close_proc_file_cleanup): Create a proc_file cleanup.
+       (info_proc): Use.
+
+       * defs.h (make_cleanup_freeargv): Helper function.  Establish
+       cleanup using freeargv.  Can not just typecast/pass freeargv as it
+       violates ISO-C.
+       * utils.c (do_freeargv): Helper.
+       (make_cleanup_freeargv): New function.
+
+       * symmisc.c (maintenance_print_symbols,
+       maintenance_print_psymbols, maintenance_print_msymbols), symfile.c
+       (symbol_file_command), stack.c (backtrace_command), remote-sim.c
+       (gdbsim_create_inferior, gdbsim_open), remote-mips.c
+       (common_open), procfs.c (info_proc), infrun.c (handle_command,
+       xdb_handle_command), exec.c (exec_file_attach): Call
+       make_cleanup_freeargv.
+
+1999-03-03  James Ingham  <jingham@cygnus.com>
+
+       * i386-tdep.c (_initialize_i386_tdep): Set the inital value for
+       disassembly flavor at startup, rather than hardcoding it.
+
+1999-03-03  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       Put return values in the right place.
+       * fr30-tdep.c (fr30_store_return_value): New function.
+       * config/fr30/tm-fr30.h (STORE_RETURN_VALUE): Call
+       fr30_store_return_value.
+
+Wed Mar  3 18:10:55 1999  Andrew Cagney  <cagney@chook.cygnus.com>
+
+       * gdbtypes.c (virtual_base_list_aux): Return void.  Add prototype.
+
+       * breakpoint.c (map_catch_names): Comment out unused function.
+
+1999-03-02  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * hppa-tdep.c (pa_register_look_aside): Only refer to save_state_t
+       structure on PA 2.0 systems.
+
+1999-03-02  Stan Shebs  <shebs@andros.cygnus.com>
+
+       From Gary Thomas  <gthomas@cygnus.co.uk>:
+       * arm-tdep.c (ARM_LE_BREAKPOINT, ARM_BE_BREAKPOINT,
+       THUMB_LE_BREAKPOINT, THUMB_BE_BREAKPOINT): Use illegal instruction
+       instead of SWI 24.
+       * config/arm/tm-arm.h (CALL_DUMMY): Ditto.
+       (IN_SIGTRAMP): Define.
+
+1999-03-02  Nick Clifton  <nickc@cygnus.com>
+
+       * findvar.c (store_address): Delete incorrect big endian
+        code. 
+
+Tue Mar  2 18:02:42 1999  Andrew Cagney  <cagney@chook>
+
+       * configure.in (gdb_cv_os_cygwin): Compat.  Continue to reconize
+       __CYGWIN32__.
+
+1999-03-01  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * configure.in: Move setting of gdb_cv_os_cygwin to before
+       setting of TERM_LIB.  Check for __CYGWIN__ instead of __CYGWIN32__.
+       * configure: Regenerated.
+
+1999-03-01  DJ Delorie  <dj@cygnus.com>
+
+       * configure.in: Change -cygwin32* to -cygwin*.
+       * configure: Ditto.
+
+1999-02-25  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * breakpoint.c (SOLIB_LOADED_LIBRARY_PATHNAME,
+       SOLIB_UNLOADED_LIBRARY_PATHNAME, SOLIB_CREATE_CATCH_LOAD_HOOK,
+       SOLIB_CREATE_CATCH_UNLOAD_HOOK): Supply default definitions.
+       * infrun.c (SOLIB_IN_DYNAMIC_LINKER): Ditto.
+
+1999-02-25  Keith Seitz  <keiths@cygnus.com>
+
+       * corelow.c (core_close): Clear out solib state before
+       closing the bfd associated with the core file.
+       * solib.c (clear_solib): Mention that clear_solib requires
+       an open BFD in order for disable_breakpoints_in_shlibs to
+       determine whether breakpoints live in shared libraries.
+
+1999-02-24  Jason Molenda  (jsm@bugshack.cygnus.com)
 
         * configure.in: Set CPU_HPPA_RISC_20 if the host CPU is a PA 2.0 
         processor.
@@ -215,15 +960,90 @@ Tue Mar 16 15:29:04 1999  Stan Shebs  <shebs@andros.cygnus.com>
         structure elements if we are on a PA2.0 system.
         * defs.h: Include limits.h.
 
-       Merged changes from Stu Grossman:
+Tue Feb 23 14:37:08 1999  Michael Snyder  <msnyder@cleaver.cygnus.com>
+
+       * infrun.c (wait_for_inferior): Check scheduler_locking state 
+       before resuming after a thread-specific breakpoint.
+
+1999-02-23  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * aclocal.m4, config.in, configure: Regenerated with latest
+       autotools.
+
+Mon Feb 22 12:32:19 1999  Per Bothner  <bothner@cygnus.com>
+
+       * jv-valprint.c (java_val_print):  Restore line that somehow got lost.
+
+       * jv-valprint.c (java_print_value_fields):  Check for NULL type.
+
+1999-02-21  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * tm-h8500.h, i386lynx-nat.c: Removed.  These files are long
+       dead; it seems that they only appeared due to some CVS weirdness.
+       If they appear again, we may need to distribute garlic and holy
+       water.
+
+1999-02-19  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * configure.in (TERM_LIB): Move checking for TERM_LIB, substituting.
+       * configure: Regenerated.
+
+1999-02-19 Robert Hoehne (robert.hoehne@gmx.net)
+
+        * configure.host (i[3456]86-*-msdosdjgpp*): New host.
+        * configure.tgt (i[3456]86-*-msdosdjgpp*): New target.
+        * go32-nat.c: New file, native DJGPP support.
+        * config/i386/go32.mh: Rewrite for DJGPP (go32) host.
+        * config/i386/go32.mt: New file, DJGPP (go32) target.
+        * config/i386/nm-go32.h: New file.
+        * config/i386/tm-go32.h: New file.
+        * config/i386/xm-go32.h: Rewritten for current DJGPP.
+
+1999-02-18  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * reply_mig_hack.awk, config/nm-gnu.h, config/alpha/nm-linux.h
+       config/alpha/xm-alphalinux.h, config/alpha/xm-alphaosf.h
+       config/i386/nm-i386sco5.h, config/i386/tm-fbsd.h, config/i386/tm-i386.h
+       config/powerpc/nm-aix.h, config/powerpc/tm-macos.h
+       config/powerpc/tm-ppc-aix.h, config/powerpc/xm-aix.h
+       config/rs6000/tm-rs6000-aix4.h, testsuite/gdb.chill/tests1.ch
+       testsuite/gdb.chill/tests2.ch, testsuite/gdb.chill/tests2.exp:
+       Update FSF address in copyright notices.
+
+1999-02-18  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * configure.in: Quote "$GCC" correctly.
+       * configure: Regenerated.
+
+1999-02-18  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * dbxread.c (elfstab_build_psymtabs): Don't assume that there's a
+       section named ".text", which has all the code in it.  Instead, look
+       at all the sections in the file with the `code' flag set.
+       (find_text_range): New function, that does all the work.
+
+Thu Feb 18 17:50:45 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * mips-tdep.c (FP_REGISTER_DOUBLE): Conditionally define.
+
+Fri Jan 29 16:51:11 1999  Andrew Cagney  <cagney@chook.cygnus.com>
+
+       * mips-tdep.c (return_value_location): New function. Merge/rewrite
+       of return-value code in mips_extract_return_value,
+       mips_store_return_value.  Stop buffer overflow when 64 bit value
+       in 32 bit registers.  Extract 64bit float from 32 bit register
+       pair of correct order.
+       (mips_extract_return_value, mips_store_return_value): Call
+       return_value_location.  For store, ensure that remainder of
+       register is zero.
        
-       Wed Feb 17 10:10:27 1999  Stu Grossman  <grossman@babylon-5.cygnus.com>
+Wed Feb 17 10:10:27 1999  Stu Grossman  <grossman@babylon-5.cygnus.com>
 
        * gdbtypes.h (get_discrete_bounds):  Remove duplicate decl.
 
        * jv-typeprint.c (java_type_print_base):  Change fputs => fputs_filtered.
        
-       Mon Jan 25 18:30:57 1999  Per Bothner  <bothner@cygnus.com>
+Mon Jan 25 18:30:57 1999  Per Bothner  <bothner@cygnus.com>
 
        * jv-lang.h (JAVA_OBJECT_SIZE):  Change from hard-wired constant.
        (java_primitive_type_from_name, get_java_object_header_size):  Declare.
@@ -247,7 +1067,7 @@ Tue Mar 16 15:29:04 1999  Stan Shebs  <shebs@andros.cygnus.com>
        is a waste of effort.  Also, handle TYPE_CODE_INT, to make sure
        Java bytes as not printed as C chars.
 
-       Fri Jan  8 16:58:22 1999  Stu Grossman  <grossman@babylon-5.cygnus.com>
+Fri Jan  8 16:58:22 1999  Stu Grossman  <grossman@babylon-5.cygnus.com>
 
        * blockframe.c (find_pc_sect_partial_function):  Search full symtabs as
        a last ditch effort (after the partial & minimal symtabs).
@@ -263,7 +1083,7 @@ Tue Mar 16 15:29:04 1999  Stan Shebs  <shebs@andros.cygnus.com>
        * values.c (value_virtual_fn_field):  Fixes code to handle new vtable
        debug info format.  Patch from marka.
        
-       Wed Dec 16 23:11:25 1998  Stu Grossman  <grossman@fencer.cygnus.com>
+Wed Dec 16 23:11:25 1998  Stu Grossman  <grossman@fencer.cygnus.com>
 
        * jv-lang.c (java_class_from_object java_class_is_primitive
        is_object_type):  Change dtable to vtable.
@@ -271,13 +1091,13 @@ Tue Mar 16 15:29:04 1999  Stan Shebs  <shebs@andros.cygnus.com>
        * (_initialize_java_language):  Make java_char_type be unsigned.
        * jv-lang.h:  Fixup prototypes.
        
-       Mon Dec  7 19:02:15 1998  Stu Grossman  <grossman@babylon-5.cygnus.com>
+Mon Dec  7 19:02:15 1998  Stu Grossman  <grossman@babylon-5.cygnus.com>
 
        * jv-valprint.c (java_value_print):  Fix printing of values where
        run time type != compile time type.
 
-       Fri Dec  4 15:23:38 1998  Stu Grossman  <grossman@fencer.cygnus.com>
-  
+Fri Dec  4 15:23:38 1998  Stu Grossman  <grossman@fencer.cygnus.com>
+
        * Makefile.in:  Whack out m2-typeprint.c.
        * c-typeprint.c (c_type_print_varspec_suffix) typeprint.h:  Make this
        global.  It's needed by Java.
@@ -296,71 +1116,37 @@ Tue Mar 16 15:29:04 1999  Stan Shebs  <shebs@andros.cygnus.com>
        * jv-valprint.c (java_val_print):  Minor formatting.
        * m2-lang.c (m2_language_d):  Change m2_print_type to c_print_type.
        * stabsread.c (read_member_functions):  Save public and static attributes.
+       
+Wed Feb 17 15:32:57 1999  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
 
-1999-03-02  Stan Shebs  <shebs@andros.cygnus.com>
-
-       From Gary Thomas  <gthomas@cygnus.co.uk>:
-       * arm-tdep.c (ARM_LE_BREAKPOINT, ARM_BE_BREAKPOINT,
-       THUMB_LE_BREAKPOINT, THUMB_BE_BREAKPOINT): Use illegal instruction
-       instead of SWI 24.
-       * config/arm/tm-arm.h (CALL_DUMMY): Ditto.
-       (IN_SIGTRAMP): Define.
-
-1999-03-01  Jim Blandy  <jimb@zwingli.cygnus.com>
-
-       * configure.in (TERM_LIB): Move the code which sets this to a
-       better place.
-
-1999-02-25  Stan Shebs  <shebs@andros.cygnus.com>
-
-       * breakpoint.c (SOLIB_LOADED_LIBRARY_PATHNAME,
-       SOLIB_UNLOADED_LIBRARY_PATHNAME, SOLIB_CREATE_CATCH_LOAD_HOOK,
-       SOLIB_CREATE_CATCH_UNLOAD_HOOK): Supply default definitions.
-       * infrun.c (SOLIB_IN_DYNAMIC_LINKER): Ditto.
-
-1999-02-23  Jim Blandy  <jimb@zwingli.cygnus.com>
-
-       Patch from Jason Molenda  (jsm@bugshack.cygnus.com)
-        * configure.in (TERM_LIB): Move checking for TERM_LIB, substituting.
-        * configure, aclocal.m4, config.in: Regenerated.
-
-1999-02-22  Jim Blandy  <jimb@zwingli.cygnus.com>
-
-       * Makefile.in (VERSION): Bump to 4.17.85, for the release process.
-
-       Patch from Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
        * breakpoint.c (watch_command_1): Reformat comment.
 
-       Patch from Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
        * c-typeprint.c (c_type_print_base): Reformat comments.
 
-       Patch from Edith Epstein  <eepstein@sophia.cygnus.com>:
+1999-02-17  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * Makefile.in (VERSION): Bump version to 4.17.2.
+
+Tue Feb 16 15:48:20 1999  Edith Epstein  <eepstein@sophia.cygnus.com>
         * config/pa/nm-hppah.h: Added prototype declarations for
         hppa_enable_page_protection_events and 
         hppa_disable_page_protection_events.
-
-       Patch from Edith Epstein  <eepstein@sophia.cygnus.com>:
-        * infttrace.c (hppa_insert_hw_watchpoint): Make sure that
-        function always returns a value.
-        (hppa_remove_hw_watchpoint): Make sure that function always
-        returns a value.
-
-       Patch from Edith Epstein  <eepstein@sophia.cygnus.com>:
         * inftarg.c (child_wait): Fixed code that checks whether
         or not the target program has done a fork/vfork. 
         related_pid  does not have a value unless the target 
         program has forked/vforked.
-       
-1999-02-22  Jim Blandy  <jimb@zwingli.cygnus.com>
-
-       * tm-h8500.h, i386lynx-nat.c: Removed.  These files are long
-       dead; it seems that they only appeared due to some CVS weirdness.
-       If they appear again, we may need to distribute garlic and holy
-       water.
+        * infttrace.c (hppa_insert_hw_watchpoint): Make sure that
+        function always returns a value.
+        (hppa_remove_hw_watchpoint): Make sure that function always
+        returns a value.
 
-1999-02-16  Jim Blandy  <jimb@zwingli.cygnus.com>
+Tue Feb 16 06:31:58 1999  Keith Seitz  <keiths@cygnus.com>
 
-       * Makefile.in (VERSION): Bump to 4.17.2.
+       * config/powerpc/tm-ppc-eabi.h: Do not define PC_IN_CALL_DUMMY,
+       let the generic call dummy infrastructure do it.
 
 Sun Feb 14 18:21:08 1999  Mark Alexander  <marka@cygnus.com>
 
index 4f9a949c0481b09e12a906cf97ea30518a091a55..026c9a5c9e89ceff605cbe1f9b379d14ada1de9d 100644 (file)
@@ -143,6 +143,12 @@ Thu Dec 11 13:40:46 1997  Andrew Cagney  <cagney@b1.cygnus.com>
        * dwarf2read.c (dwarf_decode_lines): Change type of address to
        CORE_ADDR.
 
+Thu Dec 11 22:39:02 1997  Mark Alexander  <marka@cygnus.com>
+
+       From change made to branch by Bob Manson <manson@cygnus.com>:
+       * tic80-tdep.c (tic80_push_arguments): The compiler always
+       passes structs by reference.
+
 Thu Dec 11 14:28:01 1997  Michael Snyder  (msnyder@cleaver.cygnus.com)
 
        * tracepoint.c (trace_find_command): don't error if going
@@ -1016,6 +1022,10 @@ Sat Aug  9 01:50:14 1997  Peter Schauer  (pes@regent.e-technik.tu-muenchen.de)
 
 Fri Aug  8 21:35:44 1997  Mark Alexander  <marka@cygnus.com>
 
+       * config/tic80/tic80.mt:
+       (GDBSERVER-DEPFILES, GDBSERVER_LIBS): Define for gdbserver.
+       (SIM): Remove -lm to prevent make errors.
+       * configure.tgt: add gdbserver to configdirs for tic80.
        * gdbserver/utils.c (error): Change prototype to match defs.h.
        * gdbserver/low-sim.c: Change simulator calls to use new interface.
        * remote.c (remote_write_bytes): Include '$' at start of packet
@@ -1151,6 +1161,11 @@ Wed Aug  6 16:15:31 1997  Geoffrey Noer  <noer@cygnus.com>
        (_initialize_bdm_ppc): new
        * config/powerpc/tm-ppc-eabi.h: add necessary CPU32 BDM defines
 
+Tue Aug  5 23:56:14 1997  Mark Alexander  <marka@cygnus.com>
+
+       * tic80-tdep.c (tic80_init_extra_frame_info): Allow zero
+       as a valid SP-relative offset of a saved register.
+       
 Wed Aug  6 00:24:08 1997  Jeffrey A Law  (law@cygnus.com)
 
        * hpread.c (hpread_read_struct_type): Use accessor macros rather
@@ -1654,6 +1669,15 @@ Wed May 14 08:58:55 1997  Jeffrey A Law  (law@cygnus.com)
        symbols to find the end of the prologue.
        * mn10300-tdep.c (mn10300_skip_prologue): Likewise.
 
+Wed May 14 12:04:49 1997  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * config/tic80/tm-tic80.h (NUM_REGS): 38 not 37.
+
+Mon May 12 11:35:04 1997  Mark Alexander  <marka@cygnus.com>
+
+       * tic80-tdep.c, config/tic80/tm-tic80.h: First cut at getting
+       basic C80 features working.
+
 Thu May  8 08:42:47 1997  Andrew Cagney  <cagney@b1.cygnus.com>
 
        * configure.in (AC_TYPE_SIGNAL): Add
@@ -1695,6 +1719,10 @@ Thu May  1 02:28:21 1997  Peter Schauer  (pes@regent.e-technik.tu-muenchen.de)
        * printcmd.c (disassemble_command):  Adjust low function bound
        by FUNCTION_START_OFFSET.
 
+Wed Apr 30 15:23:02 1997  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * config/tic80/tm-tic80.h (BREAKPOINT): Set it to trap 73.
+
 Mon Apr 28 21:25:32 1997  Michael Snyder  <msnyder@cleaver.cygnus.com>
 
        * Makefile.in: Add rule for gnu-nat.o and i386gnu-nat.o (Gnu Hurd)
@@ -1762,6 +1790,15 @@ Thu Apr 24 13:31:10 1997  Jeffrey A Law  (law@cygnus.com)
        * mn10300-tdep.c (mn10300_analyze_prologue): Check for a return
        insn at "pc", not "fi->pc".
 
+Thu Apr 24 16:11:47 1997  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * config/tic80/tm-tic80.h (NUM_REGS): Four 64bit accumulators.
+       (REGISTER_BYTE, REGISTER_RAW_SIZE, REGISTER_SIZE,
+       MAX_REGISTER_RAW_SIZE, REGISTER_VIRTUAL_TYPE): Adjust.
+       (NPC_REGNUM): Tic80 has a delay slot.
+       (R0_REGNUM, Rn_REGNUM, An_REGNUM): For sim, provide base/bound for
+       register blocks.
+
 Wed Apr 23 11:18:45 1997  Jeffrey A Law  (law@cygnus.com)
 
        * config/mn10200/tm-mn10200.h (STORE_RETURN_VALUE): Pointers are
@@ -1780,6 +1817,10 @@ Tue Apr 22 11:58:15 1997  Fred Fish  <fnf@cygnus.com>
        (floatformat_from_doublest): Postswap output words for
        the floatformat_littlebyte_bigwords format.
 
+Mon Apr 21 22:44:47 1997  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * config/tic80/tic80.mt (SIM): Link in simulator.
+
 Tue Apr 22 09:02:10 1997  Stu Grossman  (grossman@critters.cygnus.com)
 
        * config/alpha/alpha-osf3.mh config/i386/{i386gnu linux}.mh
@@ -2102,6 +2143,11 @@ Mon Mar 31 14:55:53 1997  Ian Lance Taylor  <ian@cygnus.com>
        * configure.in: Generate .gdbinit from gdbinit.in.
        * configure: Rebuild.
 
+Sun Mar 30 12:28:24 1997  Fred Fish  <fnf@cygnus.com>
+
+       * config/tic80/tic80.mt: Disable using the simulator
+       until it is ready.
+
 Sat Mar 29 13:57:20 1997  Fred Fish  <fnf@cygnus.com>
 
        * COPYING: Install new version of file from FSF.
@@ -2111,6 +2157,10 @@ Fri Mar 28 18:33:41 1997  Ian Lance Taylor  <ian@cygnus.com>
 
        * Makefile.in (distclean): Remove .gdbinit.
 
+Fri Mar 28 15:37:30 1997  Fred Fish  <fnf@cygnus.com>
+
+       * config/tic80/tm-tic80.h (NAMES_HAVE_UNDERSCORE): Define.
+
 Fri Mar 28 15:38:04 1997  Mike Meissner  <meissner@cygnus.com>
 
        * remote-sim.c (gdb_os_{,e}vprintf_filtered): Change stdarg type
@@ -2167,6 +2217,10 @@ Sat Mar 22 16:41:35 1997  Fred Fish  <fnf@cygnus.com>
 
        * remote-sim.c (simulator_command): Add comment about dealing with
        NULL or empty args.
+       * Makefile.in (tic80-tdep.o): Add target.
+       * configure.tgt: Add tic80 case.
+       * tic80-tdep.c: New file.
+       * config/tic80/{tic80.mt, tm-tic80.h}: New files.
 
 Sat Mar 22 02:48:11 1997  Peter Schauer  (pes@regent.e-technik.tu-muenchen.de)
 
index bd19b49066a51a5e8ad7110f3acb24f8f520f91c..f60cd5bbc6cf020e180490fc17bef099c504dffb 100644 (file)
@@ -5718,6 +5718,13 @@ Wed Apr 29 14:02:59 1998  David Taylor  <taylor@texas.cygnus.com>
 
 Wed Apr 29 10:20:40 1998  John Metzler  <jmetzler@cygnus.com>
 
+       * nec4102rom.c: New file implements ROM monitor adapter for
+        nec-vr4102 board.  This board hosts the vr4111 chip.  This file
+        required extensions to the monitor_ops structure, hooks for wait
+        filter, new flags. This version does not support more than one
+        breakpoint and resuming after a breakpoint in 16 bit mode is
+        completely disfunctional.  
+
        * monitor.h: Defined additional hooks for dmpregs, configure_hooks
        and wait_filter. These additions require that all ROM monitor
        interfaces be recoded to initialize monitor ops using assignments
@@ -6481,6 +6488,9 @@ Wed Mar  4 01:39:08 1998  Ron Unrau  <runrau@cygnus.com>
 
 Tue Mar  3 17:19:08 1998  John Metzler  <jmetzler@cygnus.com>
 
+       * config/mips/tm-vr4xxx.h:  implements vr4111 as separate from 4300
+       * config/mips/vr4xxx.tm:    implements vr4111 as separate from 4300
+       * configure.tgt:  Recognise mips64vr4111-*-elf as vr4xxx
        * dwarfread.c (read_tag_pointer_type): Pointer sizes now come from
        TARGET_PTR_BIT rather from sizeof(char *) on host.
 
index 2c6dfb5cdeb2b9284a7ef40a8ee37d853ba9cff2..7799e098dd29ebaae7b491d687a2b795d06a8714 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
+# Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999
 # Free Software Foundation, Inc.
 
 # This file is part of GDB.
@@ -47,6 +47,8 @@ top_builddir = .
 SHELL = @SHELL@
 EXEEXT = @EXEEXT@
 
+AWK = @AWK@
+
 INSTALL = @INSTALL@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_DATA = @INSTALL_DATA@
@@ -215,7 +217,7 @@ CDEPS = $(XM_CDEPS) $(TM_CDEPS) $(NAT_CDEPS) $(SIM) $(BFD) $(READLINE) \
 ADD_FILES = $(REGEX) $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
 ADD_DEPS = $(REGEX1) $(XM_ADD_FILES) $(TM_ADD_FILES) $(NAT_ADD_FILES)
 
-VERSION=4.18
+VERSION = 19990422
 DIST=gdb
 
 LINT=/usr/5bin/lint
@@ -249,6 +251,13 @@ ANNOTATE_OBS = annotate.o
 @target_makefile_frag@
 # End of host and target-dependent makefile fragments
 
+# Possibly ignore the simulator.  If the simulator is being ignored, 
+# these expand into SIM= and SIM_OBJ=, overriding the entries from 
+# target_makefile_frag
+#
+@IGNORE_SIM@
+@IGNORE_SIM_OBS@
+
 FLAGS_TO_PASS = \
        "prefix=$(prefix)" \
        "exec_prefix=$(exec_prefix)" \
@@ -919,7 +928,7 @@ ALLDEPFILES = 29k-share/udi/udip2soc.c 29k-share/udi/udr.c \
        convex-tdep.c convex-xdep.c \
        core-sol2.c core-regset.c core-aout.c corelow.c \
        dcache.c delta68-nat.c dpx2-nat.c dstread.c exec.c fork-child.c \
-       go32-xdep.c gould-tdep.c gould-xdep.c h8300-tdep.c h8500-tdep.c \
+       gould-tdep.c gould-xdep.c h8300-tdep.c h8500-tdep.c \
        hp300ux-nat.c hppa-tdep.c hppab-nat.c hppah-nat.c \
         hp-psymtab-read.c hp-symtab-read.c \
        i386-tdep.c i386b-nat.c i386mach-nat.c i386v-nat.c \
@@ -1117,8 +1126,6 @@ gdbtypes.o: gdbtypes.c $(bfd_h) complaints.h $(defs_h) $(expression_h) \
 gnu-nat.o: process_reply_S.h exc_request_S.h notify_S.h msg_reply_S.h \
        exc_request_U.h msg_U.h gnu-nat.h
 
-go32-xdep.o: go32-xdep.c
-
 # OBSOLETE gould-tdep.o: gould-tdep.c $(OP_INCLUDE)/np1.h $(defs_h) $(frame_h) \
 # OBSOLETE     $(gdbcore_h) $(symtab_h)
 
@@ -1196,11 +1203,11 @@ jv-lang.o: jv-lang.c $(bfd_h) $(defs_h) $(symtab_h) $(gdbtypes_h) \
 
 jv-typeprint.o: jv-typeprint.c $(bfd_h) $(defs_h) $(symtab_h) $(gdbtypes_h) \
        $(value_h) $(INCLUDE_DIR)/demangle.h jv-lang.h gdb_string.h \
-       typeprint.h
+       typeprint.h c-lang.h
 
 jv-valprint.o: jv-valprint.c $(bfd_h) $(defs_h) $(symtab_h) $(gdbtypes_h) \
        $(expression_h) $(value_h) $(INCLUDE_DIR)/demangle.h valprint.h \
-       language.h jv-lang.h c-lang.h
+       language.h jv-lang.h c-lang.h gdbcore.h annotate.h
 
 language.o: language.c $(bfd_h) $(defs_h) $(expression_h) $(frame_h) \
        $(gdbcmd_h) $(gdbtypes_h) language.h parser-defs.h $(symtab_h) \
@@ -1297,7 +1304,7 @@ nindy-tdep.o: nindy-tdep.c $(defs_h) $(frame_h) $(symtab_h)  $(gdbcore_h)
 ns32k-tdep.o: ns32k-tdep.c $(bfd_h) $(dis-asm_h) $(defs_h)
 
 objfiles.o: objfiles.c $(bfd_h) $(defs_h) objfiles.h symfile.h \
-       $(symtab_h) gdb_string.h
+       $(symtab_h) gdb_string.h $(breakpoint_h)
 
 osfsolib.o: osfsolib.c $(command_h) $(defs_h) $(gdbcore_h) $(inferior_h) \
        objfiles.h gnu-regex.h symfile.h target.h language.h gdb_string.h
@@ -1504,7 +1511,7 @@ stabsread.o: stabsread.c $(bfd_h) $(INCLUDE_DIR)/aout/stab.def \
 stack.o: stack.c $(defs_h) $(gdbcmd_h) $(gdbcore_h) $(inferior_h) \
        language.h target.h gdb_string.h
 
-ax-general.o: ax-general.c $(ax_h) $(defs_h)
+ax-general.o: ax-general.c $(ax_h) $(defs_h) $(value_h)
 ax-gdb.o: ax-gdb.c $(defs_h) $(symtab_h) symfile.h $(gdbtypes_h) \
        $(value_h) $(expression_h) $(command_h) $(ax_h) $(gdbcmd_h) ax-gdb.h
 
@@ -1533,6 +1540,8 @@ symtab.o: symtab.c call-cmds.h $(defs_h) $(expression_h) $(frame_h) \
 tahoe-tdep.o: tahoe-tdep.c $(OP_INCLUDE)/tahoe.h $(defs_h) \
        $(symtab_h)
 
+tic80-tdep.o: tic80-tdep.c $(defs_h)
+
 target.o: target.c $(bfd_h) $(defs_h) $(gdbcmd_h) $(inferior_h) \
        objfiles.h symfile.h target.h gdb_string.h
 
index e6aaba318a17303f0aef4effbd1764a37d3a710f..7ae2bbdf23d6e3d6d6e0a1d2b9c3efb608650f3e 100644 (file)
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -1,6 +1,13 @@
                What has changed in GDB?
             (Organized release by release)
 
+*** Changes since GDB-4.18:
+
+* New targets
+
+TI TMS320C80                                   tic80-*-*
+
+
 *** Changes in GDB-4.18:
 
 * New native configurations
index fd791ced52315569cfd5aaf787e23432169ba286..46b9074ff17dcf48475d10dbf45ad98f5b46940b 100644 (file)
@@ -4,8 +4,8 @@
 This is GDB, the GNU source-level debugger.
 A summary of new features is in the file `NEWS'.
 
-See the GDB home page at http://www.cygnus.com/gdb/ for up to date
-release information, mailing list links and archives, etc.
+See the GDB home page at http://sourceware.cygnus.com/gdb/ for up to
+date release information, mailing list links and archives, etc.
 
 
 Unpacking and Installation -- quick overview
@@ -152,6 +152,8 @@ directory.  That directory contains:
 
 `gdb-4.18/readline'
      source for the GNU command-line interface
+     NOTE:  The readline library is compiled for use by GDB, but will
+     not be installed on your system when "make install" is issued.
 
 `gdb-4.18/sim'
      source for some simulators (ARM, D10V, SPARC, M32R, MIPS, PPC, V850, etc)
index b3c056723ad635b7f248891b5b15722acfca2da0..114922c97399501f1221fc064191ac14303a3962 100644 (file)
@@ -510,7 +510,7 @@ init_extra_frame_info (frame)
        but there isn't any way to tell the difference.  */
     init_frame_info (1, frame);
   else {
-      /* We're in get_prev_frame_info.
+      /* We're in get_prev_frame.
          Take care of everything in init_frame_pc.  */
       ;
     }
@@ -668,7 +668,7 @@ write_register_stack (memaddr, myaddr, actual_mem_addr)
    The argument RAW_BUFFER must point to aligned memory.  */
 
 void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lvalp)
+a29k_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lvalp)
      char *raw_buffer;
      int *optimized;
      CORE_ADDR *addrp;
index 95bb3c83716bb2aee32adee8eec021f9a999ef2b..deb9247beb8897c7036845e7e01cd2fe3e9251bb 100644 (file)
@@ -35,7 +35,6 @@ fetch_inferior_registers (ignored)
   struct ptrace_$data_regs_m68k inferior_registers;
   struct ptrace_$floating_regs_m68k inferior_fp_registers;
   struct ptrace_$control_regs_m68k inferior_control_registers;
-  extern char registers[];
 
   ptrace_$init_control(&inferior_control_registers);
   inferior_fp_registers.size = sizeof(inferior_fp_registers);
@@ -78,7 +77,6 @@ store_inferior_registers (regno)
   struct ptrace_$data_regs_m68k inferior_registers;
   struct ptrace_$floating_regs_m68k inferior_fp_registers;
   struct ptrace_$control_regs_m68k inferior_control_registers;
-  extern char registers[];
 
   ptrace_$init_control(&inferior_control_registers);
   inferior_fp_registers.size = sizeof(inferior_fp_registers);
index 9ad502094fbcaa72e6daa1883f3e72bf1e95196c..8128e4e91df9245dcfbd53a595bce1cd8def2a15 100644 (file)
@@ -88,6 +88,9 @@
    name, as a C string.  */
 #undef TARGET_CPU_DEFAULT
 
+/* Define if the simulator is being linked in.  */
+#undef WITH_SIM
+
 /* Set to true if the save_state_t structure is present */
 #define HAVE_STRUCT_SAVE_STATE_T 0
 
index 43a0b0d57e7098c48cdf6869ef5bc21afb238771..d614f2a5383597811b5027760254e3436eb4542a 100644 (file)
@@ -493,7 +493,7 @@ AC_DEFUN(CY_AC_PATH_ITCLCONFIG, [
 if test x"${no_itcl}" = x ; then
   # we reset no_itcl in case something fails here
   no_itcl=true
-  AC_ARG_WITH(itclconfig, [  --with-itclconfig           directory containing itcl configuration (itclConfig.sh)],
+  AC_ARG_WITH(itclconfig, [  --with-itclconfig       Directory containing itcl configuration (itclConfig.sh)],
          with_itclconfig=${withval})
   AC_MSG_CHECKING([for Itcl configuration])
   AC_CACHE_VAL(ac_cv_c_itclconfig,[
@@ -619,7 +619,7 @@ AC_DEFUN(CY_AC_PATH_ITKCONFIG, [
 if test x"${no_itk}" = x ; then
   # we reset no_itk in case something fails here
   no_itk=true
-  AC_ARG_WITH(itkconfig, [  --with-itkconfig           directory containing itk configuration (itkConfig.sh)],
+  AC_ARG_WITH(itkconfig, [  --with-itkconfig        Directory containing itk configuration (itkConfig.sh)],
          with_itkconfig=${withval})
   AC_MSG_CHECKING([for Itk configuration])
   AC_CACHE_VAL(ac_cv_c_itkconfig,[
@@ -765,7 +765,7 @@ AC_DEFUN(CY_AC_PATH_TIXCONFIG, [
 if test x"${no_tix}" = x ; then
   # we reset no_tix in case something fails here
   no_tix=true
-  AC_ARG_WITH(tixconfig, [  --with-tixconfig           directory containing tix configuration (tixConfig.sh)],
+  AC_ARG_WITH(tixconfig, [  --with-tixconfig        Directory containing tix configuration (tixConfig.sh)],
          with_tixconfig=${withval})
   AC_MSG_CHECKING([for Tix configuration])
   AC_CACHE_VAL(ac_cv_c_tixconfig,[
index 4fd3658dd6b01ee40232b289fe9729e90f1bfc2d..1a1183223c18ff1a173b80c76eb3d76c61e1598d 100644 (file)
@@ -505,7 +505,7 @@ AC_DEFUN(CY_AC_PATH_ITCLCONFIG, [
 if test x"${no_itcl}" = x ; then
   # we reset no_itcl in case something fails here
   no_itcl=true
-  AC_ARG_WITH(itclconfig, [  --with-itclconfig           directory containing itcl configuration (itclConfig.sh)],
+  AC_ARG_WITH(itclconfig, [  --with-itclconfig       Directory containing itcl configuration (itclConfig.sh)],
          with_itclconfig=${withval})
   AC_MSG_CHECKING([for Itcl configuration])
   AC_CACHE_VAL(ac_cv_c_itclconfig,[
@@ -631,7 +631,7 @@ AC_DEFUN(CY_AC_PATH_ITKCONFIG, [
 if test x"${no_itk}" = x ; then
   # we reset no_itk in case something fails here
   no_itk=true
-  AC_ARG_WITH(itkconfig, [  --with-itkconfig           directory containing itk configuration (itkConfig.sh)],
+  AC_ARG_WITH(itkconfig, [  --with-itkconfig        Directory containing itk configuration (itkConfig.sh)],
          with_itkconfig=${withval})
   AC_MSG_CHECKING([for Itk configuration])
   AC_CACHE_VAL(ac_cv_c_itkconfig,[
@@ -777,7 +777,7 @@ AC_DEFUN(CY_AC_PATH_TIXCONFIG, [
 if test x"${no_tix}" = x ; then
   # we reset no_tix in case something fails here
   no_tix=true
-  AC_ARG_WITH(tixconfig, [  --with-tixconfig           directory containing tix configuration (tixConfig.sh)],
+  AC_ARG_WITH(tixconfig, [  --with-tixconfig        Directory containing tix configuration (tixConfig.sh)],
          with_tixconfig=${withval})
   AC_MSG_CHECKING([for Tix configuration])
   AC_CACHE_VAL(ac_cv_c_tixconfig,[
index 02010160b96f41026adf97949650b46fcea1e0e6..35430a4c502370434eeb06c2210306293c483846 100644 (file)
@@ -154,8 +154,14 @@ struct linked_proc_info
    think this will be a problem in praxis, though.
 */
 
+#ifndef TM_LINUXALPHA_H
+/* HACK: Provide a prototype when compiling this file for non
+   linuxalpha targets. */
+long alpha_linux_sigtramp_offset PARAMS ((CORE_ADDR pc));
+#endif
 long
-alpha_linux_sigtramp_offset (CORE_ADDR pc)
+alpha_linux_sigtramp_offset (pc)
+     CORE_ADDR pc;
 {
   unsigned int i[3], w;
   long off;
@@ -903,7 +909,7 @@ alpha_push_arguments (nargs, args, sp, struct_return, struct_addr)
      int struct_return;
      CORE_ADDR struct_addr;
 {
-  register i;
+  int i;
   int accumulate_size = struct_return ? 8 : 0;
   int arg_regs_size = ALPHA_NUM_ARG_REGS * 8;
   struct alpha_arg { char *contents; int len; int offset; };
@@ -1209,18 +1215,21 @@ alpha_skip_prologue (pc, lenient)
            continue;
        if ((inst & 0xffff0000) == 0x23de0000)  /* lda $sp,n($sp) */
            continue;
-       else if ((inst & 0xfc1f0000) == 0xb41e0000
-                && (inst & 0xffff0000) != 0xb7fe0000)
+       if ((inst & 0xffe01fff) == 0x43c0153e)  /* subq $sp,n,$sp */
+           continue;
+
+       if ((inst & 0xfc1f0000) == 0xb41e0000
+           && (inst & 0xffff0000) != 0xb7fe0000)
            continue;                           /* stq reg,n($sp) */
                                                /* reg != $zero */
-       else if ((inst & 0xfc1f0000) == 0x9c1e0000
-                && (inst & 0xffff0000) != 0x9ffe0000)
+       if ((inst & 0xfc1f0000) == 0x9c1e0000
+           && (inst & 0xffff0000) != 0x9ffe0000)
            continue;                           /* stt reg,n($sp) */
                                                /* reg != $zero */
-       else if (inst == 0x47de040f)            /* bis sp,sp,fp */
+       if (inst == 0x47de040f)                 /* bis sp,sp,fp */
            continue;
-       else
-           break;
+
+       break;
     }
     return pc + offset;
 }
@@ -1383,6 +1392,7 @@ alpha_call_dummy_address ()
     return SYMBOL_VALUE_ADDRESS (sym) + 4;
 }
 
+void _initialize_alpha_tdep PARAMS ((void));
 void
 _initialize_alpha_tdep ()
 {
index 5727332cf6fefdb46852379a2455a45c502037f2..272c581b8ffa01290e91723cb9555c38afd21c4f 100644 (file)
@@ -54,7 +54,6 @@ core_file_command (filename, from_tty)
      int from_tty;
 {
   int val;
-  extern char registers[];
 
   /* Discard all vestiges of any previous core file
      and mark data and stack spaces as empty.  */
index ec3e4245c9bd41a56203c47144ddac7e0b348c4e..5cde62607c0d69f0a9df89fe108c5f77ab418589 100644 (file)
@@ -1,5 +1,5 @@
 /* Annotation routines for GDB.
-   Copyright 1986, 89, 90, 91, 92, 95, 1998 Free Software Foundation, Inc.
+   Copyright 1986, 89, 90, 91, 92, 95, 98, 1999 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -34,6 +34,7 @@ static void breakpoint_changed PARAMS ((struct breakpoint *));
 void (*annotate_starting_hook) PARAMS ((void));
 void (*annotate_stopped_hook) PARAMS ((void));
 void (*annotate_signalled_hook) PARAMS ((void));
+void (*annotate_signal_hook) PARAMS ((void));
 void (*annotate_exited_hook) PARAMS ((void));
 
 static void
@@ -161,6 +162,9 @@ annotate_signal_string_end ()
 void
 annotate_signal ()
 {
+  if (annotate_signal_hook)
+    annotate_signal_hook ();
+
   if (annotation_level > 1)
     printf_filtered ("\n\032\032signal\n");
 }
index 59739db68dadd436148e53ca86bdf25f49afeb60..406ee041386909c6d9f5881a4c446c15935e2c2a 100644 (file)
@@ -1,5 +1,5 @@
 /* Annotation routines for GDB.
-   Copyright 1986, 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
+   Copyright 1986, 1989, 1990, 1991, 1992, 1999 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -101,4 +101,5 @@ extern void annotate_array_section_end PARAMS ((void));
 extern void (*annotate_starting_hook) PARAMS ((void));
 extern void (*annotate_stopped_hook) PARAMS ((void));
 extern void (*annotate_signalled_hook) PARAMS ((void));
+extern void (*annotate_signal_hook) PARAMS ((void));
 extern void (*annotate_exited_hook) PARAMS ((void));
index 92957700f9c53c274e5c4353218b644cc75024c6..c5dd8478a15f60f046553157f13c6c0644c74d38 100644 (file)
@@ -234,7 +234,7 @@ arc_get_frame_setup (pc)
          /* This sequence is used to get the address of the return
             buffer for a function that returns a structure.  */
          insn = codestream_peek ();
-         if (insn & OPMASK == 0x60000000)
+         if ((insn & OPMASK) == 0x60000000)
            codestream_get ();
        }
       /* Frameless fn.  */
index 607dc8fb5afa8341c1f7e66b0c16e5e15364dd5a..d6970a2d9b84ea2ed18a5837e31bcbc9fea5fbc5 100644 (file)
@@ -1,5 +1,5 @@
-/* Target-dependent code for the Acorn Risc Machine, for GDB, the GNU Debugger.
-   Copyright (C) 1988, 1989, 1991, 1992, 1993, 1995, 1996, 1998, 1999
+/* Target-dependent code for the Acorn Risc Machine (ARM).
+   Copyright (C) 1988, 1989, 1991, 1992, 1993, 1995-1999
    Free Software Foundation, Inc.
 
 This file is part of GDB.
@@ -479,7 +479,7 @@ arm_scan_prologue (fi)
     {
       /* Get address of the stmfd in the prologue of the callee; the saved
          PC is the address of the stmfd + 12.  */
-      prologue_start = (read_memory_integer (fi->frame, 4) & 0x03fffffc) - 12;
+      prologue_start = ADDR_BITS_REMOVE(read_memory_integer (fi->frame, 4)) - 12;
       prologue_end = prologue_start + 40; /* FIXME: should be big enough */
     }
 
@@ -974,14 +974,16 @@ arm_pop_frame ()
 {
   struct frame_info *frame = get_current_frame();
   int regnum;
+  CORE_ADDR old_SP;
 
+  old_SP = read_register (frame->framereg);
   for (regnum = 0; regnum < NUM_REGS; regnum++)
     if (frame->fsr.regs[regnum] != 0)
       write_register (regnum, 
                      read_memory_integer (frame->fsr.regs[regnum], 4));
 
   write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
-  write_register (SP_REGNUM, read_register (frame->framereg));
+  write_register (SP_REGNUM, old_SP);
 
   flush_cached_frames ();
 }
index f0d806e82e747051306cdda30d1c19ac5da73a9a..19781c207137f5ef4e0b6e595b336c5a344e8385 100644 (file)
@@ -161,7 +161,6 @@ core_file_command (filename, from_tty)
      int from_tty;
 {
   int val;
-  extern char registers[];
 
   /* Discard all vestiges of any previous core file
      and mark data and stack spaces as empty.  */
index c518e19e0dad3ac91daf9e31029666e2019bf61a..831203136924d2959d40cbf9df9234e20abeb006 100644 (file)
@@ -17,8 +17,6 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
-/* $Id$ */
-
 #include "defs.h"
 #include "symtab.h"
 #include "symfile.h"
index bca70d64beb3df7cc225ca952cdf3510220e1372..feab1881b7b22d717fe4a61ff66a19bc0b677b87 100644 (file)
@@ -17,8 +17,6 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
-/* $Id$ */
-
 #ifndef AX_GDB_H
 #define AX_GDB_H
 
index 76e9bb462db77d51c0b622d14fd7ae4be9cbbaae..30022a376e2917db4e02f79e2802fa790f8cdceb 100644 (file)
@@ -17,8 +17,6 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
-/* $Id$ */
-
 /* Despite what the above comment says about this file being part of
    GDB, we would like to keep these functions free of GDB
    dependencies, since we want to be able to use them in contexts
@@ -27,6 +25,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "defs.h"
 #include "ax.h"
 
+#include "value.h"
+
 \f
 /* Functions for building expressions.  */
 
index 2ee0f0bdb41df5b3b98a88a3586abff6c583cc65..069dd997509ac5128366c7386d39f4c83d348c62 100644 (file)
--- a/gdb/ax.h
+++ b/gdb/ax.h
@@ -17,8 +17,6 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
-/* $Id$ */
-
 #ifndef AGENTEXPR_H
 #define AGENTEXPR_H
 
index d28515b846c61c48ead1712c40bf039dbc101e30..0d6d2058e7813aace6436e70e0b567fdf8c18376 100644 (file)
@@ -138,8 +138,6 @@ bcache (bytes, count, bcachep)
   return (location);
 }
 
-#if MAINTENANCE_CMDS
-
 void
 print_bcache_statistics (bcachep, id)
      struct bcache *bcachep;
@@ -215,5 +213,3 @@ print_bcache_statistics (bcachep, id)
     }
   printf_filtered ("    Maximum chain length %d at %d:%d\n", lmax, lmaxt, lmaxh);
 }
-
-#endif /* MAINTENANCE_CMDS */
index cf0c62eeda1a7ab24e5f29390e29298eea4e4104..4b753be42dca5860fda285f79b74d13e2eaa70f6 100644 (file)
@@ -62,11 +62,7 @@ struct bcache {
 extern void *
 bcache PARAMS ((void *bytes, int count, struct bcache *bcachep));
 
-#if MAINTENANCE_CMDS
-
 extern void
 print_bcache_statistics PARAMS ((struct bcache *, char *));
 
-#endif /* MAINTENANCE_CMDS */
-
 #endif /* BCACHE_H */
index 9366ca650e2079633fd9bf470f6e471f3f21bd3f..c3b377eda4ac6162fef5bc3bc04e715fc0d87c0f 100644 (file)
@@ -88,13 +88,14 @@ inside_entry_file (addr)
     return 1;
   if (symfile_objfile == 0)
     return 0;
-#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
-  /* Do not stop backtracing if the pc is in the call dummy
-     at the entry point.  */
-/* FIXME: Won't always work with zeros for the last two arguments */
-  if (PC_IN_CALL_DUMMY (addr, 0, 0))   
-    return 0;
-#endif
+  if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
+    {
+      /* Do not stop backtracing if the pc is in the call dummy
+        at the entry point.  */
+      /* FIXME: Won't always work with zeros for the last two arguments */
+      if (PC_IN_CALL_DUMMY (addr, 0, 0))       
+       return 0;
+    }
   return (addr >= symfile_objfile -> ei.entry_file_lowpc &&
          addr <  symfile_objfile -> ei.entry_file_highpc);
 }
@@ -148,19 +149,20 @@ CORE_ADDR pc;
 
 int
 inside_entry_func (pc)
-CORE_ADDR pc;
+     CORE_ADDR pc;
 {
   if (pc == 0)
     return 1;
   if (symfile_objfile == 0)
     return 0;
-#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
-  /* Do not stop backtracing if the pc is in the call dummy
-     at the entry point.  */
-/* FIXME: Won't always work with zeros for the last two arguments */
-  if (PC_IN_CALL_DUMMY (pc, 0, 0))
-    return 0;
-#endif
+  if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
+    {
+      /* Do not stop backtracing if the pc is in the call dummy
+        at the entry point.  */
+      /* FIXME: Won't always work with zeros for the last two arguments */
+      if (PC_IN_CALL_DUMMY (pc, 0, 0))
+       return 0;
+    }
   return (symfile_objfile -> ei.entry_func_lowpc  <= pc &&
          symfile_objfile -> ei.entry_func_highpc > pc);
 }
@@ -245,16 +247,6 @@ create_new_frame (addr, pc)
   return fi;
 }
 
-/* Return the frame that called FI.
-   If FI is the original frame (it has no caller), return 0.  */
-
-struct frame_info *
-get_prev_frame (frame)
-     struct frame_info *frame;
-{
-  return get_prev_frame_info (frame);
-}
-
 /* Return the frame that FRAME calls (NULL if FRAME is the innermost
    frame).  */
 
@@ -352,7 +344,7 @@ frameless_look_for_prologue (frame)
    if there is no such frame.  */
 
 struct frame_info *
-get_prev_frame_info (next_frame)
+get_prev_frame (next_frame)
      struct frame_info *next_frame;
 {
   CORE_ADDR address = 0;
@@ -1034,7 +1026,72 @@ sigtramp_saved_pc (frame)
 }
 #endif /* SIGCONTEXT_PC_OFFSET */
 
-#ifdef USE_GENERIC_DUMMY_FRAMES
+
+/* Are we in a call dummy?  The code below which allows DECR_PC_AFTER_BREAK
+   below is for infrun.c, which may give the macro a pc without that
+   subtracted out.  */
+
+extern CORE_ADDR text_end;
+
+int
+pc_in_call_dummy_before_text_end (pc, sp, frame_address)
+     CORE_ADDR pc;
+     CORE_ADDR sp;
+     CORE_ADDR frame_address;
+{
+  return ((pc) >= text_end - CALL_DUMMY_LENGTH
+         && (pc) <= text_end + DECR_PC_AFTER_BREAK);
+}
+
+int
+pc_in_call_dummy_after_text_end (pc, sp, frame_address)
+     CORE_ADDR pc;
+     CORE_ADDR sp;
+     CORE_ADDR frame_address;
+{
+  return ((pc) >= text_end
+         && (pc) <= text_end + CALL_DUMMY_LENGTH + DECR_PC_AFTER_BREAK);
+}
+
+/* Is the PC in a call dummy?  SP and FRAME_ADDRESS are the bottom and
+   top of the stack frame which we are checking, where "bottom" and
+   "top" refer to some section of memory which contains the code for
+   the call dummy.  Calls to this macro assume that the contents of
+   SP_REGNUM and FP_REGNUM (or the saved values thereof), respectively,
+   are the things to pass.
+
+   This won't work on the 29k, where SP_REGNUM and FP_REGNUM don't
+   have that meaning, but the 29k doesn't use ON_STACK.  This could be
+   fixed by generalizing this scheme, perhaps by passing in a frame
+   and adding a few fields, at least on machines which need them for
+   PC_IN_CALL_DUMMY.
+
+   Something simpler, like checking for the stack segment, doesn't work,
+   since various programs (threads implementations, gcc nested function
+   stubs, etc) may either allocate stack frames in another segment, or
+   allocate other kinds of code on the stack.  */
+
+int
+pc_in_call_dummy_on_stack (pc, sp, frame_address)
+     CORE_ADDR pc;
+     CORE_ADDR sp;
+     CORE_ADDR frame_address;
+{
+  return (INNER_THAN ((sp), (pc))
+         && (frame_address != 0)
+         && INNER_THAN ((pc), (frame_address)));
+}
+
+int
+pc_in_call_dummy_at_entry_point (pc, sp, frame_address)
+     CORE_ADDR pc;
+     CORE_ADDR sp;
+     CORE_ADDR frame_address;
+{
+  return ((pc) >= CALL_DUMMY_ADDRESS ()
+         && (pc) <= (CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK));
+}
+
 
 /*
  * GENERIC DUMMY FRAMES
@@ -1053,6 +1110,20 @@ sigtramp_saved_pc (frame)
  * being executed by the target.  Also FRAME_CHAIN_VALID as
  * generic_frame_chain_valid.  */
 
+/* Dummy frame.  This saves the processor state just prior to setting
+   up the inferior function call.  Older targets save the registers
+   target stack (but that really slows down function calls).  */
+
+struct dummy_frame
+{
+  struct dummy_frame *next;
+
+  CORE_ADDR pc;
+  CORE_ADDR fp;
+  CORE_ADDR sp;
+  char *registers;
+};
+
 static struct dummy_frame *dummy_frame_stack = NULL;
 
 /* Function: find_dummy_frame(pc, fp, sp)
@@ -1073,7 +1144,7 @@ generic_find_dummy_frame (pc, fp)
        dummyframe = dummyframe->next)
     if (fp == dummyframe->fp || fp == dummyframe->sp)
       /* The frame in question lies between the saved fp and sp, inclusive */
-      return dummyframe->regs;
+      return dummyframe->registers;
 
   return 0;
 }
@@ -1082,12 +1153,14 @@ generic_find_dummy_frame (pc, fp)
    Return true if this is a dummy frame created by gdb for an inferior call */
 
 int
-generic_pc_in_call_dummy (pc, fp)
+generic_pc_in_call_dummy (pc, sp, fp)
      CORE_ADDR pc;
+     CORE_ADDR sp;
      CORE_ADDR fp;
 {
   /* if find_dummy_frame succeeds, then PC is in a call dummy */
-  return (generic_find_dummy_frame (pc, fp) != 0);
+  /* Note: SP and not FP is passed on. */
+  return (generic_find_dummy_frame (pc, sp) != 0);
 }
 
 /* Function: read_register_dummy 
@@ -1137,10 +1210,12 @@ generic_push_dummy_frame ()
       dummy_frame = dummy_frame->next;
 
   dummy_frame = xmalloc (sizeof (struct dummy_frame));
+  dummy_frame->registers = xmalloc (REGISTER_BYTES);
+
   dummy_frame->pc   = read_register (PC_REGNUM);
   dummy_frame->sp   = read_register (SP_REGNUM);
   dummy_frame->fp   = fp;
-  read_register_bytes (0, dummy_frame->regs, REGISTER_BYTES);
+  read_register_bytes (0, dummy_frame->registers, REGISTER_BYTES);
   dummy_frame->next = dummy_frame_stack;
   dummy_frame_stack = dummy_frame;
 }
@@ -1174,8 +1249,10 @@ generic_pop_dummy_frame ()
   if (!dummy_frame)
     error ("Can't pop dummy frame!");
   dummy_frame_stack = dummy_frame->next;
-  write_register_bytes (0, dummy_frame->regs, REGISTER_BYTES);
+  write_register_bytes (0, dummy_frame->registers, REGISTER_BYTES);
   flush_cached_frames ();
+
+  free (dummy_frame->registers);
   free (dummy_frame);
 }
 
@@ -1292,7 +1369,6 @@ generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
   if (raw_buffer)
     read_register_gen (regnum, raw_buffer);
 }
-#endif /* USE_GENERIC_DUMMY_FRAMES */
 
 void
 _initialize_blockframe ()
index 4b05949b59bd9be3960506eeebfffb3e598b64bf..30e94edfbb47a534af16f8129c0aa12ad0f3b337 100644 (file)
@@ -88,9 +88,14 @@ watch_command PARAMS ((char *, int));
 static int
 can_use_hardware_watchpoint PARAMS ((struct value *));
 
+static void break_at_finish_command PARAMS ((char *, int));
+static void break_at_finish_at_depth_command PARAMS ((char *, int));
+
 void
 tbreak_command PARAMS ((char *, int));
 
+static void tbreak_at_finish_command PARAMS ((char *, int));
+
 static void
 break_command_1 PARAMS ((char *, int, int));
 
@@ -182,6 +187,36 @@ static void awatch_command PARAMS ((char *, int));
 
 static void do_enable_breakpoint PARAMS ((struct breakpoint *, enum bpdisp));
 
+static void create_solib_load_unload_event_breakpoint PARAMS ((char *hookname, int  tempflag, char *dll_pathname, char *cond_string, enum bptype bp_kind));
+
+static void create_fork_vfork_event_catchpoint PARAMS ((int  tempflag, char *  cond_string, enum bptype bp_kind));
+
+static void break_at_finish_at_depth_command_1 PARAMS ((char *arg, int flag, int from_tty));
+
+static void break_at_finish_command_1 PARAMS ((char *arg, int flag, int from_tty));
+
+static void stop_command PARAMS ((char *arg, int from_tty));
+
+static void stopin_command PARAMS ((char *arg, int from_tty));
+
+static void stopat_command PARAMS ((char *arg, int from_tty));
+
+static char *ep_find_event_name_end PARAMS ((char *arg));
+
+static char *ep_parse_optional_if_clause PARAMS ((char **arg));
+
+static char *ep_parse_optional_filename PARAMS ((char **arg));
+
+static void catch_exec_command_1 PARAMS ((char *arg, int tempflag, int from_tty));
+
+static void create_exception_catchpoint PARAMS ((int tempflag, char *cond_string, enum exception_event_kind ex_event, struct symtab_and_line *sal));
+
+static void catch_exception_command_1 PARAMS ((enum exception_event_kind ex_event, char *arg, int tempflag, int from_tty));
+
+static void tcatch_command PARAMS ((char *arg, int from_tty));
+
+static void ep_skip_leading_whitespace PARAMS ((char **s));
+
 /* Prototypes for exported functions. */
 
 static void
@@ -1327,29 +1362,26 @@ int
 frame_in_dummy (frame)
      struct frame_info *frame;
 {
-#ifdef CALL_DUMMY
-#ifdef USE_GENERIC_DUMMY_FRAMES 
-  return generic_pc_in_call_dummy (frame->pc, frame->frame);
-#else
   struct breakpoint *b;
 
+  if (! CALL_DUMMY_P)
+    return 0;
+
+  if (USE_GENERIC_DUMMY_FRAMES)
+    return generic_pc_in_call_dummy (frame->pc, frame->frame, frame->frame);
+  
   ALL_BREAKPOINTS (b)
     {
-      static ULONGEST dummy[] = CALL_DUMMY;
-
       if (b->type == bp_call_dummy
          && b->frame == frame->frame
-
          /* We need to check the PC as well as the frame on the sparc,
             for signals.exp in the testsuite.  */
          && (frame->pc
              >= (b->address
-                 - sizeof (dummy) / sizeof (LONGEST) * REGISTER_SIZE))
+                 - SIZEOF_CALL_DUMMY_WORDS / sizeof (LONGEST) * REGISTER_SIZE))
          && frame->pc <= b->address)
        return 1;
     }
-#endif /* GENERIC_DUMMY_FRAMES */
-#endif /* CALL_DUMMY */
   return 0;
 }
 
@@ -2932,10 +2964,8 @@ breakpoints_info (bnum_exp, from_tty)
   breakpoint_1 (bnum, 0);
 }
 
-#if MAINTENANCE_CMDS
-
 /* ARGSUSED */
-void
+static void
 maintenance_info_breakpoints (bnum_exp, from_tty)
      char *bnum_exp;
      int from_tty;
@@ -2948,8 +2978,6 @@ maintenance_info_breakpoints (bnum_exp, from_tty)
   breakpoint_1 (bnum, 1);
 }
 
-#endif
-
 /* Print a message describing any breakpoints set at PC.  */
 
 static void
@@ -3241,11 +3269,11 @@ re_enable_breakpoints_in_shlibs ()
 
 static void
 create_solib_load_unload_event_breakpoint (hookname, tempflag, dll_pathname, cond_string, bp_kind)
-  char *  hookname;
-  int  tempflag;
-  char *  dll_pathname;
-  char *  cond_string;
-  enum bptype  bp_kind;
+     char *hookname;
+     int tempflag;
+     char *dll_pathname;
+     char *cond_string;
+     enum bptype bp_kind;
 {
   struct breakpoint *  b;
   struct symtabs_and_lines sals;
@@ -3351,9 +3379,9 @@ create_solib_unload_event_breakpoint (hookname, tempflag, dll_pathname, cond_str
 
 static void
 create_fork_vfork_event_catchpoint (tempflag, cond_string, bp_kind)
-  int  tempflag;
-  char *  cond_string;
-  enum bptype  bp_kind;
+     int tempflag;
+     char *cond_string;
+     enum bptype bp_kind;
 {
   struct symtab_and_line  sal;
   struct breakpoint *  b;
@@ -4092,7 +4120,7 @@ break_command (arg, from_tty)
   break_command_1 (arg, 0, from_tty);
 }
 
-void
+static void
 break_at_finish_command (arg, from_tty)
      char *arg;
      int from_tty;
@@ -4100,7 +4128,7 @@ break_at_finish_command (arg, from_tty)
   break_at_finish_command_1 (arg, 0, from_tty);
 }
 
-void
+static void
 break_at_finish_at_depth_command (arg, from_tty)
      char *arg;
      int from_tty;
@@ -4116,7 +4144,7 @@ tbreak_command (arg, from_tty)
   break_command_1 (arg, BP_TEMPFLAG, from_tty);
 }
 
-void
+static void
 tbreak_at_finish_command (arg, from_tty)
      char *arg;
      int from_tty;
@@ -4531,6 +4559,7 @@ struct sal_chain
   struct symtab_and_line sal;
 };
 
+#if 0
 /* Not really used -- invocation in handle_gnu_4_16_catch_command
    had been commented out in the v.4.16 sources, and stays
    disabled there now because "catch NAME" syntax isn't allowed.
@@ -4594,6 +4623,7 @@ map_catch_names (args, function)
       while (*p == ' ' || *p == '\t') p++;
     }
 }
+#endif
 
 /* This shares a lot of code with `print_frame_label_vars' from stack.c.  */
 
@@ -4711,7 +4741,7 @@ get_catch_sals (this_level_only)
 
 static void
 ep_skip_leading_whitespace (s)
-    char **  s;
+     char **s;
 {
    if ((s == NULL) || (*s == NULL))
        return;
@@ -4725,7 +4755,7 @@ ep_skip_leading_whitespace (s)
    the token is returned.  Else, NULL is returned. */
 static char *
 ep_find_event_name_end (arg)
-  char *  arg;
+     char *arg;
 {
   char *  s = arg;
   char *  event_name_end = NULL;
@@ -4758,7 +4788,7 @@ ep_find_event_name_end (arg)
    if clause in the arg string. */
 static char *
 ep_parse_optional_if_clause (arg)
-  char **  arg;
+     char **arg;
 {
   char *  cond_string;
  
@@ -4791,7 +4821,7 @@ ep_parse_optional_if_clause (arg)
    future access should copy it to their own buffers. */
 static char *
 ep_parse_optional_filename (arg)
-  char **  arg;
+     char **arg;
 {
   static char  filename [1024];
   char *  arg_p = *arg;
@@ -4821,12 +4851,14 @@ ep_parse_optional_filename (arg)
  
 typedef enum {catch_fork, catch_vfork} catch_fork_kind;
  
+static void catch_fork_command_1 PARAMS ((catch_fork_kind fork_kind, char *arg, int tempflag, int from_tty));
+
 static void
 catch_fork_command_1 (fork_kind, arg, tempflag, from_tty)
-  catch_fork_kind  fork_kind;
-  char *  arg;
-  int  tempflag;
-  int  from_tty;
+     catch_fork_kind fork_kind;
+     char *arg;
+     int tempflag;
+     int from_tty;
 {
   char *  cond_string = NULL;
  
@@ -4859,9 +4891,9 @@ catch_fork_command_1 (fork_kind, arg, tempflag, from_tty)
 
 static void
 catch_exec_command_1 (arg, tempflag, from_tty)
-  char *  arg;
-  int  tempflag;
-  int  from_tty;
+     char *arg;
+     int tempflag;
+     int from_tty;
 {
   char *  cond_string = NULL;
 
@@ -4979,10 +5011,10 @@ catch_unload_command_1 (arg, tempflag, from_tty)
 
 static void
 create_exception_catchpoint (tempflag, cond_string, ex_event, sal)
-  int tempflag;
-  char * cond_string;
-  enum exception_event_kind ex_event;
-  struct symtab_and_line * sal;
+     int tempflag;
+     char *cond_string;
+     enum exception_event_kind ex_event;
+     struct symtab_and_line *sal;
 {
   struct breakpoint *  b;
   int  i;
@@ -5020,10 +5052,10 @@ create_exception_catchpoint (tempflag, cond_string, ex_event, sal)
 
 static void
 catch_exception_command_1 (ex_event, arg, tempflag, from_tty)
-  enum exception_event_kind ex_event;
-  char *  arg;
-  int  tempflag;
-  int  from_tty;
+     enum exception_event_kind ex_event;
+     char *arg;
+     int tempflag;
+     int from_tty;
 {
   char * cond_string = NULL;
   struct symtab_and_line * sal = NULL;
@@ -6587,8 +6619,6 @@ are set to the address of the last breakpoint listed.\n\n\
 Convenience variable \"$bpnum\" contains the number of the last\n\
 breakpoint set.", NULL));
 
-#if MAINTENANCE_CMDS
-
   add_cmd ("breakpoints", class_maintenance, maintenance_info_breakpoints,
            concat ("Status of all breakpoints, or breakpoint number NUMBER.\n\
 The \"Type\" column indicates one of:\n\
@@ -6608,8 +6638,6 @@ Convenience variable \"$bpnum\" contains the number of the last\n\
 breakpoint set.", NULL),
           &maintenanceinfolist);
 
-#endif /* MAINTENANCE_CMDS */
-
   add_com ("catch", class_breakpoint, catch_command,
          "Set catchpoints to catch events.\n\
 Raised signals may be caught:\n\
index e2febaccca375d03999fe91e38fa9423bfe3f02e..8eec1f5759ee8b42585cb52bed4e19db2b855e96 100644 (file)
@@ -112,6 +112,7 @@ enum bptype {
      commands for C++ exception handling. */
   bp_catch_catch,
   bp_catch_throw
+
  
 };
 
index e15550309dc0c9fc73bc895248506c4328d33901..c0d0333eb6adabd36b3976cfb4281add185e7293 100644 (file)
@@ -913,7 +913,7 @@ c_type_print_base (type, stream, show, level)
                      char *p;
                      char *demangled_no_class = demangled_name;
                      
-                     while (p = strchr (demangled_no_class, ':'))
+                     while ((p = strchr (demangled_no_class, ':')))
                        {
                          demangled_no_class = p;
                          if (*++demangled_no_class == ':')
index 340e77f84c0bfbb00610879a70cc6285ee23d6a2..9c8f47540574194abd786b0c7d21a898e9a89733 100644 (file)
@@ -84,21 +84,6 @@ static CORE_ADDR current_source_end_addr;
 static bfd *nlist_bfd_global;
 static int nlist_nsyms_global;
 
-/* Vector of line number information.  */
-
-static struct linetable *line_vector;
-
-/* Index of next entry to go in line_vector_index.  */
-
-static int line_vector_index;
-
-/* Last line number recorded in the line vector.  */
-
-static int prev_line_number;
-
-/* Number of elements allocated for line_vector currently.  */
-
-static int line_vector_length;
 
 /* Pointers to scratch storage, used for reading raw symbols and auxents.  */
 
@@ -252,8 +237,6 @@ static void complete_symtab PARAMS ((char *, CORE_ADDR, unsigned int));
 
 static void coff_start_symtab PARAMS ((char *));
 
-static void coff_record_line PARAMS ((int, CORE_ADDR));
-
 static struct type *coff_alloc_type PARAMS ((int));
 
 static struct type **coff_lookup_type PARAMS ((int));
@@ -440,30 +423,6 @@ coff_alloc_type (index)
   return type;
 }
 \f
-/* Record a line number entry for line LINE at address PC.
-   FIXME:  Use record_line instead.  */
-
-static void
-coff_record_line (line, pc)
-     int line;
-     CORE_ADDR pc;
-{
-  struct linetable_entry *e;
-  /* Make sure line vector is big enough.  */
-
-  if (line_vector_index + 2 >= line_vector_length)
-    {
-      line_vector_length *= 2;
-      line_vector = (struct linetable *)
-       xrealloc ((char *) line_vector, sizeof (struct linetable)
-                 + (line_vector_length
-                    * sizeof (struct linetable_entry)));
-    }
-
-  e = line_vector->item + line_vector_index++;
-  e->line = line; e->pc = pc;
-}
-\f
 /* Start a new symtab for a new source file.
    This is called when a COFF ".file" symbol is seen;
    it indicates the start of data for one original source file.  */
@@ -484,17 +443,6 @@ coff_start_symtab (name)
                   last_source_start_addr in coff_end_symtab.  */
                0);
   record_debugformat ("COFF");
-
-  /* Initialize the source file line number information for this file.  */
-
-  if (line_vector)             /* Unlikely, but maybe possible? */
-    free ((PTR)line_vector);
-  line_vector_index = 0;
-  line_vector_length = 1000;
-  prev_line_number = -2;       /* Force first line number to be explicit */
-  line_vector = (struct linetable *)
-    xmalloc (sizeof (struct linetable)
-            + line_vector_length * sizeof (struct linetable_entry));
 }
 
 /* Save the vital information from when starting to read a file,
@@ -535,26 +483,12 @@ coff_end_symtab (objfile)
 
   last_source_start_addr = current_source_start_addr;
 
-  /* For no good reason, this file stores the number of entries in a
-     separate variable instead of in line_vector->nitems.  Fix it.  */
-  if (line_vector)
-    line_vector->nitems = line_vector_index;
-
-  /* For COFF, we only have one subfile, so we can just look at
-     subfiles and not worry about there being other elements in the
-     chain.  We fill in various fields now because we didn't know them
-     before (or because doing it now is simply an artifact of how this
-     file used to be written).  */
-  subfiles->line_vector = line_vector;
-
   symtab = end_symtab (current_source_end_addr, objfile, 0);
 
   if (symtab != NULL)
     free_named_symtabs (symtab->filename);
 
   /* Reinitialize for beginning of new file. */
-  line_vector = 0;
-  line_vector_length = -1;
   last_source_file = NULL;
 }
 \f
@@ -683,7 +617,6 @@ coff_symfile_read (objfile, section_offsets, mainline)
 
   /* Set a few file-statics that give us specific information about
      the particular COFF file format we're reading.  */
-  local_linesz   = cdata->local_linesz;
   local_n_btmask = cdata->local_n_btmask;
   local_n_btshft = cdata->local_n_btshft;
   local_n_tmask  = cdata->local_n_tmask;
@@ -1086,6 +1019,7 @@ coff_symtab_read (symtab_offset, nsyms, section_offsets, objfile)
                new->name =
                  process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved,
                                       section_offsets, objfile);
+               record_line (current_subfile, fcn_first_line, cs->c_value);
              }
            else if (STREQ (cs->c_name, ".ef"))
              {
@@ -1458,7 +1392,7 @@ enter_linenos (file_offset, first_line, last_line, section_offsets)
     rawptr += local_linesz;
     /* The next function, or the sentinel, will have L_LNNO32 zero; we exit. */
     if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
-      coff_record_line (first_line + L_LNNO32 (&lptr),
+      record_line (current_subfile, first_line + L_LNNO32 (&lptr),
                        lptr.l_addr.l_paddr
                        + ANOFFSET (section_offsets, SECT_OFF_TEXT));
     else
index d6bfe942126c6c6e62f5b409abf0981fa9fc6534..4d206a48a66045c8b31023bd40bef0d5f3163005 100644 (file)
    size_t, and assorted other type changes. */
 #undef PROC_SERVICE_IS_OLD
 
+/* If you want to specify a default CPU variant, define this to be its
+   name, as a C string.  */
+#undef TARGET_CPU_DEFAULT
+
+/* Define if the simulator is being linked in.  */
+#undef WITH_SIM
+
 /* Set to true if the save_state_t structure is present */
 #define HAVE_STRUCT_SAVE_STATE_T 0
 
 /* Define if you have the <sys/reg.h> header file.  */
 #undef HAVE_SYS_REG_H
 
+/* Define if you have the <sys/select.h> header file.  */
+#undef HAVE_SYS_SELECT_H
+
 /* Define if you have the <sys/wait.h> header file.  */
 #undef HAVE_SYS_WAIT_H
 
index 4892ec52cb45b3b1141b0cfd7e5875d1bbe243db..0936e837bea32558538b7e52306b708cb60e622a 100644 (file)
@@ -429,7 +429,7 @@ long read_register_stack_integer ();
 
 /* Because INIT_FRAME_PC gets passed fromleaf, that's where we init
    not only ->pc and ->frame, but all the extra stuff, when called from
-   get_prev_frame_info, that is.  */
+   get_prev_frame, that is.  */
 #define INIT_EXTRA_FRAME_INFO(fromleaf, fci)  init_extra_frame_info(fci)
 void init_extra_frame_info ();
 
@@ -506,7 +506,13 @@ extern CORE_ADDR frame_locals_address ();
 /* Provide our own get_saved_register.  HAVE_REGISTER_WINDOWS is insufficient
    because registers get renumbered on the a29k without getting saved.  */
 
-#define GET_SAVED_REGISTER
+#ifdef __STDC__
+enum lval_type;
+struct frame_info;
+#endif
+void a29k_get_saved_register PARAMS ((char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lvalp));
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+      a29k_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 \f
 /* Call function stuff.  */
 
index eedb1a93a370b0c6bb5935fc40ea4a83375f5907..1c167306422460d6d1034de4e27920263f9ec5a7 100644 (file)
@@ -15,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /* Figure out where the longjmp will land.  We expect that we have just entered
    longjmp and haven't yet setup the stack frame, so the args are still in the
index d9b98126bb2a06aa705c05a2d6ac35b47be2a25e..c07980981716582cb1d4c25168d7dc3317b63ac1 100644 (file)
@@ -110,7 +110,7 @@ alpha_saved_pc_after_call PARAMS ((struct frame_info *));
        "f0",   "f1",   "f2",   "f3",   "f4",   "f5",   "f6",   "f7", \
        "f8",   "f9",   "f10",  "f11",  "f12",  "f13",  "f14",  "f15", \
        "f16",  "f17",  "f18",  "f19",  "f20",  "f21",  "f22",  "f23",\
-       "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "f31",\
+       "f24",  "f25",  "f26",  "f27",  "f28",  "f29",  "f30",  "fpcr",\
        "pc",   "vfp",                                          \
     }
 
@@ -132,6 +132,7 @@ alpha_saved_pc_after_call PARAMS ((struct frame_info *));
 #define ZERO_REGNUM 31         /* Read-only register, always 0 */
 #define FP0_REGNUM 32           /* Floating point register 0 */
 #define FPA0_REGNUM 48          /* First float arg during a subr call */
+#define FPCR_REGNUM 63         /* Floating point control register */
 #define PC_REGNUM 64           /* Contains program counter */
 #define FP_REGNUM 65           /* Virtual frame pointer */
 
@@ -176,7 +177,7 @@ alpha_saved_pc_after_call PARAMS ((struct frame_info *));
       memory format is an integer with 4 bytes or less, as the representation
       of integers in floating point registers is different. */
 
-#define REGISTER_CONVERTIBLE(N) ((N) >= FP0_REGNUM && (N) < FP0_REGNUM + 32)
+#define REGISTER_CONVERTIBLE(N) ((N) >= FP0_REGNUM && (N) < FP0_REGNUM + 31)
 
 /* Convert data from raw format for register REGNUM in buffer FROM
    to virtual format with type TYPE in buffer TO.  */
@@ -198,7 +199,7 @@ alpha_register_convert_to_raw PARAMS ((struct type *, int, char *, char *));
    of data in register N.  */
 
 #define REGISTER_VIRTUAL_TYPE(N) \
-       (((N) >= FP0_REGNUM && (N) < FP0_REGNUM+32)  \
+       (((N) >= FP0_REGNUM && (N) < FP0_REGNUM+31)  \
         ? builtin_type_double : builtin_type_long) \
 
 /* Store the address of the place in which to copy the structure the
index a7aeab017070e346f99c728350f5baa76592a8f2..fb4316b44f5c37d028183e390aa0649dabf59477 100644 (file)
@@ -15,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #if !defined (HOST_BYTE_ORDER)
 #define HOST_BYTE_ORDER LITTLE_ENDIAN
index 40b7fe0a2049b88fce8f4e544446ec2d57a51a1a..e143538a23d84dd338282926c2498b73e4575e3b 100644 (file)
@@ -15,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #if !defined (HOST_BYTE_ORDER)
 #define HOST_BYTE_ORDER LITTLE_ENDIAN
index b327ac381f2b516ebd08d207f7ca0160a2fd7bf9..26bdf37fbe8abcbce430733d33ca0aba3aca20f3 100644 (file)
@@ -1,5 +1,5 @@
 /* Definitions to make GDB target for an ARM
-   Copyright 1986, 1987, 1989, 1991, 1993, 1997, 1998 Free Software Foundation, Inc.
+   Copyright 1986-1989, 1991, 1993-1999 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -268,7 +268,8 @@ extern use_struct_convention_fn arm_use_struct_convention;
    the address in which a function should return its structure value,
    as a CORE_ADDR (or an expression that can be used as one).  */
 
-#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF))
+#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
+  (extract_address ((PTR) (REGBUF), REGISTER_RAW_SIZE(0)))
 
 /* Specify that for the native compiler variables for a particular
    lexical context are listed after the beginning LBRAC instead of
index ef75bc5307f0963d077789043a73e6fe966db92b..edfa62fe7f540433c9912c21e76e76ae532c0111 100644 (file)
@@ -19,7 +19,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /* Contributed by Martin Hunt, hunt@cygnus.com */
 
-#define GDB_TARGET_IS_D10V
+/* #define GDB_TARGET_IS_D10V - moved to gdbarch.h */
 
 /* Define the bit, byte, and word ordering of the machine.  */
 
@@ -262,7 +262,7 @@ extern void d10v_frame_find_saved_regs PARAMS ((struct frame_info *, struct fram
 extern void d10v_pop_frame PARAMS ((struct frame_info *frame));
 #define POP_FRAME generic_pop_current_frame (d10v_pop_frame)
 
-#define USE_GENERIC_DUMMY_FRAMES
+#define USE_GENERIC_DUMMY_FRAMES 1
 #define CALL_DUMMY                   {0}
 #define CALL_DUMMY_START_OFFSET      (0)
 #define CALL_DUMMY_BREAKPOINT_OFFSET (0)
@@ -272,15 +272,15 @@ extern void d10v_pop_frame PARAMS ((struct frame_info *frame));
 extern CORE_ADDR d10v_push_return_address PARAMS ((CORE_ADDR pc, CORE_ADDR sp));
 #define PUSH_RETURN_ADDRESS(PC, SP)  d10v_push_return_address (PC, SP)
 
-#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP)
+#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
 /* #define PC_IN_CALL_DUMMY(pc, sp, frame_address) ( pc == IMEM_START + 4 ) */
 
 #define PUSH_DUMMY_FRAME       generic_push_dummy_frame ()
 
 /* override the default get_saved_register function with one that
    takes account of generic CALL_DUMMY frames */
-#define GET_SAVED_REGISTER
-#define get_saved_register generic_get_saved_register
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+       generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 
 #define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
     sp = d10v_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr))
index ea32792dcc440718c7b28a2338a7a0236c06c4a1..5478b93b1812600e56611ce81d32b7acdfb04bf5 100644 (file)
@@ -1,4 +1,5 @@
 /* Parameters for execution on a Fujitsu FR30 processor.
+   Copyright 1999, Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -95,7 +96,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 extern void fr30_pop_frame PARAMS ((void));
 #define POP_FRAME fr30_pop_frame()
 
-#define USE_GENERIC_DUMMY_FRAMES
+#define USE_GENERIC_DUMMY_FRAMES 1
 #define CALL_DUMMY                   {0}
 #define CALL_DUMMY_START_OFFSET      (0)
 #define CALL_DUMMY_BREAKPOINT_OFFSET (0)
@@ -129,7 +130,7 @@ extern void fr30_pop_frame PARAMS ((void));
 #define STORE_STRUCT_RETURN(ADDR, SP) \
   { write_register (RETVAL_REG, (ADDR)); }
 
-#define FRAME_ARGS_ADDRESS(fi) (fi->frame)
+#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)
 #define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
 
 /* Return number of args passed to a frame.
@@ -160,11 +161,14 @@ extern CORE_ADDR fr30_frame_saved_pc   PARAMS ((struct frame_info *));
 extern CORE_ADDR fr30_skip_prologue PARAMS ((CORE_ADDR pc));
 #define SKIP_PROLOGUE(pc) pc = fr30_skip_prologue (pc)
 
-/* Write into appropriate registers a function return value
-   of type TYPE, given in virtual format.  */
+/* Write into appropriate registers a function return value of type
+   TYPE, given in virtual format.  VALBUF is in the target byte order;
+   it's typically the VALUE_CONTENTS of some struct value, and those
+   are in the target's byte order.  */
+extern void fr30_store_return_value PARAMS ((struct type *type, char *valbuf));
 
 #define STORE_RETURN_VALUE(TYPE,VALBUF) \
-    write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE))
+  (fr30_store_return_value ((TYPE), (VALBUF)))
 
 /* Put here the code to store, into a struct frame_saved_regs,
    the addresses of the saved registers of frame described by FRAME_INFO.
@@ -211,7 +215,7 @@ fr30_push_arguments PARAMS ((int nargs, struct value **args, CORE_ADDR sp,
 #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) \
   (SP) = fr30_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR)
 
-#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP)
+#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
 
 /* Fujitsu's ABI requires all structs to be passed using a pointer.
    That is obviously not very efficient, so I am leaving the definitions
@@ -230,3 +234,12 @@ fr30_push_arguments PARAMS ((int nargs, struct value **args, CORE_ADDR sp,
 #endif
 /* alway return struct by value by input pointer */
 #define USE_STRUCT_CONVENTION(GCC_P, TYPE)     1
+
+/* The stack should always be aligned on a four-word boundary.  */
+#define STACK_ALIGN(len) (((len) + 3) & ~3)
+
+/* I think the comment about this in value_arg_coerce is wrong; this
+   should be true on any system where you can rely on the prototyping
+   information.  When this is true, value_arg_coerce will promote
+   floats to doubles iff the function is not prototyped.  */
+#define COERCE_FLOAT_TO_DOUBLE 1
index b398d2f0f9c654ec3832fb38024323ba423eba83..929d6ff74d98e060b6e71676a3dffe6565df444c 100644 (file)
@@ -271,7 +271,7 @@ typedef unsigned short INSN_WORD;
  * CALL_DUMMY stuff:
  */
 
-#define USE_GENERIC_DUMMY_FRAMES
+#define USE_GENERIC_DUMMY_FRAMES 1
 #define CALL_DUMMY                     {0}
 #define CALL_DUMMY_LENGTH              (0)
 #define CALL_DUMMY_ADDRESS()           entry_point_address ()
@@ -286,7 +286,7 @@ extern CORE_ADDR h8300_push_arguments PARAMS ((int nargs,
                                               CORE_ADDR struct_addr));
 extern CORE_ADDR h8300_push_return_address PARAMS ((CORE_ADDR, CORE_ADDR));
 
-#define PC_IN_CALL_DUMMY(PC, SP, FP)   generic_pc_in_call_dummy (PC, SP)
+#define PC_IN_CALL_DUMMY(PC, SP, FP)   generic_pc_in_call_dummy (PC, SP, FP)
 #define FIX_CALL_DUMMY(DUMMY, START_SP, FUNADDR, NARGS, ARGS, TYPE, GCCP)
 #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) \
   (SP) = h8300_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR)
@@ -298,6 +298,8 @@ extern CORE_ADDR h8300_push_return_address PARAMS ((CORE_ADDR, CORE_ADDR));
 
 /* override the standard get_saved_register function with 
    one that takes account of generic CALL_DUMMY frames */
-#define GET_SAVED_REGISTER
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+     generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
+
 
 
index 311ee1c272b591bc45555e28f9484026e5bf282d..d4fa352adc5fc7c7e671922e88acca2d5c59858f 100644 (file)
@@ -1,8 +1,19 @@
-MH_CFLAGS=-D__GO32__ -D__MSDOS__
-XDEPFILES= go32-xdep.o
+# Host: Intel x86 running DJGPP
+# we don't need mmalloc on DJGPP
+MH_CFLAGS= -DNO_MMALLOC
+MMALLOC=
+MMALLOC_CFLAGS=
+
 XM_FILE= xm-go32.h
-HOST_IPC=-DDOS_IPC
+XDEPFILES=
+
+NAT_FILE= nm-go32.h
+NATDEPFILES= go32-nat.o
+
+TERMCAP= 
+HOST_IPC=
 SER_HARDWIRE= ser-go32.o
-CC=i386-go32-gcc -O2 -fno-omit-frame-pointer
+CC= gcc
+XM_CLIBS= -ldbg
 
 
index 10e749ba1ff398397af2d8c2390aedf370d5670d..155336cb13c910d634560195b923c212a2accc21 100644 (file)
@@ -19,7 +19,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /* Basically, its a lot like the older versions ... */
 #include "i386/nm-i386sco.h"
index 9933e10a60f499ea352bfcdf9f6058b29494de4a..419993db2fe07b02cb5c995ca9b7246bbfad1541 100644 (file)
@@ -15,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "i386/tm-i386bsd.h"
 
index e2039e5fbfa316f7939f81d8ccffdb2b13af6124..aeff2e1f2636ff333e6f4df35dfe58f9751f56bd 100644 (file)
@@ -15,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #ifndef TM_I386_H
 #define TM_I386_H 1
index 0797833220777915a547d64198e51f30bd49508d..562d457924a47c8179c467003064fe109c7a00c5 100644 (file)
@@ -1,5 +1,5 @@
-/* Definitions for hosting on GO32, for GDB.
-   Copyright 1991, 1992 Free Software Foundation, Inc.
+/* Host-dependent definitions for Intel x86 running DJGPP.
+   Copyright 1993-1996 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -18,14 +18,20 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #define HOST_BYTE_ORDER LITTLE_ENDIAN
+
 #include "fopen-bin.h"
 
-/* Define this lseek(n) != nth byte of file */
-#define LSEEK_NOT_LINEAR
+#define GDBINIT_FILENAME "gdb.ini"
 
-#define CANT_FORK
+#define SLASH_P(X) ((X)=='\\' || (X) == '/')
 
-#undef QUIT
-#define QUIT  { pollquit(); }
+#define ROOTED_P(X) ((SLASH_P((X)[0]))|| ((X)[1] ==':'))
 
-#define GDBINIT_FILENAME "gdb.ini"
+#define SLASH_CHAR '/'
+#define SLASH_STRING "/"
+
+#define CRLF_SOURCE_FILES
+
+#define DIRNAME_SEPARATOR ';'
+
+#define HOST_I386
index 8273b4e7fde3f68b6571050e4de506895e8a1cef..e03558a75bf9ae831062a28f969706b16e7fbbe2 100644 (file)
@@ -193,7 +193,7 @@ extern use_struct_convention_fn m32r_use_struct_convention;
 /* generic dummy frame stuff */
 
 #define PUSH_DUMMY_FRAME             generic_push_dummy_frame ()
-#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP)
+#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
 
 
 /* target-specific dummy_frame stuff */
@@ -222,9 +222,11 @@ extern CORE_ADDR m32r_push_arguments PARAMS ((int nargs,
 
 /* override the standard get_saved_register function with 
    one that takes account of generic CALL_DUMMY frames */
-#define GET_SAVED_REGISTER
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+     generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 
-#define USE_GENERIC_DUMMY_FRAMES
+
+#define USE_GENERIC_DUMMY_FRAMES 1
 #define CALL_DUMMY                   {0}
 #define CALL_DUMMY_LENGTH            (0)
 #define CALL_DUMMY_START_OFFSET      (0)
index 671b53473fcc261b234dada47e405f81c54c0b49..e15cdae2b9169dbbd3e761c49a75e9ca64159a4a 100644 (file)
@@ -177,7 +177,7 @@ extern CORE_ADDR mn10200_skip_prologue PARAMS ((CORE_ADDR));
 extern void mn10200_pop_frame PARAMS ((struct frame_info *));
 #define POP_FRAME mn10200_pop_frame (get_current_frame ())
 
-#define USE_GENERIC_DUMMY_FRAMES
+#define USE_GENERIC_DUMMY_FRAMES 1
 #define CALL_DUMMY                   {0}
 #define CALL_DUMMY_START_OFFSET      (0)
 #define CALL_DUMMY_BREAKPOINT_OFFSET (0)
@@ -196,7 +196,7 @@ mn10200_push_arguments PARAMS ((int, struct value **, CORE_ADDR,
 #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) \
   (SP) = mn10200_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR)
 
-#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP)
+#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
 
 #define REG_STRUCT_HAS_ADDR(gcc_p,TYPE) \
        (TYPE_LENGTH (TYPE) > 8)
@@ -206,7 +206,8 @@ extern use_struct_convention_fn mn10200_use_struct_convention;
 
 /* Override the default get_saved_register function with
    one that takes account of generic CALL_DUMMY frames.  */
-#define GET_SAVED_REGISTER
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+      generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 
 /* Define this for Wingdb */
 #define TARGET_MN10200
index e7d3fd7f96ebd82660a9f90d50dd5c598f8d0891..f0736427fcae3de01a92dee54c696c40f2ce9c79 100644 (file)
@@ -124,7 +124,7 @@ extern CORE_ADDR mn10300_skip_prologue PARAMS ((CORE_ADDR));
 extern void mn10300_pop_frame PARAMS ((struct frame_info *));
 #define POP_FRAME mn10300_pop_frame (get_current_frame ())
 
-#define USE_GENERIC_DUMMY_FRAMES
+#define USE_GENERIC_DUMMY_FRAMES 1
 #define CALL_DUMMY                   {0}
 #define CALL_DUMMY_START_OFFSET      (0)
 #define CALL_DUMMY_BREAKPOINT_OFFSET (0)
@@ -143,7 +143,7 @@ mn10300_push_arguments PARAMS ((int, struct value **, CORE_ADDR,
 #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) \
   (SP) = mn10300_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR)
 
-#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP)
+#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
 
 #define REG_STRUCT_HAS_ADDR(gcc_p,TYPE) \
        (TYPE_LENGTH (TYPE) > 8)
@@ -153,7 +153,8 @@ extern use_struct_convention_fn mn10300_use_struct_convention;
 
 /* override the default get_saved_register function with
    one that takes account of generic CALL_DUMMY frames */
-#define GET_SAVED_REGISTER
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+    generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 
 /* Cons up virtual frame pointer for trace */
 extern void mn10300_virtual_frame_pointer PARAMS ((CORE_ADDR, long *, long *));
index b7ee4dc769bc0f5c6aa166f19c794be444b0b19d..38a85f7accfcf5a6b0a1d5af2c60954b4e2f1eb6 100644 (file)
@@ -16,7 +16,7 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
 #ifndef __NM_GNU_H__
 #define __NM_GNU_H__
@@ -40,6 +40,4 @@ extern char *gnu_target_pid_to_str (int pid);
 #include "solib.h"
 #define NO_CORE_OPS
 
-#define MAINTENANCE_CMDS 1
-
 #endif /* __NM_GNU_H__ */
index 0f5ef018bad770709da68d80b6de135d91ec837d..5883c1b745185332ccb1f5245fb5f89348b5cc87 100644 (file)
@@ -279,3 +279,10 @@ extern char *hpux_pid_to_str PARAMS ((int pid));
 #endif /* HAVE_HPUX_THREAD_SUPPORT */
 
 #define HPUXHPPA
+
+#define MAY_SWITCH_FROM_INFERIOR_PID (1)
+
+#define MAY_FOLLOW_EXEC (1)
+
+#define USE_THREAD_STEP_NEEDED (1)
+
index 559534a050c632a5fbdf9f7314402dec47abaf4a..e5b5acd90652818d1dd21160b96ea7eae3844318 100644 (file)
@@ -469,7 +469,7 @@ hppa_frame_find_saved_regs PARAMS ((struct frame_info *,
 
 /* Push an empty stack frame, to record the current PC, etc. */
 
-#define PUSH_DUMMY_FRAME push_dummy_frame (&inf_status)
+#define PUSH_DUMMY_FRAME push_dummy_frame (inf_status)
 extern void push_dummy_frame PARAMS ((struct inferior_status *));
 
 /* Discard from the stack the innermost frame, 
index 9661d50f668e99ac43b15d9fd3122ceebadb3dc4..c771e8c1288dc5c8f2e4de3fd63c626038c31a75 100644 (file)
@@ -15,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "rs6000/nm-rs6000.h"
 
index b29d285b4ab5c16bae4c14b8d9b5610a834983bf..d32d0de1cd835cf61f3e4b0f1b4a47ed70f7fb1c 100644 (file)
@@ -15,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /* Use generic RS6000 definitions. */
 #include "rs6000/tm-rs6000.h"
index 5dfb3c4764441f5492a29d6f145936e9c9c7eb4a..521b9afa349e8e8a19cb154b77b504635bd8c2ab 100644 (file)
@@ -15,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #ifndef TM_PPC_AIX_H
 #define TM_PPC_AIX_H
index c2828b29b68fbd35c028436e0d5caa9f33fe6e5a..cd0ec32ed6f811bc81b057c04a16ccbf67021054 100644 (file)
@@ -46,8 +46,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 /* FIXME: This just checks for the end of the stack, which is broken
    for things like stepping through gcc nested function stubs.  */
 #undef PC_IN_CALL_DUMMY
-#define        PC_IN_CALL_DUMMY(STOP_PC, STOP_SP, STOP_FRAME_ADDR)     \
-       (STOP_SP < STOP_PC)
 
 /* generic dummy frame stuff */
 
@@ -71,9 +69,10 @@ extern CORE_ADDR rs6000_push_arguments PARAMS ((int nargs,
 
 /* override the standard get_saved_register function with 
    one that takes account of generic CALL_DUMMY frames */
-#define GET_SAVED_REGISTER
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+      generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 
-#define USE_GENERIC_DUMMY_FRAMES
+#define USE_GENERIC_DUMMY_FRAMES 1
 #define CALL_DUMMY_BREAKPOINT_OFFSET (0)
 #define CALL_DUMMY_LOCATION          AT_ENTRY_POINT
 #define CALL_DUMMY_ADDRESS()         entry_point_address ()
index efd0e7424b392a69ff215d564131c4bfbada2ec0..e616d9ee6fd50f739edaaa31e61e58d02ec2912f 100644 (file)
@@ -16,7 +16,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "xm-aix4.h"
 
index f65eae3868186a5c744e3e9cf2c5e81e8d0133f5..c7889e4ceb8e0f871bcd324a6d454d4ccfca863b 100644 (file)
@@ -15,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #ifndef TM_RS6000_AIX4_H
 #define TM_RS6000_AIX4_H
index 21779094f65576700a6fef026dbc70e47d1d8660..291677b71c05812a2f039cef0e741fceaf0e852e 100644 (file)
@@ -239,7 +239,7 @@ extern CORE_ADDR sh_push_arguments PARAMS ((int nargs,
                                            unsigned char struct_return,
                                            CORE_ADDR struct_addr));
 
-#define USE_GENERIC_DUMMY_FRAMES
+#define USE_GENERIC_DUMMY_FRAMES 1
 #define CALL_DUMMY                   {0}
 #define CALL_DUMMY_LENGTH            (0)
 #define CALL_DUMMY_START_OFFSET      (0)
@@ -255,13 +255,14 @@ extern CORE_ADDR sh_frame_chain PARAMS ((struct frame_info *));
 #define FRAME_CHAIN(FRAME)           sh_frame_chain(FRAME)
 #define PUSH_DUMMY_FRAME             generic_push_dummy_frame ()
 #define FRAME_CHAIN_VALID(FP, FRAME) generic_frame_chain_valid (FP, FRAME)
-#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP)
+#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
 #define PUSH_ARGUMENTS(NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR) \
     (SP) = sh_push_arguments (NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR)
 
 /* override the standard get_saved_register function with 
    one that takes account of generic CALL_DUMMY frames */
-#define GET_SAVED_REGISTER
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+     generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 
 /* Discard from the stack the innermost frame, restoring all saved
    registers.  */
index ecbe9e2285d97fc6d9590f1bc802227106aae7d1..6d565081063d2fd355fb3826727f84bc206e5782 100644 (file)
@@ -206,7 +206,13 @@ extern CORE_ADDR sparc_pc_adjust PARAMS ((CORE_ADDR));
    outs change into ins in different frames.  HAVE_REGISTER_WINDOWS can't
    deal with this case and also handle flat frames at the same time.  */
 
-#define GET_SAVED_REGISTER 1
+#ifdef __STDC__
+struct frame_info;
+enum lval_type;
+#endif
+void sparc_get_saved_register PARAMS ((char *raw_buffer, int *optimized, CORE_ADDR *addrp, struct frame_info *frame, int regnum, enum lval_type *lvalp));
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+      sparc_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 
 /* Number of bytes of storage in the actual machine representation
    for register N.  */
index 14dd7f09cedbf700a9d9dd2b8bc3b20fead51bc9..287ff86880769d9b4a3dafbcd533e02accba01c4 100644 (file)
@@ -137,7 +137,7 @@ extern CORE_ADDR v850_skip_prologue PARAMS ((CORE_ADDR pc));
 extern void v850_pop_frame PARAMS ((struct frame_info *frame));
 #define POP_FRAME v850_pop_frame (get_current_frame ())
 
-#define USE_GENERIC_DUMMY_FRAMES
+#define USE_GENERIC_DUMMY_FRAMES 1
 #define CALL_DUMMY                   {0}
 #define CALL_DUMMY_START_OFFSET      (0)
 #define CALL_DUMMY_BREAKPOINT_OFFSET (0)
@@ -160,14 +160,15 @@ v850_push_arguments PARAMS ((int nargs, struct value **args, CORE_ADDR sp,
 #define STORE_STRUCT_RETURN(STRUCT_ADDR, SP)
 
 
-#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP)
+#define PC_IN_CALL_DUMMY(PC, SP, FP) generic_pc_in_call_dummy (PC, SP, FP)
 
 extern use_struct_convention_fn v850_use_struct_convention;
 #define USE_STRUCT_CONVENTION(GCC_P, TYPE) v850_use_struct_convention (GCC_P, TYPE);
 
 /* override the default get_saved_register function with
    one that takes account of generic CALL_DUMMY frames */
-#define GET_SAVED_REGISTER
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+      generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 
 /* Define this for Wingdb */
 
index f70d0465af3ede10e9dfcf775d8cbcd8616e1149..8d392703ecc21c3ed2d4cbba2e2fe6a76e217497 100755 (executable)
@@ -23,8 +23,40 @@ ac_help="$ac_help
   --enable-build-warnings Enable build-time compiler warnings if gcc is used"
 ac_help="$ac_help
   --with-mmalloc          Use memory mapped malloc package"
+ac_help="$ac_help
+  --enable-carp           Configure alternative readaptive paradigm "
+ac_help="$ac_help
+  --enable-targets        Alternative target configurations"
+ac_help="$ac_help
+  --enable-ide            Enable IDE support"
+ac_help="$ac_help
+  --with-foundry-libs=DIR Use the Foundry SDK in DIR"
+ac_help="$ac_help
+  --with-cpu=CPU          Set the default CPU variant to debug"
+ac_help="$ac_help
+  --enable-gdbtk          Enable GDBTK GUI front end"
+ac_help="$ac_help
+  --with-tclconfig=DIR    Directory containing tcl configuration (tclConfig.sh)"
+ac_help="$ac_help
+  --with-tkconfig=DIR     Directory containing tk configuration (tkConfig.sh)"
+ac_help="$ac_help
+  --with-tclinclude=DIR   Directory where tcl private headers are"
+ac_help="$ac_help
+  --with-tkinclude=DIR    Directory where tk private headers are"
+ac_help="$ac_help
+  --with-itclconfig       Directory containing itcl configuration (itclConfig.sh)"
+ac_help="$ac_help
+  --with-itkconfig        Directory containing itk configuration (itkConfig.sh)"
+ac_help="$ac_help
+  --with-tixconfig        Directory containing tix configuration (tixConfig.sh)"
 ac_help="$ac_help
   --with-x                use the X Window System"
+ac_help="$ac_help
+  --with-sim-gpu2=DIR     Use GPU2 library under given DIR"
+ac_help="$ac_help
+  --with-sim-funit=DIR    Use target FP lib under given DIR"
+ac_help="$ac_help
+  --enable-sim            Link gdb with simulator"
 ac_help="$ac_help
   --enable-shared         Use shared libraries"
 
@@ -542,7 +574,7 @@ fi
 # Extract the first word of "gcc", so it can be a program name with args.
 set dummy gcc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:546: checking for $ac_word" >&5
+echo "configure:578: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -572,7 +604,7 @@ if test -z "$CC"; then
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:576: checking for $ac_word" >&5
+echo "configure:608: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -623,7 +655,7 @@ fi
       # Extract the first word of "cl", so it can be a program name with args.
 set dummy cl; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:627: checking for $ac_word" >&5
+echo "configure:659: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -655,7 +687,7 @@ fi
 fi
 
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
-echo "configure:659: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+echo "configure:691: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
 
 ac_ext=c
 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
@@ -666,12 +698,12 @@ cross_compiling=$ac_cv_prog_cc_cross
 
 cat > conftest.$ac_ext << EOF
 
-#line 670 "configure"
+#line 702 "configure"
 #include "confdefs.h"
 
 main(){return(0);}
 EOF
-if { (eval echo configure:675: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:707: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   ac_cv_prog_cc_works=yes
   # If we can't run a trivial program, we are probably using a cross compiler.
   if (./conftest; exit) 2>/dev/null; then
@@ -697,12 +729,12 @@ if test $ac_cv_prog_cc_works = no; then
   { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
 fi
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
-echo "configure:701: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "configure:733: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
 echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
 cross_compiling=$ac_cv_prog_cc_cross
 
 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:706: checking whether we are using GNU C" >&5
+echo "configure:738: checking whether we are using GNU C" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -711,7 +743,7 @@ else
   yes;
 #endif
 EOF
-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:715: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:747: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
   ac_cv_prog_gcc=yes
 else
   ac_cv_prog_gcc=no
@@ -730,7 +762,7 @@ ac_test_CFLAGS="${CFLAGS+set}"
 ac_save_CFLAGS="$CFLAGS"
 CFLAGS=
 echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
-echo "configure:734: checking whether ${CC-cc} accepts -g" >&5
+echo "configure:766: checking whether ${CC-cc} accepts -g" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -762,7 +794,7 @@ else
 fi
 
 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
-echo "configure:766: checking how to run the C preprocessor" >&5
+echo "configure:798: checking how to run the C preprocessor" >&5
 # On Suns, sometimes $CPP names a directory.
 if test -n "$CPP" && test -d "$CPP"; then
   CPP=
@@ -777,13 +809,13 @@ else
   # On the NeXT, cc -E runs the code through the compiler's parser,
   # not just through cpp.
   cat > conftest.$ac_ext <<EOF
-#line 781 "configure"
+#line 813 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:787: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:819: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -794,13 +826,13 @@ else
   rm -rf conftest*
   CPP="${CC-cc} -E -traditional-cpp"
   cat > conftest.$ac_ext <<EOF
-#line 798 "configure"
+#line 830 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:804: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:836: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -811,13 +843,13 @@ else
   rm -rf conftest*
   CPP="${CC-cc} -nologo -E"
   cat > conftest.$ac_ext <<EOF
-#line 815 "configure"
+#line 847 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:821: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:853: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -842,9 +874,9 @@ fi
 echo "$ac_t""$CPP" 1>&6
 
 echo $ac_n "checking for AIX""... $ac_c" 1>&6
-echo "configure:846: checking for AIX" >&5
+echo "configure:878: checking for AIX" >&5
 cat > conftest.$ac_ext <<EOF
-#line 848 "configure"
+#line 880 "configure"
 #include "confdefs.h"
 #ifdef _AIX
   yes
@@ -866,7 +898,7 @@ rm -f conftest*
 
 
 echo $ac_n "checking for POSIXized ISC""... $ac_c" 1>&6
-echo "configure:870: checking for POSIXized ISC" >&5
+echo "configure:902: checking for POSIXized ISC" >&5
 if test -d /etc/conf/kconfig.d &&
   grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1
 then
@@ -890,7 +922,7 @@ fi
 
 
 echo $ac_n "checking for ${CC-cc} option to accept ANSI C""... $ac_c" 1>&6
-echo "configure:894: checking for ${CC-cc} option to accept ANSI C" >&5
+echo "configure:926: checking for ${CC-cc} option to accept ANSI C" >&5
 if eval "test \"`echo '$''{'am_cv_prog_cc_stdc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -906,7 +938,7 @@ for ac_arg in "" -qlanglvl=ansi -std1 "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__
 do
   CC="$ac_save_CC $ac_arg"
   cat > conftest.$ac_ext <<EOF
-#line 910 "configure"
+#line 942 "configure"
 #include "confdefs.h"
 #include <stdarg.h>
 #include <stdio.h>
@@ -943,7 +975,7 @@ return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
 
 ; return 0; }
 EOF
-if { (eval echo configure:947: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:979: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   am_cv_prog_cc_stdc="$ac_arg"; break
 else
@@ -1014,7 +1046,7 @@ else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 fi
 
 echo $ac_n "checking host system type""... $ac_c" 1>&6
-echo "configure:1018: checking host system type" >&5
+echo "configure:1050: checking host system type" >&5
 
 host_alias=$host
 case "$host_alias" in
@@ -1035,7 +1067,7 @@ host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$host" 1>&6
 
 echo $ac_n "checking target system type""... $ac_c" 1>&6
-echo "configure:1039: checking target system type" >&5
+echo "configure:1071: checking target system type" >&5
 
 target_alias=$target
 case "$target_alias" in
@@ -1053,7 +1085,7 @@ target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$target" 1>&6
 
 echo $ac_n "checking build system type""... $ac_c" 1>&6
-echo "configure:1057: checking build system type" >&5
+echo "configure:1089: checking build system type" >&5
 
 build_alias=$build
 case "$build_alias" in
@@ -1078,7 +1110,7 @@ test "$host_alias" != "$target_alias" &&
 
 ALL_LINGUAS=
 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
-echo "configure:1082: checking whether ${MAKE-make} sets \${MAKE}" >&5
+echo "configure:1114: checking whether ${MAKE-make} sets \${MAKE}" >&5
 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1107,7 +1139,7 @@ fi
 # Extract the first word of "ranlib", so it can be a program name with args.
 set dummy ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1111: checking for $ac_word" >&5
+echo "configure:1143: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1135,12 +1167,12 @@ else
 fi
 
 echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6
-echo "configure:1139: checking for ANSI C header files" >&5
+echo "configure:1171: checking for ANSI C header files" >&5
 if eval "test \"`echo '$''{'ac_cv_header_stdc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1144 "configure"
+#line 1176 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 #include <stdarg.h>
@@ -1148,7 +1180,7 @@ else
 #include <float.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:1152: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:1184: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -1165,7 +1197,7 @@ rm -f conftest*
 if test $ac_cv_header_stdc = yes; then
   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 1169 "configure"
+#line 1201 "configure"
 #include "confdefs.h"
 #include <string.h>
 EOF
@@ -1183,7 +1215,7 @@ fi
 if test $ac_cv_header_stdc = yes; then
   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 1187 "configure"
+#line 1219 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 EOF
@@ -1204,7 +1236,7 @@ if test "$cross_compiling" = yes; then
   :
 else
   cat > conftest.$ac_ext <<EOF
-#line 1208 "configure"
+#line 1240 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
@@ -1215,7 +1247,7 @@ if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2);
 exit (0); }
 
 EOF
-if { (eval echo configure:1219: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:1251: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   :
 else
@@ -1239,12 +1271,12 @@ EOF
 fi
 
 echo $ac_n "checking for working const""... $ac_c" 1>&6
-echo "configure:1243: checking for working const" >&5
+echo "configure:1275: checking for working const" >&5
 if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1248 "configure"
+#line 1280 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -1293,7 +1325,7 @@ ccp = (char const *const *) p;
 
 ; return 0; }
 EOF
-if { (eval echo configure:1297: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:1329: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_const=yes
 else
@@ -1314,21 +1346,21 @@ EOF
 fi
 
 echo $ac_n "checking for inline""... $ac_c" 1>&6
-echo "configure:1318: checking for inline" >&5
+echo "configure:1350: checking for inline" >&5
 if eval "test \"`echo '$''{'ac_cv_c_inline'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   ac_cv_c_inline=no
 for ac_kw in inline __inline__ __inline; do
   cat > conftest.$ac_ext <<EOF
-#line 1325 "configure"
+#line 1357 "configure"
 #include "confdefs.h"
 
 int main() {
 } $ac_kw foo() {
 ; return 0; }
 EOF
-if { (eval echo configure:1332: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:1364: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_inline=$ac_kw; break
 else
@@ -1354,12 +1386,12 @@ EOF
 esac
 
 echo $ac_n "checking for off_t""... $ac_c" 1>&6
-echo "configure:1358: checking for off_t" >&5
+echo "configure:1390: checking for off_t" >&5
 if eval "test \"`echo '$''{'ac_cv_type_off_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1363 "configure"
+#line 1395 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -1387,12 +1419,12 @@ EOF
 fi
 
 echo $ac_n "checking for size_t""... $ac_c" 1>&6
-echo "configure:1391: checking for size_t" >&5
+echo "configure:1423: checking for size_t" >&5
 if eval "test \"`echo '$''{'ac_cv_type_size_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1396 "configure"
+#line 1428 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -1422,19 +1454,19 @@ fi
 # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
 # for constant arguments.  Useless!
 echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6
-echo "configure:1426: checking for working alloca.h" >&5
+echo "configure:1458: checking for working alloca.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_alloca_h'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1431 "configure"
+#line 1463 "configure"
 #include "confdefs.h"
 #include <alloca.h>
 int main() {
 char *p = alloca(2 * sizeof(int));
 ; return 0; }
 EOF
-if { (eval echo configure:1438: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1470: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_header_alloca_h=yes
 else
@@ -1455,12 +1487,12 @@ EOF
 fi
 
 echo $ac_n "checking for alloca""... $ac_c" 1>&6
-echo "configure:1459: checking for alloca" >&5
+echo "configure:1491: checking for alloca" >&5
 if eval "test \"`echo '$''{'ac_cv_func_alloca_works'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1464 "configure"
+#line 1496 "configure"
 #include "confdefs.h"
 
 #ifdef __GNUC__
@@ -1488,7 +1520,7 @@ int main() {
 char *p = (char *) alloca(1);
 ; return 0; }
 EOF
-if { (eval echo configure:1492: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1524: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_func_alloca_works=yes
 else
@@ -1520,12 +1552,12 @@ EOF
 
 
 echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6
-echo "configure:1524: checking whether alloca needs Cray hooks" >&5
+echo "configure:1556: checking whether alloca needs Cray hooks" >&5
 if eval "test \"`echo '$''{'ac_cv_os_cray'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1529 "configure"
+#line 1561 "configure"
 #include "confdefs.h"
 #if defined(CRAY) && ! defined(CRAY2)
 webecray
@@ -1550,12 +1582,12 @@ echo "$ac_t""$ac_cv_os_cray" 1>&6
 if test $ac_cv_os_cray = yes; then
 for ac_func in _getb67 GETB67 getb67; do
   echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:1554: checking for $ac_func" >&5
+echo "configure:1586: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1559 "configure"
+#line 1591 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -1578,7 +1610,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:1582: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1614: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -1605,7 +1637,7 @@ done
 fi
 
 echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6
-echo "configure:1609: checking stack direction for C alloca" >&5
+echo "configure:1641: checking stack direction for C alloca" >&5
 if eval "test \"`echo '$''{'ac_cv_c_stack_direction'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1613,7 +1645,7 @@ else
   ac_cv_c_stack_direction=0
 else
   cat > conftest.$ac_ext <<EOF
-#line 1617 "configure"
+#line 1649 "configure"
 #include "confdefs.h"
 find_stack_direction ()
 {
@@ -1632,7 +1664,7 @@ main ()
   exit (find_stack_direction() < 0);
 }
 EOF
-if { (eval echo configure:1636: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:1668: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_c_stack_direction=1
 else
@@ -1657,17 +1689,17 @@ for ac_hdr in unistd.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:1661: checking for $ac_hdr" >&5
+echo "configure:1693: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1666 "configure"
+#line 1698 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:1671: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:1703: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -1696,12 +1728,12 @@ done
 for ac_func in getpagesize
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:1700: checking for $ac_func" >&5
+echo "configure:1732: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1705 "configure"
+#line 1737 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -1724,7 +1756,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:1728: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1760: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -1749,7 +1781,7 @@ fi
 done
 
 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
-echo "configure:1753: checking for working mmap" >&5
+echo "configure:1785: checking for working mmap" >&5
 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1757,7 +1789,7 @@ else
   ac_cv_func_mmap_fixed_mapped=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 1761 "configure"
+#line 1793 "configure"
 #include "confdefs.h"
 
 /* Thanks to Mike Haertel and Jim Avera for this test.
@@ -1897,7 +1929,7 @@ main()
 }
 
 EOF
-if { (eval echo configure:1901: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:1933: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_func_mmap_fixed_mapped=yes
 else
@@ -1925,17 +1957,17 @@ unistd.h values.h sys/param.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:1929: checking for $ac_hdr" >&5
+echo "configure:1961: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1934 "configure"
+#line 1966 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:1939: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:1971: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -1965,12 +1997,12 @@ done
 __argz_count __argz_stringify __argz_next
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:1969: checking for $ac_func" >&5
+echo "configure:2001: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1974 "configure"
+#line 2006 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -1993,7 +2025,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:1997: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2029: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -2022,12 +2054,12 @@ done
      for ac_func in stpcpy
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2026: checking for $ac_func" >&5
+echo "configure:2058: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2031 "configure"
+#line 2063 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -2050,7 +2082,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2054: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2086: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -2084,19 +2116,19 @@ EOF
 
    if test $ac_cv_header_locale_h = yes; then
     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
-echo "configure:2088: checking for LC_MESSAGES" >&5
+echo "configure:2120: checking for LC_MESSAGES" >&5
 if eval "test \"`echo '$''{'am_cv_val_LC_MESSAGES'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2093 "configure"
+#line 2125 "configure"
 #include "confdefs.h"
 #include <locale.h>
 int main() {
 return LC_MESSAGES
 ; return 0; }
 EOF
-if { (eval echo configure:2100: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2132: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   am_cv_val_LC_MESSAGES=yes
 else
@@ -2117,7 +2149,7 @@ EOF
     fi
   fi
    echo $ac_n "checking whether NLS is requested""... $ac_c" 1>&6
-echo "configure:2121: checking whether NLS is requested" >&5
+echo "configure:2153: checking whether NLS is requested" >&5
         # Check whether --enable-nls or --disable-nls was given.
 if test "${enable_nls+set}" = set; then
   enableval="$enable_nls"
@@ -2137,7 +2169,7 @@ fi
 EOF
 
       echo $ac_n "checking whether included gettext is requested""... $ac_c" 1>&6
-echo "configure:2141: checking whether included gettext is requested" >&5
+echo "configure:2173: checking whether included gettext is requested" >&5
       # Check whether --with-included-gettext or --without-included-gettext was given.
 if test "${with_included_gettext+set}" = set; then
   withval="$with_included_gettext"
@@ -2156,17 +2188,17 @@ fi
 
        ac_safe=`echo "libintl.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for libintl.h""... $ac_c" 1>&6
-echo "configure:2160: checking for libintl.h" >&5
+echo "configure:2192: checking for libintl.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2165 "configure"
+#line 2197 "configure"
 #include "confdefs.h"
 #include <libintl.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2170: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2202: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2183,19 +2215,19 @@ fi
 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
   echo "$ac_t""yes" 1>&6
   echo $ac_n "checking for gettext in libc""... $ac_c" 1>&6
-echo "configure:2187: checking for gettext in libc" >&5
+echo "configure:2219: checking for gettext in libc" >&5
 if eval "test \"`echo '$''{'gt_cv_func_gettext_libc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2192 "configure"
+#line 2224 "configure"
 #include "confdefs.h"
 #include <libintl.h>
 int main() {
 return (int) gettext ("")
 ; return 0; }
 EOF
-if { (eval echo configure:2199: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2231: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   gt_cv_func_gettext_libc=yes
 else
@@ -2211,7 +2243,7 @@ echo "$ac_t""$gt_cv_func_gettext_libc" 1>&6
 
           if test "$gt_cv_func_gettext_libc" != "yes"; then
             echo $ac_n "checking for bindtextdomain in -lintl""... $ac_c" 1>&6
-echo "configure:2215: checking for bindtextdomain in -lintl" >&5
+echo "configure:2247: checking for bindtextdomain in -lintl" >&5
 ac_lib_var=`echo intl'_'bindtextdomain | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2219,7 +2251,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lintl  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 2223 "configure"
+#line 2255 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -2230,7 +2262,7 @@ int main() {
 bindtextdomain()
 ; return 0; }
 EOF
-if { (eval echo configure:2234: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2266: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -2246,19 +2278,19 @@ fi
 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
   echo "$ac_t""yes" 1>&6
   echo $ac_n "checking for gettext in libintl""... $ac_c" 1>&6
-echo "configure:2250: checking for gettext in libintl" >&5
+echo "configure:2282: checking for gettext in libintl" >&5
 if eval "test \"`echo '$''{'gt_cv_func_gettext_libintl'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2255 "configure"
+#line 2287 "configure"
 #include "confdefs.h"
 
 int main() {
 return (int) gettext ("")
 ; return 0; }
 EOF
-if { (eval echo configure:2262: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2294: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   gt_cv_func_gettext_libintl=yes
 else
@@ -2286,7 +2318,7 @@ EOF
              # Extract the first word of "msgfmt", so it can be a program name with args.
 set dummy msgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2290: checking for $ac_word" >&5
+echo "configure:2322: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2320,12 +2352,12 @@ fi
                for ac_func in dcgettext
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2324: checking for $ac_func" >&5
+echo "configure:2356: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2329 "configure"
+#line 2361 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -2348,7 +2380,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2352: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2384: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -2375,7 +2407,7 @@ done
                # Extract the first word of "gmsgfmt", so it can be a program name with args.
 set dummy gmsgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2379: checking for $ac_word" >&5
+echo "configure:2411: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2411,7 +2443,7 @@ fi
                # Extract the first word of "xgettext", so it can be a program name with args.
 set dummy xgettext; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2415: checking for $ac_word" >&5
+echo "configure:2447: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2443,7 +2475,7 @@ else
 fi
 
                cat > conftest.$ac_ext <<EOF
-#line 2447 "configure"
+#line 2479 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -2451,7 +2483,7 @@ extern int _nl_msg_cat_cntr;
                               return _nl_msg_cat_cntr
 ; return 0; }
 EOF
-if { (eval echo configure:2455: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2487: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   CATOBJEXT=.gmo
                   DATADIRNAME=share
@@ -2483,7 +2515,7 @@ fi
         # Extract the first word of "msgfmt", so it can be a program name with args.
 set dummy msgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2487: checking for $ac_word" >&5
+echo "configure:2519: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2517,7 +2549,7 @@ fi
         # Extract the first word of "gmsgfmt", so it can be a program name with args.
 set dummy gmsgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2521: checking for $ac_word" >&5
+echo "configure:2553: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2553,7 +2585,7 @@ fi
         # Extract the first word of "xgettext", so it can be a program name with args.
 set dummy xgettext; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2557: checking for $ac_word" >&5
+echo "configure:2589: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2643,7 +2675,7 @@ fi
        LINGUAS=
      else
        echo $ac_n "checking for catalogs to be installed""... $ac_c" 1>&6
-echo "configure:2647: checking for catalogs to be installed" >&5
+echo "configure:2679: checking for catalogs to be installed" >&5
        NEW_LINGUAS=
        for lang in ${LINGUAS=$ALL_LINGUAS}; do
          case "$ALL_LINGUAS" in
@@ -2671,17 +2703,17 @@ echo "configure:2647: checking for catalogs to be installed" >&5
       if test "$CATOBJEXT" = ".cat"; then
         ac_safe=`echo "linux/version.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for linux/version.h""... $ac_c" 1>&6
-echo "configure:2675: checking for linux/version.h" >&5
+echo "configure:2707: checking for linux/version.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2680 "configure"
+#line 2712 "configure"
 #include "confdefs.h"
 #include <linux/version.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2685: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2717: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2756,6 +2788,40 @@ configdirs="doc testsuite"
 . ${srcdir}/configure.tgt
 
 
+for ac_prog in mawk gawk nawk awk
+do
+# Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
+echo "configure:2797: checking for $ac_word" >&5
+if eval "test \"`echo '$''{'ac_cv_prog_AWK'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+  IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
+    test -z "$ac_dir" && ac_dir=.
+    if test -f $ac_dir/$ac_word; then
+      ac_cv_prog_AWK="$ac_prog"
+      break
+    fi
+  done
+  IFS="$ac_save_ifs"
+fi
+fi
+AWK="$ac_cv_prog_AWK"
+if test -n "$AWK"; then
+  echo "$ac_t""$AWK" 1>&6
+else
+  echo "$ac_t""no" 1>&6
+fi
+
+test -n "$AWK" && break
+done
+
 # Find a good install program.  We prefer a C program (faster),
 # so one script is as good as another.  But avoid the broken or
 # incompatible versions:
@@ -2768,7 +2834,7 @@ configdirs="doc testsuite"
 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 # ./install, which can be erroneously created by make from ./install.sh.
 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
-echo "configure:2772: checking for a BSD compatible install" >&5
+echo "configure:2838: checking for a BSD compatible install" >&5
 if test -z "$INSTALL"; then
 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2829,7 +2895,7 @@ fi
 # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
 set dummy ${ac_tool_prefix}ar; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2833: checking for $ac_word" >&5
+echo "configure:2899: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2861,7 +2927,7 @@ fi
 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2865: checking for $ac_word" >&5
+echo "configure:2931: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2893,7 +2959,7 @@ if test -n "$ac_tool_prefix"; then
   # Extract the first word of "ranlib", so it can be a program name with args.
 set dummy ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2897: checking for $ac_word" >&5
+echo "configure:2963: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2930,7 +2996,7 @@ do
 # Extract the first word of "$ac_prog", so it can be a program name with args.
 set dummy $ac_prog; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2934: checking for $ac_word" >&5
+echo "configure:3000: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_YACC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2982,12 +3048,12 @@ test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 
 
 echo $ac_n "checking return type of signal handlers""... $ac_c" 1>&6
-echo "configure:2986: checking return type of signal handlers" >&5
+echo "configure:3052: checking return type of signal handlers" >&5
 if eval "test \"`echo '$''{'ac_cv_type_signal'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2991 "configure"
+#line 3057 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <signal.h>
@@ -3004,7 +3070,7 @@ int main() {
 int i;
 ; return 0; }
 EOF
-if { (eval echo configure:3008: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3074: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_type_signal=void
 else
@@ -3024,12 +3090,12 @@ EOF
 
 
 echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6
-echo "configure:3028: checking for ANSI C header files" >&5
+echo "configure:3094: checking for ANSI C header files" >&5
 if eval "test \"`echo '$''{'ac_cv_header_stdc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3033 "configure"
+#line 3099 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 #include <stdarg.h>
@@ -3037,7 +3103,7 @@ else
 #include <float.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3041: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:3107: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3054,7 +3120,7 @@ rm -f conftest*
 if test $ac_cv_header_stdc = yes; then
   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 3058 "configure"
+#line 3124 "configure"
 #include "confdefs.h"
 #include <string.h>
 EOF
@@ -3072,7 +3138,7 @@ fi
 if test $ac_cv_header_stdc = yes; then
   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 3076 "configure"
+#line 3142 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 EOF
@@ -3093,7 +3159,7 @@ if test "$cross_compiling" = yes; then
   :
 else
   cat > conftest.$ac_ext <<EOF
-#line 3097 "configure"
+#line 3163 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
@@ -3104,7 +3170,7 @@ if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2);
 exit (0); }
 
 EOF
-if { (eval echo configure:3108: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:3174: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   :
 else
@@ -3132,21 +3198,21 @@ for ac_hdr in ctype.h curses.h endian.h link.h \
        memory.h objlist.h ptrace.h sgtty.h stddef.h stdlib.h \
        string.h sys/procfs.h sys/ptrace.h sys/reg.h \
        term.h termio.h termios.h unistd.h wait.h sys/wait.h \
-       wchar.h wctype.h asm/debugreg.h sys/debugreg.h
+       wchar.h wctype.h asm/debugreg.h sys/debugreg.h sys/select.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:3140: checking for $ac_hdr" >&5
+echo "configure:3206: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3145 "configure"
+#line 3211 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3150: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:3216: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3173,12 +3239,12 @@ fi
 done
 
 echo $ac_n "checking whether stat file-mode macros are broken""... $ac_c" 1>&6
-echo "configure:3177: checking whether stat file-mode macros are broken" >&5
+echo "configure:3243: checking whether stat file-mode macros are broken" >&5
 if eval "test \"`echo '$''{'ac_cv_header_stat_broken'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3182 "configure"
+#line 3248 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -3230,12 +3296,12 @@ fi
 
 
 echo $ac_n "checking for working const""... $ac_c" 1>&6
-echo "configure:3234: checking for working const" >&5
+echo "configure:3300: checking for working const" >&5
 if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3239 "configure"
+#line 3305 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -3284,7 +3350,7 @@ ccp = (char const *const *) p;
 
 ; return 0; }
 EOF
-if { (eval echo configure:3288: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3354: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_const=yes
 else
@@ -3308,12 +3374,12 @@ fi
 for ac_func in setpgid sbrk sigaction isascii bzero bcopy btowc
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3312: checking for $ac_func" >&5
+echo "configure:3378: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3317 "configure"
+#line 3383 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3336,7 +3402,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3340: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3406: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3363,19 +3429,19 @@ done
 # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
 # for constant arguments.  Useless!
 echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6
-echo "configure:3367: checking for working alloca.h" >&5
+echo "configure:3433: checking for working alloca.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_alloca_h'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3372 "configure"
+#line 3438 "configure"
 #include "confdefs.h"
 #include <alloca.h>
 int main() {
 char *p = alloca(2 * sizeof(int));
 ; return 0; }
 EOF
-if { (eval echo configure:3379: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3445: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_header_alloca_h=yes
 else
@@ -3396,12 +3462,12 @@ EOF
 fi
 
 echo $ac_n "checking for alloca""... $ac_c" 1>&6
-echo "configure:3400: checking for alloca" >&5
+echo "configure:3466: checking for alloca" >&5
 if eval "test \"`echo '$''{'ac_cv_func_alloca_works'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3405 "configure"
+#line 3471 "configure"
 #include "confdefs.h"
 
 #ifdef __GNUC__
@@ -3429,7 +3495,7 @@ int main() {
 char *p = (char *) alloca(1);
 ; return 0; }
 EOF
-if { (eval echo configure:3433: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3499: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_func_alloca_works=yes
 else
@@ -3461,12 +3527,12 @@ EOF
 
 
 echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6
-echo "configure:3465: checking whether alloca needs Cray hooks" >&5
+echo "configure:3531: checking whether alloca needs Cray hooks" >&5
 if eval "test \"`echo '$''{'ac_cv_os_cray'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3470 "configure"
+#line 3536 "configure"
 #include "confdefs.h"
 #if defined(CRAY) && ! defined(CRAY2)
 webecray
@@ -3491,12 +3557,12 @@ echo "$ac_t""$ac_cv_os_cray" 1>&6
 if test $ac_cv_os_cray = yes; then
 for ac_func in _getb67 GETB67 getb67; do
   echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3495: checking for $ac_func" >&5
+echo "configure:3561: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3500 "configure"
+#line 3566 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3519,7 +3585,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3523: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3589: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3546,7 +3612,7 @@ done
 fi
 
 echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6
-echo "configure:3550: checking stack direction for C alloca" >&5
+echo "configure:3616: checking stack direction for C alloca" >&5
 if eval "test \"`echo '$''{'ac_cv_c_stack_direction'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -3554,7 +3620,7 @@ else
   ac_cv_c_stack_direction=0
 else
   cat > conftest.$ac_ext <<EOF
-#line 3558 "configure"
+#line 3624 "configure"
 #include "confdefs.h"
 find_stack_direction ()
 {
@@ -3573,7 +3639,7 @@ main ()
   exit (find_stack_direction() < 0);
 }
 EOF
-if { (eval echo configure:3577: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:3643: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_c_stack_direction=1
 else
@@ -3596,12 +3662,12 @@ fi
 
 
 echo $ac_n "checking whether malloc must be declared""... $ac_c" 1>&6
-echo "configure:3600: checking whether malloc must be declared" >&5
+echo "configure:3666: checking whether malloc must be declared" >&5
 if eval "test \"`echo '$''{'bfd_cv_decl_needed_malloc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3605 "configure"
+#line 3671 "configure"
 #include "confdefs.h"
 
 #include <stdio.h>
@@ -3622,7 +3688,7 @@ int main() {
 char *(*pfn) = (char *(*)) malloc
 ; return 0; }
 EOF
-if { (eval echo configure:3626: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3692: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   bfd_cv_decl_needed_malloc=no
 else
@@ -3643,12 +3709,12 @@ EOF
 fi
 
 echo $ac_n "checking whether realloc must be declared""... $ac_c" 1>&6
-echo "configure:3647: checking whether realloc must be declared" >&5
+echo "configure:3713: checking whether realloc must be declared" >&5
 if eval "test \"`echo '$''{'bfd_cv_decl_needed_realloc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3652 "configure"
+#line 3718 "configure"
 #include "confdefs.h"
 
 #include <stdio.h>
@@ -3669,7 +3735,7 @@ int main() {
 char *(*pfn) = (char *(*)) realloc
 ; return 0; }
 EOF
-if { (eval echo configure:3673: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3739: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   bfd_cv_decl_needed_realloc=no
 else
@@ -3690,12 +3756,12 @@ EOF
 fi
 
 echo $ac_n "checking whether free must be declared""... $ac_c" 1>&6
-echo "configure:3694: checking whether free must be declared" >&5
+echo "configure:3760: checking whether free must be declared" >&5
 if eval "test \"`echo '$''{'bfd_cv_decl_needed_free'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3699 "configure"
+#line 3765 "configure"
 #include "confdefs.h"
 
 #include <stdio.h>
@@ -3716,7 +3782,7 @@ int main() {
 char *(*pfn) = (char *(*)) free
 ; return 0; }
 EOF
-if { (eval echo configure:3720: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3786: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   bfd_cv_decl_needed_free=no
 else
@@ -3737,12 +3803,12 @@ EOF
 fi
 
 echo $ac_n "checking whether strerror must be declared""... $ac_c" 1>&6
-echo "configure:3741: checking whether strerror must be declared" >&5
+echo "configure:3807: checking whether strerror must be declared" >&5
 if eval "test \"`echo '$''{'bfd_cv_decl_needed_strerror'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3746 "configure"
+#line 3812 "configure"
 #include "confdefs.h"
 
 #include <stdio.h>
@@ -3763,7 +3829,7 @@ int main() {
 char *(*pfn) = (char *(*)) strerror
 ; return 0; }
 EOF
-if { (eval echo configure:3767: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3833: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   bfd_cv_decl_needed_strerror=no
 else
@@ -3784,12 +3850,12 @@ EOF
 fi
 
 echo $ac_n "checking whether strdup must be declared""... $ac_c" 1>&6
-echo "configure:3788: checking whether strdup must be declared" >&5
+echo "configure:3854: checking whether strdup must be declared" >&5
 if eval "test \"`echo '$''{'bfd_cv_decl_needed_strdup'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3793 "configure"
+#line 3859 "configure"
 #include "confdefs.h"
 
 #include <stdio.h>
@@ -3810,7 +3876,7 @@ int main() {
 char *(*pfn) = (char *(*)) strdup
 ; return 0; }
 EOF
-if { (eval echo configure:3814: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3880: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   bfd_cv_decl_needed_strdup=no
 else
@@ -3837,9 +3903,9 @@ fi
 # could be expunged. --jsm 1999-03-22
 
 echo $ac_n "checking for HPUX save_state structure""... $ac_c" 1>&6
-echo "configure:3841: checking for HPUX save_state structure" >&5
+echo "configure:3907: checking for HPUX save_state structure" >&5
 cat > conftest.$ac_ext <<EOF
-#line 3843 "configure"
+#line 3909 "configure"
 #include "confdefs.h"
 #include <machine/save_state.h>
 EOF
@@ -3854,7 +3920,7 @@ fi
 rm -f conftest*
 
 cat > conftest.$ac_ext <<EOF
-#line 3858 "configure"
+#line 3924 "configure"
 #include "confdefs.h"
 #include <machine/save_state.h>
 EOF
@@ -3890,6 +3956,7 @@ echo "$ac_t""$gdb_cv_hpux_sswide" 1>&6
 # Also detect which type of /proc is in use, such as for Unixware.
 
 if test "${target}" = "${host}"; then
+  gdb_cv_hostos_is_solaris=no
   case "${host}" in
   i[3456]86-*-linux*)
        cat >> confdefs.h <<\EOF
@@ -3901,12 +3968,15 @@ EOF
 EOF
 
        ;;
+  *-*-solaris*)
+       gdb_cv_hostos_is_solaris=yes ;;
   esac
   echo $ac_n "checking for directory proc entries""... $ac_c" 1>&6
-echo "configure:3907: checking for directory proc entries" >&5
+echo "configure:3976: checking for directory proc entries" >&5
 # The [gdb_host != sun4sol2] hack is because Solaris does provide the
 # multiple procfs files as of Solaris 2.6, but GDB can't use it right now.
-  if test "$ac_cv_header_sys_procfs_h" = yes -a "$gdb_host" != sun4sol2 \
+  if test "$ac_cv_header_sys_procfs_h" = yes -a \
+          "$gdb_cv_hostos_is_solaris" = no \
   -a -d /proc/$$ \
   -a -f /proc/$$/ctl \
   -a -f /proc/$$/as \
@@ -3924,19 +3994,19 @@ fi
 
 if test "$ac_cv_header_sys_procfs_h" = yes; then
   echo $ac_n "checking for pstatus_t in sys/procfs.h""... $ac_c" 1>&6
-echo "configure:3928: checking for pstatus_t in sys/procfs.h" >&5
+echo "configure:3998: checking for pstatus_t in sys/procfs.h" >&5
  if eval "test \"`echo '$''{'bfd_cv_have_sys_procfs_type_pstatus_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3933 "configure"
+#line 4003 "configure"
 #include "confdefs.h"
 #include <sys/procfs.h>
 int main() {
 pstatus_t avar
 ; return 0; }
 EOF
-if { (eval echo configure:3940: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4010: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   bfd_cv_have_sys_procfs_type_pstatus_t=yes
 else
@@ -3958,19 +4028,19 @@ EOF
  echo "$ac_t""$bfd_cv_have_sys_procfs_type_pstatus_t" 1>&6
 
   echo $ac_n "checking for prrun_t in sys/procfs.h""... $ac_c" 1>&6
-echo "configure:3962: checking for prrun_t in sys/procfs.h" >&5
+echo "configure:4032: checking for prrun_t in sys/procfs.h" >&5
  if eval "test \"`echo '$''{'bfd_cv_have_sys_procfs_type_prrun_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3967 "configure"
+#line 4037 "configure"
 #include "confdefs.h"
 #include <sys/procfs.h>
 int main() {
 prrun_t avar
 ; return 0; }
 EOF
-if { (eval echo configure:3974: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4044: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   bfd_cv_have_sys_procfs_type_prrun_t=yes
 else
@@ -3992,19 +4062,19 @@ EOF
  echo "$ac_t""$bfd_cv_have_sys_procfs_type_prrun_t" 1>&6
 
   echo $ac_n "checking for gregset_t in sys/procfs.h""... $ac_c" 1>&6
-echo "configure:3996: checking for gregset_t in sys/procfs.h" >&5
+echo "configure:4066: checking for gregset_t in sys/procfs.h" >&5
  if eval "test \"`echo '$''{'bfd_cv_have_sys_procfs_type_gregset_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 4001 "configure"
+#line 4071 "configure"
 #include "confdefs.h"
 #include <sys/procfs.h>
 int main() {
 gregset_t avar
 ; return 0; }
 EOF
-if { (eval echo configure:4008: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4078: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   bfd_cv_have_sys_procfs_type_gregset_t=yes
 else
@@ -4026,19 +4096,19 @@ EOF
  echo "$ac_t""$bfd_cv_have_sys_procfs_type_gregset_t" 1>&6
 
   echo $ac_n "checking for fpregset_t in sys/procfs.h""... $ac_c" 1>&6
-echo "configure:4030: checking for fpregset_t in sys/procfs.h" >&5
+echo "configure:4100: checking for fpregset_t in sys/procfs.h" >&5
  if eval "test \"`echo '$''{'bfd_cv_have_sys_procfs_type_fpregset_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 4035 "configure"
+#line 4105 "configure"
 #include "confdefs.h"
 #include <sys/procfs.h>
 int main() {
 fpregset_t avar
 ; return 0; }
 EOF
-if { (eval echo configure:4042: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4112: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   bfd_cv_have_sys_procfs_type_fpregset_t=yes
 else
@@ -4062,12 +4132,12 @@ EOF
 
   
   echo $ac_n "checking for PIOCSET ioctl entry in sys/procfs.h""... $ac_c" 1>&6
-echo "configure:4066: checking for PIOCSET ioctl entry in sys/procfs.h" >&5
+echo "configure:4136: checking for PIOCSET ioctl entry in sys/procfs.h" >&5
   if eval "test \"`echo '$''{'gdb_cv_have_procfs_piocset'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 4071 "configure"
+#line 4141 "configure"
 #include "confdefs.h"
 #include <unistd.h>
 #include <sys/types.h>
@@ -4080,7 +4150,7 @@ int main() {
   
 ; return 0; }
 EOF
-if { (eval echo configure:4084: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4154: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   gdb_cv_have_procfs_piocset=yes
 else
@@ -4102,7 +4172,7 @@ EOF
 fi
 
 echo $ac_n "checking for main in -lm""... $ac_c" 1>&6
-echo "configure:4106: checking for main in -lm" >&5
+echo "configure:4176: checking for main in -lm" >&5
 ac_lib_var=`echo m'_'main | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -4110,14 +4180,14 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lm  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 4114 "configure"
+#line 4184 "configure"
 #include "confdefs.h"
 
 int main() {
 main()
 ; return 0; }
 EOF
-if { (eval echo configure:4121: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4191: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -4146,7 +4216,7 @@ fi
 
 
 echo $ac_n "checking for wctype in -lc""... $ac_c" 1>&6
-echo "configure:4150: checking for wctype in -lc" >&5
+echo "configure:4220: checking for wctype in -lc" >&5
 ac_lib_var=`echo c'_'wctype | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -4154,7 +4224,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lc  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 4158 "configure"
+#line 4228 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -4165,7 +4235,7 @@ int main() {
 wctype()
 ; return 0; }
 EOF
-if { (eval echo configure:4169: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4239: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -4184,7 +4254,7 @@ if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for wctype in -lw""... $ac_c" 1>&6
-echo "configure:4188: checking for wctype in -lw" >&5
+echo "configure:4258: checking for wctype in -lw" >&5
 ac_lib_var=`echo w'_'wctype | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -4192,7 +4262,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lw  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 4196 "configure"
+#line 4266 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -4203,7 +4273,7 @@ int main() {
 wctype()
 ; return 0; }
 EOF
-if { (eval echo configure:4207: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4277: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -4235,12 +4305,12 @@ fi
 
 
 echo $ac_n "checking for long long support in compiler""... $ac_c" 1>&6
-echo "configure:4239: checking for long long support in compiler" >&5
+echo "configure:4309: checking for long long support in compiler" >&5
 if eval "test \"`echo '$''{'gdb_cv_c_long_long'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 4244 "configure"
+#line 4314 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -4250,7 +4320,7 @@ int main() {
 
 ; return 0; }
 EOF
-if { (eval echo configure:4254: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4324: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   gdb_cv_c_long_long=yes
 else
@@ -4272,7 +4342,7 @@ fi
 
 
 echo $ac_n "checking for long long support in printf""... $ac_c" 1>&6
-echo "configure:4276: checking for long long support in printf" >&5
+echo "configure:4346: checking for long long support in printf" >&5
 if eval "test \"`echo '$''{'gdb_cv_printf_has_long_long'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -4280,7 +4350,7 @@ else
   gdb_cv_printf_has_long_long=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 4284 "configure"
+#line 4354 "configure"
 #include "confdefs.h"
 
 int main () {
@@ -4294,7 +4364,7 @@ int main () {
   return (strcmp ("0x0123456789abcdef", buf));
 }
 EOF
-if { (eval echo configure:4298: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:4368: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   gdb_cv_printf_has_long_long=yes
 else
@@ -4318,19 +4388,19 @@ echo "$ac_t""$gdb_cv_printf_has_long_long" 1>&6
 
 
 echo $ac_n "checking for long double support in compiler""... $ac_c" 1>&6
-echo "configure:4322: checking for long double support in compiler" >&5
+echo "configure:4392: checking for long double support in compiler" >&5
 if eval "test \"`echo '$''{'ac_cv_c_long_double'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 4327 "configure"
+#line 4397 "configure"
 #include "confdefs.h"
 
 int main() {
 long double foo;
 ; return 0; }
 EOF
-if { (eval echo configure:4334: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4404: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_long_double=yes
 else
@@ -4352,7 +4422,7 @@ fi
 
 
 echo $ac_n "checking for long double support in printf""... $ac_c" 1>&6
-echo "configure:4356: checking for long double support in printf" >&5
+echo "configure:4426: checking for long double support in printf" >&5
 if eval "test \"`echo '$''{'gdb_cv_printf_has_long_double'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -4360,7 +4430,7 @@ else
   gdb_cv_printf_has_long_double=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 4364 "configure"
+#line 4434 "configure"
 #include "confdefs.h"
 
 int main () {
@@ -4370,7 +4440,7 @@ int main () {
   return (strncmp ("3.14159", buf, 7));
 }
 EOF
-if { (eval echo configure:4374: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:4444: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   gdb_cv_printf_has_long_double=yes
 else
@@ -4394,7 +4464,7 @@ echo "$ac_t""$gdb_cv_printf_has_long_double" 1>&6
 
 
 echo $ac_n "checking for long double support in scanf""... $ac_c" 1>&6
-echo "configure:4398: checking for long double support in scanf" >&5
+echo "configure:4468: checking for long double support in scanf" >&5
 if eval "test \"`echo '$''{'gdb_cv_scanf_has_long_double'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -4402,7 +4472,7 @@ else
   gdb_cv_scanf_has_long_double=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 4406 "configure"
+#line 4476 "configure"
 #include "confdefs.h"
 
 int main () {
@@ -4412,7 +4482,7 @@ int main () {
   return !(f > 3.14159 && f < 3.14160);
 }
 EOF
-if { (eval echo configure:4416: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:4486: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   gdb_cv_scanf_has_long_double=yes
 else
@@ -4438,17 +4508,17 @@ for ac_hdr in unistd.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:4442: checking for $ac_hdr" >&5
+echo "configure:4512: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 4447 "configure"
+#line 4517 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:4452: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:4522: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -4477,12 +4547,12 @@ done
 for ac_func in getpagesize
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:4481: checking for $ac_func" >&5
+echo "configure:4551: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 4486 "configure"
+#line 4556 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -4505,7 +4575,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:4509: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4579: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -4530,7 +4600,7 @@ fi
 done
 
 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
-echo "configure:4534: checking for working mmap" >&5
+echo "configure:4604: checking for working mmap" >&5
 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -4538,7 +4608,7 @@ else
   ac_cv_func_mmap_fixed_mapped=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 4542 "configure"
+#line 4612 "configure"
 #include "confdefs.h"
 
 /* Thanks to Mike Haertel and Jim Avera for this test.
@@ -4678,7 +4748,7 @@ main()
 }
 
 EOF
-if { (eval echo configure:4682: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:4752: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_func_mmap_fixed_mapped=yes
 else
@@ -4707,7 +4777,7 @@ if test ${build} = ${host} -a ${host} = ${target} ; then
    case ${host_os} in
    hpux*)
       echo $ac_n "checking for HPUX/OSF thread support""... $ac_c" 1>&6
-echo "configure:4711: checking for HPUX/OSF thread support" >&5
+echo "configure:4781: checking for HPUX/OSF thread support" >&5
       if test -f /usr/include/dce/cma_config.h ; then
          if test "$GCC" = "yes" ; then
             echo "$ac_t""yes" 1>&6
@@ -4726,7 +4796,7 @@ EOF
       ;;
    solaris*)
       echo $ac_n "checking for Solaris thread debugging library""... $ac_c" 1>&6
-echo "configure:4730: checking for Solaris thread debugging library" >&5
+echo "configure:4800: checking for Solaris thread debugging library" >&5
       if test -f /usr/lib/libthread_db.so.1 ; then
          echo "$ac_t""yes" 1>&6
          cat >> confdefs.h <<\EOF
@@ -4736,7 +4806,7 @@ EOF
          CONFIG_OBS="${CONFIG_OBS} sol-thread.o"
          CONFIG_SRCS="${CONFIG_SRCS} sol-thread.c"
          echo $ac_n "checking for dlopen in -ldl""... $ac_c" 1>&6
-echo "configure:4740: checking for dlopen in -ldl" >&5
+echo "configure:4810: checking for dlopen in -ldl" >&5
 ac_lib_var=`echo dl'_'dlopen | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -4744,7 +4814,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-ldl  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 4748 "configure"
+#line 4818 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -4755,7 +4825,7 @@ int main() {
 dlopen()
 ; return 0; }
 EOF
-if { (eval echo configure:4759: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4829: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -4787,17 +4857,17 @@ fi
             # all symbols visible in the dynamic symbol table.
             hold_ldflags=$LDFLAGS
             echo $ac_n "checking for the ld -export-dynamic flag""... $ac_c" 1>&6
-echo "configure:4791: checking for the ld -export-dynamic flag" >&5
+echo "configure:4861: checking for the ld -export-dynamic flag" >&5
             LDFLAGS="${LDFLAGS} -Wl,-export-dynamic"
             cat > conftest.$ac_ext <<EOF
-#line 4794 "configure"
+#line 4864 "configure"
 #include "confdefs.h"
 
 int main() {
 int i;
 ; return 0; }
 EOF
-if { (eval echo configure:4801: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4871: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   found=yes
 else
@@ -4816,13 +4886,13 @@ rm -f conftest*
         # Sun randomly tweaked the prototypes in <proc_service.h>
         # at one point.
         echo $ac_n "checking if <proc_service.h> is old""... $ac_c" 1>&6
-echo "configure:4820: checking if <proc_service.h> is old" >&5
+echo "configure:4890: checking if <proc_service.h> is old" >&5
         if eval "test \"`echo '$''{'gdb_cv_proc_service_is_old'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   
            cat > conftest.$ac_ext <<EOF
-#line 4826 "configure"
+#line 4896 "configure"
 #include "confdefs.h"
 
                #include <proc_service.h>
@@ -4833,7 +4903,7 @@ int main() {
 
 ; return 0; }
 EOF
-if { (eval echo configure:4837: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:4907: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   gdb_cv_proc_service_is_old=no
 else
@@ -4965,12 +5035,46 @@ EOF
    MMALLOC='../mmalloc/libmmalloc.a'
 fi
 
+
+# In the Cygwin environment, we need some additional flags.
+echo $ac_n "checking for cygwin""... $ac_c" 1>&6
+echo "configure:5165: checking for cygwin" >&5
+if eval "test \"`echo '$''{'gdb_cv_os_cygwin'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 5170 "configure"
+#include "confdefs.h"
+
+#if defined (__CYGWIN__) || defined (__CYGWIN32__)
+lose
+#endif
+EOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  egrep "lose" >/dev/null 2>&1; then
+  rm -rf conftest*
+  gdb_cv_os_cygwin=yes
+else
+  rm -rf conftest*
+  gdb_cv_os_cygwin=no
+fi
+rm -f conftest*
+
+fi
+
+echo "$ac_t""$gdb_cv_os_cygwin" 1>&6
+
+DLLTOOL=${DLLTOOL-dlltool}
+WINDRES=${WINDRES-windres}
+
+
+
 if test x$gdb_cv_os_cygwin = xyes; then
   TERM_LIB='`if test -r ../libtermcap/libtermcap.a; then echo ../libtermcap/libtermcap.a; else echo -ltermcap; fi`'
 else
   TERM_LIB=
   echo $ac_n "checking for tgetent in -lncurses""... $ac_c" 1>&6
-echo "configure:4974: checking for tgetent in -lncurses" >&5
+echo "configure:5201: checking for tgetent in -lncurses" >&5
 ac_lib_var=`echo ncurses'_'tgetent | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -4978,7 +5082,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lncurses  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 4982 "configure"
+#line 5209 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -4989,7 +5093,7 @@ int main() {
 tgetent()
 ; return 0; }
 EOF
-if { (eval echo configure:4993: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5220: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5008,7 +5112,7 @@ if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for tgetent in -lHcurses""... $ac_c" 1>&6
-echo "configure:5012: checking for tgetent in -lHcurses" >&5
+echo "configure:5239: checking for tgetent in -lHcurses" >&5
 ac_lib_var=`echo Hcurses'_'tgetent | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -5016,7 +5120,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lHcurses  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 5020 "configure"
+#line 5247 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -5027,7 +5131,7 @@ int main() {
 tgetent()
 ; return 0; }
 EOF
-if { (eval echo configure:5031: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5258: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5046,7 +5150,7 @@ if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for tgetent in -ltermlib""... $ac_c" 1>&6
-echo "configure:5050: checking for tgetent in -ltermlib" >&5
+echo "configure:5277: checking for tgetent in -ltermlib" >&5
 ac_lib_var=`echo termlib'_'tgetent | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -5054,7 +5158,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-ltermlib  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 5058 "configure"
+#line 5285 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -5065,7 +5169,7 @@ int main() {
 tgetent()
 ; return 0; }
 EOF
-if { (eval echo configure:5069: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5296: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5084,7 +5188,7 @@ if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for tgetent in -ltermcap""... $ac_c" 1>&6
-echo "configure:5088: checking for tgetent in -ltermcap" >&5
+echo "configure:5315: checking for tgetent in -ltermcap" >&5
 ac_lib_var=`echo termcap'_'tgetent | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -5092,7 +5196,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-ltermcap  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 5096 "configure"
+#line 5323 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -5103,7 +5207,7 @@ int main() {
 tgetent()
 ; return 0; }
 EOF
-if { (eval echo configure:5107: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5334: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5122,7 +5226,7 @@ if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for tgetent in -lcurses""... $ac_c" 1>&6
-echo "configure:5126: checking for tgetent in -lcurses" >&5
+echo "configure:5353: checking for tgetent in -lcurses" >&5
 ac_lib_var=`echo curses'_'tgetent | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -5130,7 +5234,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lcurses  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 5134 "configure"
+#line 5361 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -5141,7 +5245,7 @@ int main() {
 tgetent()
 ; return 0; }
 EOF
-if { (eval echo configure:5145: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5372: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5160,7 +5264,7 @@ if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
 else
   echo "$ac_t""no" 1>&6
 echo $ac_n "checking for tgetent in -lterminfo""... $ac_c" 1>&6
-echo "configure:5164: checking for tgetent in -lterminfo" >&5
+echo "configure:5391: checking for tgetent in -lterminfo" >&5
 ac_lib_var=`echo terminfo'_'tgetent | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -5168,7 +5272,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lterminfo  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 5172 "configure"
+#line 5399 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -5179,7 +5283,7 @@ int main() {
 tgetent()
 ; return 0; }
 EOF
-if { (eval echo configure:5183: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5410: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -5218,12 +5322,14 @@ fi
 
 
 
+
+
 # If we find X, set shell vars x_includes and x_libraries to the
 # paths, otherwise set no_x=yes.
 # Uses ac_ vars as temps to allow command line to override cache and checks.
 # --without-x overrides everything else, but does not touch the cache.
 echo $ac_n "checking for X""... $ac_c" 1>&6
-echo "configure:5227: checking for X" >&5
+echo "configure:6542: checking for X" >&5
 
 # Check whether --with-x or --without-x was given.
 if test "${with_x+set}" = set; then
@@ -5285,12 +5391,12 @@ if test "$ac_x_includes" = NO; then
 
   # First, try using that file with no special directory specified.
 cat > conftest.$ac_ext <<EOF
-#line 5289 "configure"
+#line 6604 "configure"
 #include "confdefs.h"
 #include <$x_direct_test_include>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:5294: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:6609: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -5359,14 +5465,14 @@ if test "$ac_x_libraries" = NO; then
   ac_save_LIBS="$LIBS"
   LIBS="-l$x_direct_test_library $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 5363 "configure"
+#line 6678 "configure"
 #include "confdefs.h"
 
 int main() {
 ${x_direct_test_function}()
 ; return 0; }
 EOF
-if { (eval echo configure:5370: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6685: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   LIBS="$ac_save_LIBS"
 # We can link X programs with no special library path.
@@ -5453,6 +5559,47 @@ else
 fi
 
 
+# Unlike the sim directory, whether a simulator is linked is controlled by 
+# presence of a SIM= and a SIM_OBS= definition in the target '.mt' file.  
+# This code just checks for a few cases where we'd like to ignore those
+# definitions, even when they're present in the '.mt' file.  These cases
+# are when --disable-sim is specified, or if the simulator directory is
+# not part of the soruce tree.
+#
+# Check whether --enable-sim or --disable-sim was given.
+if test "${enable_sim+set}" = set; then
+  enableval="$enable_sim"
+  echo "enable_sim = $enable_sim";
+ echo "enableval = ${enableval}";
+ case "${enableval}" in
+  yes) ignore_sim=false ;;
+  no)  ignore_sim=true ;;
+  *)   ignore_sim=false ;;
+ esac
+else
+  ignore_sim=false
+fi
+
+
+if test ! -d "${srcdir}/../sim"; then
+  ignore_sim=true
+fi
+
+if test "${ignore_sim}" = "true"; then
+    IGNORE_SIM="SIM="
+    IGNORE_SIM_OBS="SIM_OBS="
+else
+    IGNORE_SIM=""
+    IGNORE_SIM_OBS=""
+    cat >> confdefs.h <<\EOF
+#define WITH_SIM 1
+EOF
+
+fi
+
+
+
 
 
 
@@ -5598,12 +5745,12 @@ fi
 
 
 echo $ac_n "checking for Cygwin environment""... $ac_c" 1>&6
-echo "configure:5602: checking for Cygwin environment" >&5
+echo "configure:7029: checking for Cygwin environment" >&5
 if eval "test \"`echo '$''{'ac_cv_cygwin'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 5607 "configure"
+#line 7034 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -5614,7 +5761,7 @@ int main() {
 return __CYGWIN__;
 ; return 0; }
 EOF
-if { (eval echo configure:5618: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:7045: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_cygwin=yes
 else
@@ -5631,19 +5778,19 @@ echo "$ac_t""$ac_cv_cygwin" 1>&6
 CYGWIN=
 test "$ac_cv_cygwin" = yes && CYGWIN=yes
 echo $ac_n "checking for mingw32 environment""... $ac_c" 1>&6
-echo "configure:5635: checking for mingw32 environment" >&5
+echo "configure:7062: checking for mingw32 environment" >&5
 if eval "test \"`echo '$''{'ac_cv_mingw32'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 5640 "configure"
+#line 7067 "configure"
 #include "confdefs.h"
 
 int main() {
 return __MINGW32__;
 ; return 0; }
 EOF
-if { (eval echo configure:5647: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:7074: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_mingw32=yes
 else
@@ -5662,7 +5809,7 @@ test "$ac_cv_mingw32" = yes && MINGW32=yes
 
 
 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
-echo "configure:5666: checking for executable suffix" >&5
+echo "configure:7093: checking for executable suffix" >&5
 if eval "test \"`echo '$''{'ac_cv_exeext'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -5672,7 +5819,7 @@ else
   rm -f conftest*
   echo 'int main () { return 0; }' > conftest.$ac_ext
   ac_cv_exeext=
-  if { (eval echo configure:5676: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
+  if { (eval echo configure:7103: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; }; then
     for file in conftest.*; do
       case $file in
       *.c | *.o | *.obj | *.ilk | *.pdb) ;;
@@ -5868,6 +6015,7 @@ s%@GT_NO@%$GT_NO%g
 s%@GT_YES@%$GT_YES%g
 s%@MKINSTALLDIRS@%$MKINSTALLDIRS%g
 s%@l@%$l%g
+s%@AWK@%$AWK%g
 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
 s%@INSTALL_DATA@%$INSTALL_DATA%g
@@ -5879,7 +6027,76 @@ s%@TUI_LIBRARY@%$TUI_LIBRARY%g
 s%@WARN_CFLAGS@%$WARN_CFLAGS%g
 s%@MMALLOC_CFLAGS@%$MMALLOC_CFLAGS%g
 s%@MMALLOC@%$MMALLOC%g
+s%@MACHINE_OBS@%$MACHINE_OBS%g
+s%@DLLTOOL@%$DLLTOOL%g
+s%@WINDRES@%$WINDRES%g
 s%@TERM_LIB@%$TERM_LIB%g
+s%@ENABLE_IDE@%$ENABLE_IDE%g
+s%@FOUNDRY_LIB_BASE@%$FOUNDRY_LIB_BASE%g
+s%@LIBGUI@%$LIBGUI%g
+s%@GUI_CFLAGS_X@%$GUI_CFLAGS_X%g
+s%@IDE_CFLAGS_X@%$IDE_CFLAGS_X%g
+s%@IDE_X@%$IDE_X%g
+s%@LIBIDETCL@%$LIBIDETCL%g
+s%@LIBIDE@%$LIBIDE%g
+s%@IDE_DEPS@%$IDE_DEPS%g
+s%@WIN32LIBS@%$WIN32LIBS%g
+s%@WIN32LDAPP@%$WIN32LDAPP%g
+s%@TCL_VERSION@%$TCL_VERSION%g
+s%@TCL_MAJOR_VERSION@%$TCL_MAJOR_VERSION%g
+s%@TCL_MINOR_VERSION@%$TCL_MINOR_VERSION%g
+s%@TCL_CC@%$TCL_CC%g
+s%@TCL_DEFS@%$TCL_DEFS%g
+s%@TCL_SHLIB_CFLAGS@%$TCL_SHLIB_CFLAGS%g
+s%@TCL_SHLIB_LD@%$TCL_SHLIB_LD%g
+s%@TCL_SHLIB_LD_LIBS@%$TCL_SHLIB_LD_LIBS%g
+s%@TCL_SHLIB_SUFFIX@%$TCL_SHLIB_SUFFIX%g
+s%@TCL_DL_LIBS@%$TCL_DL_LIBS%g
+s%@TCL_LD_FLAGS@%$TCL_LD_FLAGS%g
+s%@TCL_LD_SEARCH_FLAGS@%$TCL_LD_SEARCH_FLAGS%g
+s%@TCL_COMPAT_OBJS@%$TCL_COMPAT_OBJS%g
+s%@TCL_RANLIB@%$TCL_RANLIB%g
+s%@TCL_BUILD_LIB_SPEC@%$TCL_BUILD_LIB_SPEC%g
+s%@TCL_LIB_SPEC@%$TCL_LIB_SPEC%g
+s%@TCL_LIB_VERSIONS_OK@%$TCL_LIB_VERSIONS_OK%g
+s%@TK_VERSION@%$TK_VERSION%g
+s%@TK_DEFS@%$TK_DEFS%g
+s%@TK_BUILD_INCLUDES@%$TK_BUILD_INCLUDES%g
+s%@TK_XINCLUDES@%$TK_XINCLUDES%g
+s%@TK_XLIBSW@%$TK_XLIBSW%g
+s%@TK_BUILD_LIB_SPEC@%$TK_BUILD_LIB_SPEC%g
+s%@TK_LIB_SPEC@%$TK_LIB_SPEC%g
+s%@TCLHDIR@%$TCLHDIR%g
+s%@TKHDIR@%$TKHDIR%g
+s%@ITCLHDIR@%$ITCLHDIR%g
+s%@ITKHDIR@%$ITKHDIR%g
+s%@TIXHDIR@%$TIXHDIR%g
+s%@ITCL_VERSION@%$ITCL_VERSION%g
+s%@ITCL_DEFS@%$ITCL_DEFS%g
+s%@ITCL_BUILD_INCLUDES@%$ITCL_BUILD_INCLUDES%g
+s%@ITCL_BUILD_LIB_SPEC@%$ITCL_BUILD_LIB_SPEC%g
+s%@ITCL_LIB_SPEC@%$ITCL_LIB_SPEC%g
+s%@ITK_VERSION@%$ITK_VERSION%g
+s%@ITK_DEFS@%$ITK_DEFS%g
+s%@ITK_BUILD_INCLUDES@%$ITK_BUILD_INCLUDES%g
+s%@ITK_BUILD_LIB_SPEC@%$ITK_BUILD_LIB_SPEC%g
+s%@ITK_LIB_SPEC@%$ITK_LIB_SPEC%g
+s%@TIX_VERSION@%$TIX_VERSION%g
+s%@TIX_BUILD_LIB_SPEC@%$TIX_BUILD_LIB_SPEC%g
+s%@ENABLE_GDBTK@%$ENABLE_GDBTK%g
+s%@X_CFLAGS@%$X_CFLAGS%g
+s%@X_LDFLAGS@%$X_LDFLAGS%g
+s%@X_LIBS@%$X_LIBS%g
+s%@ITCLLIB@%$ITCLLIB%g
+s%@ITCL_DEPS@%$ITCL_DEPS%g
+s%@ITKLIB@%$ITKLIB%g
+s%@ITK_DEPS@%$ITK_DEPS%g
+s%@TIXLIB@%$TIXLIB%g
+s%@TIX_DEPS@%$TIX_DEPS%g
+s%@GDBTKLIBS@%$GDBTKLIBS%g
+s%@GDBTK_CFLAGS@%$GDBTK_CFLAGS%g
+s%@IGNORE_SIM@%$IGNORE_SIM%g
+s%@IGNORE_SIM_OBS@%$IGNORE_SIM_OBS%g
 s%@ENABLE_CFLAGS@%$ENABLE_CFLAGS%g
 s%@CONFIG_OBS@%$CONFIG_OBS%g
 s%@CONFIG_DEPS@%$CONFIG_DEPS%g
@@ -5892,6 +6109,7 @@ s%@host_makefile_frag@%%g
 /@target_makefile_frag@/r $target_makefile_frag
 s%@target_makefile_frag@%%g
 s%@frags@%$frags%g
+s%@LN_S@%$LN_S%g
 s%@EXEEXT@%$EXEEXT%g
 s%@subdirs@%$subdirs%g
 
index aca63e62e27c6d89c6107b8ee6baf00ac4e50984..0a4695fde3b99a8eb755a1fd8fd40fc36554a6e8 100644 (file)
@@ -56,6 +56,7 @@ i[3456]86-*-dgux*)    gdb_host=i386dgux ;;
 i[3456]86-*-freebsd*)  gdb_host=fbsd ;;
 i[3456]86-*-netbsd*)   gdb_host=nbsd ;;
 i[3456]86-*-go32*)     gdb_host=go32 ;;
+i[3456]86-*-msdosdjgpp*) gdb_host=go32 ;;
 i[3456]86-*-linux*)    gdb_host=linux ;;
 i[3456]86-*-lynxos*)   gdb_host=i386lynx ;;
 i[3456]86-*-mach3*)    gdb_host=i386m3 ;;
@@ -104,7 +105,7 @@ m88*-motorola-sysv4*)       gdb_host=delta88v4 ;;
 m88*-motorola-sysv*)   gdb_host=delta88 ;;
 m88*-*-*)              gdb_host=m88k ;;
 
-mips-dec-mach3*)       gdb_host=mach3 ;;
+mips-dec-mach3*)       gdb_host=mipsm3 ;;
 mips-dec-*)            gdb_host=decstation ;;
 mips-little-*)         gdb_host=littlemips ;;
 mips-sgi-irix3*)       gdb_host=irix3 ;;
index d65811837928ebd939a129b83778a78c1a61fe8f..363438a033c8a7f8abd81b4e5174f3aae73b91ff 100644 (file)
@@ -54,6 +54,7 @@ changequote(,)dnl
 dnl
 changequote([,])dnl
 
+AC_PROG_AWK
 AC_PROG_INSTALL
 AC_CHECK_TOOL(AR, ar)
 AC_CHECK_TOOL(RANLIB, ranlib, :)
@@ -69,7 +70,7 @@ AC_CHECK_HEADERS(ctype.h curses.h endian.h link.h \
        memory.h objlist.h ptrace.h sgtty.h stddef.h stdlib.h \
        string.h sys/procfs.h sys/ptrace.h sys/reg.h \
        term.h termio.h termios.h unistd.h wait.h sys/wait.h \
-       wchar.h wctype.h asm/debugreg.h sys/debugreg.h)
+       wchar.h wctype.h asm/debugreg.h sys/debugreg.h sys/select.h)
 AC_HEADER_STAT
 
 AC_C_CONST
@@ -109,16 +110,20 @@ AC_MSG_RESULT($gdb_cv_hpux_sswide)
 # Also detect which type of /proc is in use, such as for Unixware.
 
 if test "${target}" = "${host}"; then
+  gdb_cv_hostos_is_solaris=no
   case "${host}" in
   i[[3456]]86-*-linux*)
        AC_DEFINE(START_INFERIOR_TRAPS_EXPECTED,2)
        AC_DEFINE(sys_quotactl)
        ;;
+  *-*-solaris*)
+       gdb_cv_hostos_is_solaris=yes ;;
   esac
   AC_MSG_CHECKING(for directory proc entries)
 # The [gdb_host != sun4sol2] hack is because Solaris does provide the
 # multiple procfs files as of Solaris 2.6, but GDB can't use it right now.
-  if test "$ac_cv_header_sys_procfs_h" = yes -a "$gdb_host" != sun4sol2 \
+  if test "$ac_cv_header_sys_procfs_h" = yes -a \
+          "$gdb_cv_hostos_is_solaris" = no \
   -a -d /proc/$$ \
   -a -f /proc/$$/ctl \
   -a -f /proc/$$/as \
@@ -405,6 +410,19 @@ if test x$want_mmalloc = xtrue; then
    MMALLOC='../mmalloc/libmmalloc.a'
 fi
 
+
+# In the Cygwin environment, we need some additional flags.
+AC_CACHE_CHECK([for cygwin], gdb_cv_os_cygwin,
+[AC_EGREP_CPP(lose, [
+#if defined (__CYGWIN__) || defined (__CYGWIN32__)
+lose
+#endif],[gdb_cv_os_cygwin=yes],[gdb_cv_os_cygwin=no])])
+
+DLLTOOL=${DLLTOOL-dlltool}
+WINDRES=${WINDRES-windres}
+AC_SUBST(DLLTOOL)
+AC_SUBST(WINDRES)
+
 dnl Figure out which term library to use.
 if test x$gdb_cv_os_cygwin = xyes; then
   TERM_LIB='`if test -r ../libtermcap/libtermcap.a; then echo ../libtermcap/libtermcap.a; else echo -ltermcap; fi`'
@@ -425,8 +443,44 @@ fi
 AC_SUBST(TERM_LIB)
 
 
+
+
 AC_PATH_X
 
+# Unlike the sim directory, whether a simulator is linked is controlled by 
+# presence of a SIM= and a SIM_OBS= definition in the target '.mt' file.  
+# This code just checks for a few cases where we'd like to ignore those
+# definitions, even when they're present in the '.mt' file.  These cases
+# are when --disable-sim is specified, or if the simulator directory is
+# not part of the soruce tree.
+#
+AC_ARG_ENABLE(sim,
+[  --enable-sim            Link gdb with simulator],
+[echo "enable_sim = $enable_sim";
+ echo "enableval = ${enableval}";
+ case "${enableval}" in
+  yes) ignore_sim=false ;;
+  no)  ignore_sim=true ;;
+  *)   ignore_sim=false ;;
+ esac],
+[ignore_sim=false])
+
+if test ! -d "${srcdir}/../sim"; then
+  ignore_sim=true
+fi
+
+if test "${ignore_sim}" = "true"; then
+    IGNORE_SIM="SIM="
+    IGNORE_SIM_OBS="SIM_OBS="
+else
+    IGNORE_SIM=""
+    IGNORE_SIM_OBS=""
+    AC_DEFINE(WITH_SIM)
+fi
+AC_SUBST(IGNORE_SIM)
+AC_SUBST(IGNORE_SIM_OBS)
+
 AC_SUBST(ENABLE_CFLAGS)
 
 AC_SUBST(CONFIG_OBS)
index 95fc274194369718e38e560b1081eae053933cbe..23585453c4697645ba817d0ea15b935ea4befb35 100644 (file)
@@ -50,17 +50,8 @@ alpha*-*-linux*)     gdb_target=alpha-linux ;;
 
 arc-*-*)               gdb_target=arc ;;
 
-arm-*-* | thumb-*-* | strongarm-*-*)   gdb_target=arm
-
-                       # rdi doesn't work for wingdb yet
-                       case $gdb_host in
-                       windows) ;;
-                       *)
-                           configdirs="$configdirs rdi-share"
-                           CONFIG_OBS="$CONFIG_OBS remote-rdi.o rdi-share/libangsd.a"
-                           ;;
-                       esac
-                       ;;
+arm-*-* | thumb-*-* | strongarm-*-*)
+                       gdb_target=arm ;;
 
 c1-*-*)                        gdb_target=convex ;;
 c2-*-*)                        gdb_target=convex ;;
@@ -94,13 +85,14 @@ i[3456]86-*-freebsd*)       gdb_target=fbsd ;;
 i[3456]86-*-netbsd*)   gdb_target=nbsd ;;
 i[3456]86-*-os9k)      gdb_target=i386os9k ;;
 i[3456]86-*-go32*)     gdb_target=i386aout ;;
+i[3456]86-*-msdosdjgpp*) gdb_target=go32 ;;
 i[3456]86-*-lynxos*)   gdb_target=i386lynx
                configdirs="${configdirs} gdbserver" ;;
 i[3456]86-*-solaris*)  gdb_target=i386sol2 ;;
 i[3456]86-*-sunos*)    gdb_target=sun386 ;;
-i[3456]86-*-sysv4.2MP) gdb_target=i386v42mp ;;
-i[3456]86-*-sysv4.2uw2*)       gdb_target=i386v42mp ;;
+i[3456]86-*-sysv4.2*)  gdb_target=i386v42mp ;;
 i[3456]86-*-sysv4*)    gdb_target=i386v4 ;;
+i[3456]86-*-sysv5*)    gdb_target=i386v42mp ;;
 i[3456]86-*-unixware2*)        gdb_target=i386v42mp ;;
 i[3456]86-*-unixware*) gdb_target=i386v4 ;;
 i[3456]86-*-sco3.2v4*) gdb_target=i386sco4 ;;
@@ -118,12 +110,12 @@ i[3456]86-*-netware*)     gdb_target=i386nw
                configdirs="${configdirs} nlm" ;;
 i[3456]86-*-osf1mk*)   gdb_target=i386mk ;;
 i[3456]86-*-cygwin*)   gdb_target=cygwin  ;;
+
 i960-*-bout*)          gdb_target=vxworks960 ;;
 i960-nindy-coff*)      gdb_target=nindy960 ;;
 i960-*-coff*)          gdb_target=mon960 ;;
 i960-nindy-elf*)       gdb_target=nindy960 ;;
 i960-*-elf*)           gdb_target=mon960 ;;
-
 i960-*-nindy*)         gdb_target=nindy960 ;;
 i960-*-vxworks*)       gdb_target=vxworks960 ;;
 
@@ -266,6 +258,8 @@ sparc64-*-*)                gdb_target=sp64 ;;
 
 tahoe-*-*)             gdb_target=tahoe ;;
 
+tic80-*-*)             gdb_target=tic80
+                       configdirs="${configdirs} gdbserver" ;;
 
 vax-*-*)               gdb_target=vax ;;
 
index 8bfc0d8166e2278918581115916ec1789faf8b65..ad128c117e8dcb4cea082af6d191025b4815efd8 100644 (file)
@@ -123,9 +123,6 @@ static struct user u;
 static thread_t th;
 static proc_t pr;
 
-/* The registers of the currently selected thread.  */
-
-extern char registers[REGISTER_BYTES];
 
 /* Vector and communication registers from core dump or from inferior.
    These are read on demand, ie, not normally valid.  */
index 94e56ebffec1c2a114d2fe2127efc238687be6a1..6a0bea4f9442529f2383133b7e757d3ce9036098 100644 (file)
@@ -37,8 +37,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "symfile.h"
 #include "objfiles.h"
 
-extern char registers[];
-
 /* Local function declarations.  */
 
 static void call_extra_exec_file_hooks PARAMS ((char *filename));
index e635257b2f4329d3e398c0fc7de39dff7cd66e5a..0cff040127237723567c100b1c3b290ef8e6da30 100644 (file)
@@ -95,15 +95,18 @@ core_close (quitting)
     {
       inferior_pid = 0;                /* Avoid confusion from thread stuff */
 
+      /* Clear out solib state while the bfd is still open. See
+        comments in clear_solib in solib.c. */
+#ifdef CLEAR_SOLIB
+      CLEAR_SOLIB ();
+#endif
+
       name = bfd_get_filename (core_bfd);
       if (!bfd_close (core_bfd))
        warning ("cannot close \"%s\": %s",
                 name, bfd_errmsg (bfd_get_error ()));
       free (name);
       core_bfd = NULL;
-#ifdef CLEAR_SOLIB
-      CLEAR_SOLIB ();
-#endif
       if (core_ops.to_sections)
        {
          free ((PTR)core_ops.to_sections);
index 2c4b6f1667d4e1cc478e6cb8cb889ede56ab0e76..f693a30a0452c45cc727cd287a0b11b2ea4efa21 100644 (file)
@@ -63,7 +63,6 @@ extern int have_symbol_file_p();
 extern jmp_buf stack_jmp;
 
 extern int errno;
-extern char registers[REGISTER_BYTES];
 
 void
 fetch_inferior_registers (regno)
@@ -310,7 +309,6 @@ fill_gregset (gregsetp, regno)
 {
     int regi;
     register greg_t *regp = (greg_t *) gregsetp;
-    extern char registers[];
 
     for (regi = 0 ; regi <= R_R31 ; regi++)
        if ((regno == -1) || (regno == regi))
index f4b52f62295bb13dd6115dacbffad9fb195c1e21..7f6060337c86c54e7cebe4a6b53e7e5b73eb489a 100644 (file)
@@ -552,6 +552,45 @@ d10v_push_return_address (pc, sp)
 }
  
 
+/* When arguments must be pushed onto the stack, they go on in reverse
+   order.  The below implements a FILO (stack) to do this. */
+
+struct stack_item
+{
+  int len;
+  struct stack_item *prev;
+  void *data;
+};
+
+static struct stack_item *push_stack_item PARAMS ((struct stack_item *prev, void *contents, int len));
+static struct stack_item *
+push_stack_item (prev, contents, len)
+     struct stack_item *prev;
+     void *contents;
+     int len;
+{
+  struct stack_item *si;
+  si = xmalloc (sizeof (struct stack_item));
+  si->data = xmalloc (len);
+  si->len = len;
+  si->prev = prev;
+  memcpy (si->data, contents, len);
+  return si;
+}
+
+static struct stack_item *pop_stack_item PARAMS ((struct stack_item *si));
+static struct stack_item *
+pop_stack_item (si)
+     struct stack_item *si;
+{
+  struct stack_item *dead = si;
+  si = si->prev;
+  free (dead->data);
+  free (dead);
+  return si;
+}
+
+
 CORE_ADDR
 d10v_push_arguments (nargs, args, sp, struct_return, struct_addr)
      int nargs;
@@ -562,6 +601,7 @@ d10v_push_arguments (nargs, args, sp, struct_return, struct_addr)
 {
   int i;
   int regnum = ARG1_REGNUM;
+  struct stack_item *si = NULL;
   
   /* Fill in registers and arg lists */
   for (i = 0; i < nargs; i++)
@@ -598,9 +638,9 @@ d10v_push_arguments (nargs, args, sp, struct_return, struct_addr)
          else
            {
              char ptr[2];
-             sp -= 2;
+             /* arg will go onto stack */
              store_address (ptr, val & 0xffff, 2);
-             write_memory (sp, ptr, 2);
+             si = push_stack_item (si, ptr, 2);
            }
        }
       else
@@ -631,13 +671,20 @@ d10v_push_arguments (nargs, args, sp, struct_return, struct_addr)
            }
          else
            {
-             /* arg goes straight on stack */
-             regnum = ARGN_REGNUM + 1;
-             sp = (sp - len) & ~1;
-             write_memory (sp, contents, len);
+             /* arg will go onto stack */
+             regnum = ARGN_REGNUM + 1; 
+             si = push_stack_item (si, contents, len);
            }
        }
     }
+
+  while (si)
+    {
+      sp = (sp - si->len) & ~1;
+      write_memory (sp, si->data, si->len);
+      si = pop_stack_item (si);
+    }
+  
   return sp;
 }
 
index fa9c97440ed8e1f2f3e28eb0ed265e5adfb547e3..494bd4465a13724807d36a703a7bf21f04705f0b 100644 (file)
@@ -1,5 +1,5 @@
 /* Remote debugging interface to dBUG ROM monitor for GDB, the GNU debugger.
-   Copyright 1996 Free Software Foundation, Inc.
+   Copyright 1996, 1999 Free Software Foundation, Inc.
 
    Written by Stan Shebs of Cygnus Support.
 
@@ -97,12 +97,12 @@ init_dbug_cmds(void)
   dbug_cmds.flags =   MO_CLR_BREAK_USES_ADDR | MO_GETMEM_NEEDS_RANGE | MO_FILL_USES_ADDR;
   dbug_cmds.init =   dbug_inits;                       /* Init strings */
   dbug_cmds.cont =   "go\r";                   /* continue command */
-  dbug_cmds.step =   "step\r";                 /* single step */
+  dbug_cmds.step =   "trace\r";                        /* single step */
   dbug_cmds.stop =   NULL;                             /* interrupt command */
   dbug_cmds.set_break =   "br %x\r";                   /* set a breakpoint */
-  dbug_cmds.clr_break =   "br -c %x\r";                        /* clear a breakpoint */
-  dbug_cmds.clr_all_break =   "br -c\r";                       /* clear all breakpoints */
-  dbug_cmds.fill =   "bf.b %x %x %x";          /* fill (start end val) */
+  dbug_cmds.clr_break =   "br -r %x\r";                        /* clear a breakpoint */
+  dbug_cmds.clr_all_break =   "br -r\r";                       /* clear all breakpoints */
+  dbug_cmds.fill =   "bf.b %x %x %x\r";                /* fill (start end val) */
   dbug_cmds.setmem.cmdb =     "mm.b %x %x\r";          /* setmem.cmdb (addr, value) */
   dbug_cmds.setmem.cmdw =     "mm.w %x %x\r";          /* setmem.cmdw (addr, value) */
   dbug_cmds.setmem.cmdl =     "mm.l %x %x\r";          /* setmem.cmdl (addr, value) */
index 0749412cc35d23ca7f358170a932984a11d0c500..f7521307026da3f4ef379fa9840f8c070183d27d 100644 (file)
@@ -196,6 +196,51 @@ struct complaint repeated_header_complaint =
 
 struct complaint unclaimed_bincl_complaint =
   {"N_BINCL %s not in entries for any file, at symtab pos %d", 0, 0};
+\f
+/* find_text_range --- find start and end of loadable code sections
+
+   The find_text_range function finds the shortest address range that
+   encloses all sections containing executable code, and stores it in
+   objfile's text_addr and text_size members.
+
+   dbx_symfile_read will use this to finish off the partial symbol
+   table, in some cases.  */
+
+static void
+find_text_range (bfd *sym_bfd, struct objfile *objfile)
+{
+  asection *sec;
+  int found_any = 0;
+  CORE_ADDR start, end;
+  
+  for (sec = sym_bfd->sections; sec; sec = sec->next)
+    if (bfd_get_section_flags (sym_bfd, sec) & SEC_CODE)
+      {
+       CORE_ADDR sec_start = bfd_section_vma (sym_bfd, sec);
+       CORE_ADDR sec_end = sec_start + bfd_section_size (sym_bfd, sec);
+
+       if (found_any)
+         {
+           if (sec_start < start) start = sec_start;
+           if (sec_end > end) end = sec_end;
+         }
+       else
+         {
+           start = sec_start;
+           end = sec_end;
+         }
+
+       found_any = 1;
+      }
+
+  if (! found_any)
+    error ("Can't find any code sections in symbol file");
+
+  DBX_TEXT_ADDR (objfile) = start;
+  DBX_TEXT_SIZE (objfile) = end - start;
+}
+
+
 \f
 /* During initial symbol readin, we need to have a structure to keep
    track of which psymtabs have which bincls in them.  This structure
@@ -2589,11 +2634,9 @@ elfstab_build_psymtabs (objfile, section_offsets, mainline,
      It might even contain some info from the ELF symtab to help us.  */
   info = objfile->sym_stab_info;
 
-  text_sect = bfd_get_section_by_name (sym_bfd, ".text");
-  if (!text_sect)
-    error ("Can't find .text section in symbol file");
-  DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
-  DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
+  /* Find the first and last text address.  dbx_symfile_read seems to
+     want this.  */
+  find_text_range (sym_bfd, objfile);
 
 #define        ELF_STABS_SYMBOL_SIZE   12      /* XXX FIXME XXX */
   DBX_SYMBOL_SIZE    (objfile) = ELF_STABS_SYMBOL_SIZE;
index c0552a1728425b0fb431ed07184b25ba2af781db..ed16956ee558404d07c895a47dfe3c26d3a69fd1 100644 (file)
@@ -1,5 +1,5 @@
 /* Basic, host-specific, and target-specific definitions for GDB.
-   Copyright (C) 1986, 89, 91, 92, 93, 94, 95, 96, 98, 1999
+   Copyright (C) 1986, 89, 91, 92, 93, 94, 95, 96, 1998
    Free Software Foundation, Inc.
 
 This file is part of GDB.
@@ -252,6 +252,8 @@ extern void notice_quit PARAMS ((void));
 
 extern int strcmp_iw PARAMS ((const char *, const char *));
 
+extern int subset_compare PARAMS ((char *, char *));
+
 extern char *safe_strerror PARAMS ((int));
 
 extern char *safe_strsignal PARAMS ((int));
@@ -273,6 +275,8 @@ typedef void (*make_cleanup_func) PARAMS ((void *));
 
 extern struct cleanup *make_cleanup PARAMS ((make_cleanup_func, void *));
 
+extern struct cleanup *make_cleanup_freeargv PARAMS ((char **));
+
 extern struct cleanup *make_final_cleanup PARAMS ((make_cleanup_func, void *));
 
 extern struct cleanup *make_my_cleanup PARAMS ((struct cleanup **, 
@@ -1019,24 +1023,7 @@ extern CORE_ADDR push_bytes PARAMS ((CORE_ADDR, char *, int));
 
 extern CORE_ADDR push_word PARAMS ((CORE_ADDR, ULONGEST));
 
-/* Some parts of gdb might be considered optional, in the sense that they
-   are not essential for being able to build a working, usable debugger
-   for a specific environment.  For example, the maintenance commands
-   are there for the benefit of gdb maintainers.  As another example,
-   some environments really don't need gdb's that are able to read N
-   different object file formats.  In order to make it possible (but
-   not necessarily recommended) to build "stripped down" versions of
-   gdb, the following defines control selective compilation of those
-   parts of gdb which can be safely left out when necessary.  Note that
-   the default is to include everything. */
-
-#ifndef MAINTENANCE_CMDS
-#define MAINTENANCE_CMDS 1
-#endif
-
-#ifdef MAINTENANCE_CMDS
 extern int watchdog;
-#endif
 
 /* Hooks for alternate command interfaces.  */
 
index 1e03a80884b33e8c829f9dcccd4cc04e39cc8b33..19f11db10cd68768a3254c60694e8947e040f55e 100644 (file)
@@ -1,3 +1,41 @@
+Thu Apr 22 13:07:37 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * gdbint.texinfo (USE_GENERIC_DUMMY_FRAMES): Document.
+       (GET_SAVED_REGISTER): Update, not just the a29k uses this.
+
+Wed Apr 21 13:59:01 1999  Dave Brolley  <brolley@cygnus.com>
+
+       * gdbint.texinfo: Fix typos: $ -> @.
+
+Tue Apr 20 11:59:38 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * gdbint.texinfo (REGISTER_NAMES, BREAKPOINT, BIG_BREAKPOINT,
+       LITTLE_BREAKPOINT, LITTLE_REMOTE_BREAKPOINT,
+       BIG_REMOTE_BREAKPOINT): Deprecate in favor of REGISTER_NAME and
+       BREAKPOINT_FROM_PC.
+       
+Mon Apr 12 16:00:44 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * gdbint.texinfo (CALL_DUMMY_STACK_ADJUST_P,
+       CALL_DUMMY_STACK_ADJUST): Document.
+
+Thu Apr  8 17:23:15 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * gdbint.texinfo (CALL_DUMMY_P, CALL_DUMMY_WORDS,
+       SIZEOF_CALL_DUMMY_WORDS, CALL_DUMMY): Define.
+
+1999-04-02  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * gdbint.texinfo (MAINTENANCE_CMDS): Remove ref, since it no
+       longer exists.
+
+Tue Mar  9 19:25:11 1999  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * gdb.texinfo, remote.texi, all-cfg.texi, HPPA-cfg.texi: Remove
+       nearly all @ifset/@ifclear conditionals; nobody uses them, and
+       they make the manual source incomprehensible.
+       * h8-cfg.texi: Remove, hasn't been used in years.
+
 Thu Feb 11 18:00:59 1999  Stan Shebs  <shebs@andros.cygnus.com>
 
        * gdb.texinfo: Update the credits.
index 88a138cab8b0a70ed36035b0f445932ac2a9c581..8e44a4c99feaf8ce33d74552c1fc9a9d0e106ceb 100644 (file)
@@ -1,5 +1,5 @@
 @c GDB MANUAL configuration file.  
-@c Copyright (c) 1993 Free Software Foundation, Inc.
+@c Copyright (c) 1997, 1998 Free Software Foundation, Inc.
 @c
 @c NOTE: While the GDB manual is configurable (by changing these
 @c switches), its configuration is ***NOT*** automatically tied in to
 @c HP PA-RISC target:
 @set HPPA
 @c
-@c Hitachi H8/300 target:
-@clear H8
-@c Hitachi H8/300 target ONLY:
-@clear H8EXCLUSIVE
-@c
-@c remote MIPS target:
-@clear MIPS
-@c
-@c SPARC target:
-@clear SPARC
-@c
-@c AMD 29000 target:
-@clear AMD29K
-@c
-@c Intel 960 target:
-@clear I960
-@c
-@c Tandem ST2000 (phone switch) target:
-@clear ST2000
-@c
-@c Zilog 8000 target:
-@clear Z8K
-@c
-@c Wind River Systems VxWorks environment:
-@clear VXWORKS
-@c
-@c ----------------------------------------------------------------------
-@c DOC FEATURE FLAGS:
-@c 
-@c Bare-board target?
-@clear BARETARGET
-@c
-@c Restrict languages discussed to C?
-@c This is backward.  As time permits, change this to language-specific
-@c switches for what to include.
-@clear CONLY
-@c Discuss Fortran?
-@clear FORTRAN
-@c
-@c Discuss Modula 2?
-@clear MOD2
-@c
-@c Specifically for host machine running DOS?
-@clear DOSHOST
-@c
-@c Talk about CPU simulator targets?
-@clear SIMS
-@c
-@c Remote serial line settings of interest?
-@set SERIAL
-@c
-@c Discuss features requiring Posix or similar OS environment?
-@set POSIX
-@c
-@c Discuss remote serial debugging stub?
-@clear REMOTESTUB
-@c
-@c Discuss gdbserver?
-@set GDBSERVER
-@c
-@c Discuss gdbserve.nlm?
-@set GDBSERVE
-@c
 @c Refrain from discussing how to configure sw and format doc?
 @clear PRECONFIGURED
 @c
-@c Refrain from referring to unfree publications?
-@set FSFDOC
-@c
 @c ----------------------------------------------------------------------
 @c STRINGS:
 @c
index 74d8090b51bb81d9a701a6563fdcf666f6fd0990..755f334440e9acc6ed9b733f6b2a8261ed4e50ed 100644 (file)
 @c HP PA-RISC target ONLY:
 @clear HPPA
 @c
-@c Hitachi H8/300 target:
-@set H8
-@c Hitachi H8/300 target ONLY:
-@clear H8EXCLUSIVE
-@c
-@c remote MIPS target:
-@set MIPS
-@c
-@c SPARC target:
-@set SPARC
-@set SPARCLET
-@c
-@c AMD 29000 target:
-@set AMD29K
-@c
-@c Intel 960 target:
-@set I960
-@c
-@c Tandem ST2000 (phone switch) target:
-@set ST2000
-@c
-@c Zilog 8000 target:
-@set Z8K
-@c
-@c Wind River Systems VxWorks environment:
-@set VXWORKS
-@c
-@c ----------------------------------------------------------------------
-@c DOC FEATURE FLAGS:
-@c 
-@c Bare-board target?
-@clear BARETARGET
-@c
-@c Restrict languages discussed to C?
-@c This is backward.  As time permits, change this to language-specific
-@c switches for what to include.
-@clear CONLY
-@c Discuss Fortran?
-@set FORTRAN
-@c
-@c Discuss Modula 2?
-@set MOD2
-@c
-@c Specifically for host machine running DOS?
-@clear DOSHOST
-@c
-@c Talk about CPU simulator targets?
-@set SIMS
-@c
-@c Remote serial line settings of interest?
-@set SERIAL
-@c
-@c Discuss features requiring Posix or similar OS environment?
-@set POSIX
-@c
-@c Discuss remote serial debugging stub?
-@set REMOTESTUB
-@c
-@c Discuss gdbserver?
-@set GDBSERVER
-@c
-@c Discuss gdbserve.nlm?
-@set GDBSERVE
-@c
 @c Refrain from discussing how to configure sw and format doc?
 @clear PRECONFIGURED
 @c
-@c Refrain from referring to unfree publications?
-@set FSFDOC
-@c
 @c ----------------------------------------------------------------------
 @c STRINGS:
 @c
index fc920bb0c5788211f40d47d77225dcba24b87f0e..d7c9d83c19070acc42e6603615d2c19ec2ffd148 100644 (file)
@@ -9,12 +9,7 @@
 @c
 @include gdb-cfg.texi
 @c
-@ifset GENERIC
 @settitle Debugging with @value{GDBN}
-@end ifset
-@ifclear GENERIC
-@settitle Debugging with @value{GDBN} (@value{TARGET})
-@end ifclear
 @setchapternewpage odd
 @c %**end of header
 
@@ -81,9 +76,6 @@ into another language, under the above conditions for modified versions.
 @titlepage
 @title Debugging with @value{GDBN}
 @subtitle The @sc{gnu} Source-Level Debugger
-@ifclear GENERIC
-@subtitle (@value{TARGET})
-@end ifclear
 @sp 1
 @ifclear HPPA
 @subtitle @value{EDITION} Edition, for @value{GDBN} version @value{GDBVN}
@@ -151,9 +143,7 @@ This is the @value{EDITION} Edition, @value{DATE}, for @value{GDBN} Version
 Copyright (C) 1988-1999 Free Software Foundation, Inc.
 @menu
 * Summary::                     Summary of @value{GDBN}
-@ifclear BARETARGET
 * Sample Session::              A sample @value{GDBN} session
-@end ifclear
 
 * Invocation::                  Getting in and out of @value{GDBN}
 * Commands::                    @value{GDBN} commands
@@ -162,13 +152,9 @@ Copyright (C) 1988-1999 Free Software Foundation, Inc.
 * Stack::                       Examining the stack
 * Source::                      Examining source files
 * Data::                        Examining data
-@ifclear CONLY
-* Languages::                   Using @value{GDBN} with different languages
-@end ifclear
 
-@ifset CONLY
+* Languages::                   Using @value{GDBN} with different languages
 * C::                           C language support
-@end ifset
 
 * Symbols::                     Examining the symbol table
 * Altering::                    Altering execution
@@ -176,9 +162,7 @@ Copyright (C) 1988-1999 Free Software Foundation, Inc.
 * Targets::                     Specifying a debugging target
 * Controlling GDB::             Controlling @value{GDBN}
 * Sequences::                   Canned sequences of commands
-@ifclear DOSHOST
 * Emacs::                       Using @value{GDBN} under @sc{gnu} Emacs
-@end ifclear
 
 * GDB Bugs::                    Reporting bugs in @value{GDBN}
 
@@ -222,18 +206,13 @@ Running Programs Under @value{GDBN}
 
 * Compilation::                 Compiling for debugging
 * Starting::                    Starting your program
-@ifclear BARETARGET
 * Arguments::                   Your program's arguments
 * Environment::                 Your program's environment
-@end ifclear
-
 * Working Directory::           Your program's working directory
 * Input/Output::                Your program's input and output
 * Attach::                      Debugging an already-running process
 * Kill Process::                Killing the child process
-@ifclear HPPA
 * Process Information::         Additional process information
-@end ifclear
 
 * Threads::                     Debugging programs with multiple threads
 * Processes::                   Debugging programs with multiple processes
@@ -242,12 +221,8 @@ Stopping and Continuing
 
 * Breakpoints::                 Breakpoints, watchpoints, and catchpoints
 * Continuing and Stepping::     Resuming execution
-@ifset POSIX
 * Signals::                     Signals
-@end ifset
-@ifclear BARETARGET
 * Thread Stops::                Stopping and starting multi-thread programs
-@end ifclear
 
 Breakpoints and watchpoints
 
@@ -258,9 +233,7 @@ Breakpoints and watchpoints
 * Disabling::                   Disabling breakpoints
 * Conditions::                  Break conditions
 * Break Commands::              Breakpoint command lists
-@ifclear CONLY
 * Breakpoint Menus::            Breakpoint menus
-@end ifclear
 
 Examining the Stack
 
@@ -273,9 +246,7 @@ Examining the Stack
 Examining Source Files
 
 * List::                        Printing source lines
-@ifclear DOSHOST
 * Search::                      Searching source files
-@end ifclear
 * Source Path::                 Specifying source directories
 * Machine Code::                Source and machine code
 
@@ -291,18 +262,13 @@ Examining Data
 * Value History::               Value history
 * Convenience Vars::            Convenience variables
 * Registers::                   Registers
-@ifclear HAVE-FLOAT
 * Floating Point Hardware::     Floating point hardware
-@end ifclear
 
 Using @value{GDBN} with Different Languages
 
 * Setting::                     Switching between source languages
 * Show::                        Displaying the language
-@ifset MOD2
 * Checks::                      Type and range checks
-@end ifset
-
 * Support::                     Supported languages
 
 Switching between source languages
@@ -311,36 +277,24 @@ Switching between source languages
 * Manually::                    Setting the working language manually
 * Automatically::               Having @value{GDBN} infer the source language
 
-@ifset MOD2
 Type and range checking
 
 * Type Checking::               An overview of type checking
 * Range Checking::              An overview of range checking
-@end ifset
 
 Supported languages
 
-@ifset MOD2
-* C::                           C and C++
-
-C Language Support
-
-* C Operators::                 C operators
-
 C Language Support
-@end ifset
 
+* C::                           C and C++
 * C Operators::                 C and C++ operators
 * C Constants::                 C and C++ constants
-* Cplus expressions::           C++ expressions
+* C plus plus expressions::     C++ expressions
 * C Defaults::                  Default settings for C and C++
-@ifset MOD2
 * C Checks::                    C and C++ type and range checks
-@end ifset
 * Debugging C::                 @value{GDBN} and C
 * Debugging C plus plus::       @value{GDBN} features for C++
 
-@ifset MOD2
 Modula-2
 
 * M2 Operators::                Built-in operators
@@ -351,15 +305,12 @@ Modula-2
 * M2 Checks::                   Modula-2 type and range checks
 * M2 Scope::                    The scope operators @code{::} and @code{.}
 * GDB/M2::                      @value{GDBN} and Modula-2
-@end ifset
 
 Altering Execution
 
 * Assignment::                  Assignment to variables
 * Jumping::                     Continuing at a different address
-@ifclear BARETARGET
 * Signaling::                   Giving your program a signal
-@end ifclear
 * Returning::                   Returning from a function
 * Calling::                     Calling your program's functions
 * Patching::                    Patching your program
@@ -380,38 +331,23 @@ Specifying a Debugging Target
 Remote debugging
 @end ifclear
 
-@ifset REMOTESTUB
 * Remote Serial::               @value{GDBN} remote serial protocol
-@end ifset
 
-@ifset I960
 * i960-Nindy Remote::          @value{GDBN} with a remote i960 (Nindy)
-@end ifset
 
-@ifset AMD29K
 * UDI29K Remote::               The UDI protocol for AMD29K
+
 * EB29K Remote::               The EBMON protocol for AMD29K
-@end ifset
 
-@ifset VXWORKS
 * VxWorks Remote::             @value{GDBN} and VxWorks
-@end ifset
 
-@ifset ST2000
 * ST2000 Remote::               @value{GDBN} with a Tandem ST2000
-@end ifset
 
-@ifset H8
 * Hitachi Remote::              @value{GDBN} and Hitachi Microprocessors
-@end ifset
 
-@ifset MIPS
 * MIPS Remote::                        @value{GDBN} and MIPS boards
-@end ifset
 
-@ifset SIMS
 * Simulator::                   Simulated CPU target
-@end ifset
 
 Controlling @value{GDBN}
 
@@ -468,14 +404,10 @@ Change things in your program, so you can experiment with correcting the
 effects of one bug and go on to learn about another.
 @end itemize
 
-@ifclear CONLY
 You can use @value{GDBN} to debug programs written in C or C++.
 @c "MOD2" used as a "miscellaneous languages" flag here.
 @c This is acceptable while there is no real doc for Chill and Pascal.
-@ifclear MOD2
 For more information, see @ref{Support,,Supported languages}.
-@end ifclear
-@ifset MOD2
 For more information, see @ref{C,,C and C++}.
 
 Support for Modula-2 and Chill is partial.  For information on Modula-2,
@@ -484,16 +416,12 @@ see @ref{Modula-2,,Modula-2}.  There is no further documentation on Chill yet.
 Debugging Pascal programs which use sets, subranges, file variables, or nested
 functions does not currently work.  @value{GDBN} does not support
 entering expressions, printing values, or similar features using Pascal syntax.
-@end ifset
 
-@ifset FORTRAN
 @cindex Fortran
 @value{GDBN} can be used to debug programs written in Fortran, although
 it does not yet support entering expressions, printing values, or
 similar features using Fortran syntax.  It may be necessary to refer to
 some variables with a trailing underscore.
-@end ifset
-@end ifclear
 
 @ifset HPPA
 This version of the manual documents HP Wildebeest (WDB) Version 0.75,
@@ -559,12 +487,10 @@ and Randy Smith (releases 3.2, 3.1, and 3.0).
 Richard Stallman, assisted at various times by Peter TerMaat, Chris
 Hanson, and Richard Mlynarik, handled releases through 2.8.
 
-@ifclear CONLY
 Michael Tiemann is the author of most of the @sc{gnu} C++ support in GDB,
 with significant additional contributions from Per Bothner.  James
 Clark wrote the @sc{gnu} C++ demangler.  Early work on C++ was by Peter
 TerMaat (who also did much general update work leading to release 3.0).
-@end ifclear
 
 @value{GDBN} 4 uses the BFD subroutine library to examine multiple
 object-file formats; BFD was a joint project of David V.
@@ -610,17 +536,12 @@ and RDI targets, respectively.
 Brian Fox is the author of the readline libraries providing
 command-line editing and command history.
 
-Andrew Beers of SUNY Buffalo wrote the language-switching code,
-@ifset MOD2
-the Modula-2 support,
-@end ifset
-and contributed the Languages chapter of this manual.
+Andrew Beers of SUNY Buffalo wrote the language-switching code, the
+Modula-2 support, and contributed the Languages chapter of this manual.
 
 Fred Fish wrote most of the support for Unix System Vr4.  
-@ifclear CONLY
 He also enhanced the command-completion support to cover C++ overloaded
 symbols.
-@end ifclear
 
 Hitachi America, Ltd. sponsored the support for H8/300, H8/500, and
 Super-H processors.
@@ -670,7 +591,6 @@ Unrau, Jim Wilson, and David Zuhn have made contributions both large
 and small.
 
 
-@ifclear BARETARGET
 @node Sample Session, Invocation, Summary, Top
 @chapter A Sample @value{GDBN} Session
 
@@ -956,7 +876,6 @@ session with the @value{GDBN} @code{quit} command.
 @smallexample
 (@value{GDBP}) @b{quit}
 @end smallexample
-@end ifclear
 
 @node Invocation, Commands, Sample Session, Top
 @chapter Getting In and Out of @value{GDBN}
@@ -979,23 +898,15 @@ type @kbd{quit} or @kbd{C-d} to exit.
 @node Invoking GDB, Quitting GDB, Invocation, Invocation
 @section Invoking @value{GDBN}
 
-@ifset H8EXCLUSIVE
-For details on starting up @value{GDBP} as a
-remote debugger attached to a Hitachi microprocessor, see @ref{Hitachi
-Remote,,@value{GDBN} and Hitachi Microprocessors}.
-@end ifset
-
 Invoke @value{GDBN} by running the program @code{@value{GDBP}}.  Once started,
 @value{GDBN} reads commands from the terminal until you tell it to exit.
 
 You can also run @code{@value{GDBP}} with a variety of arguments and options,
 to specify more of your debugging environment at the outset.
 
-@ifset GENERIC
 The command-line options described here are designed
 to cover a variety of situations; in some environments, some of these
 options may effectively be unavailable.  
-@end ifset
 
 The most usual way to start @value{GDBN} is with one argument,
 specifying an executable program:
@@ -1004,7 +915,6 @@ specifying an executable program:
 @value{GDBP} @var{program}
 @end example
 
-@ifclear BARETARGET
 @noindent
 You can also start with both an executable program and a core file
 specified:
@@ -1030,7 +940,6 @@ complete operating system; when you use @value{GDBN} as a remote debugger
 attached to a bare board, there may not be any notion of ``process'',
 and there is often no way to get a core dump.
 @end ifclear
-@end ifclear
 
 You can run @code{gdb} without printing the front material, which describes
 @value{GDBN}'s non-warranty, by specifying @code{-silent}:
@@ -1060,52 +969,13 @@ in sequential order.  The order makes a difference when the
 
 
 @menu
-@ifclear GENERIC
-@ifset REMOTESTUB
-* Remote Serial::               @value{GDBN} remote serial protocol
-@end ifset
-@ifset I960
-* i960-Nindy Remote::          @value{GDBN} with a remote i960 (Nindy)
-@end ifset
-@ifset AMD29K
-* UDI29K Remote::               The UDI protocol for AMD29K
-* EB29K Remote::               The EBMON protocol for AMD29K
-@end ifset
-@ifset VXWORKS
-* VxWorks Remote::             @value{GDBN} and VxWorks
-@end ifset
-@ifset ST2000
-* ST2000 Remote::               @value{GDBN} with a Tandem ST2000
-@end ifset
-@ifset H8
-* Hitachi Remote::              @value{GDBN} and Hitachi Microprocessors
-@end ifset
-@ifset MIPS
-* MIPS Remote::                        @value{GDBN} and MIPS boards
-@end ifset
-@ifset SPARCLET
-* Sparclet Remote::             @value{GDBN} and Sparclet boards
-@end ifset
-@ifset SIMS
-* Simulator::                   Simulated CPU target
-@end ifset
-@end ifclear
-@c remnant makeinfo bug requires this blank line after *two* end-ifblahs:
-
 * File Options::                Choosing files
 * Mode Options::                Choosing modes
 @end menu
 
-@ifclear GENERIC
-@ifclear HPPA
-@include remote.texi
-@end ifclear
-@end ifclear
-
 @node File Options
 @subsection Choosing files
 
-@ifclear BARETARGET
 When @value{GDBN} starts, it reads any arguments other than options as
 specifying an executable file and core file (or process ID).  This is
 the same as if the arguments were specified by the @samp{-se} and
@@ -1114,12 +984,10 @@ that does not have an associated option flag as equivalent to the
 @samp{-se} option followed by that argument; and the second argument
 that does not have an associated option flag, if any, as equivalent to
 the @samp{-c} option followed by that argument.)
-@end ifclear
-@ifset BARETARGET
-When @value{GDBN} starts, it reads any argument other than options as
-specifying an executable file.  This is the same as if the argument was
-specified by the @samp{-se} option.
-@end ifset
+
+If @value{GDBN} has not been configured to included core file support,
+such as for most embedded targets, then it will complain about a second
+argument and ignore it.
 
 Many options have both long and short forms; both are shown in the
 following list.  @value{GDBN} also recognizes the long forms if you truncate
@@ -1134,20 +1002,13 @@ Read symbol table from file @var{file}.
 
 @item -exec @var{file}
 @itemx -e @var{file}
-Use file @var{file} as the executable file to execute when
-@ifset BARETARGET
-appropriate.
-@end ifset
-@ifclear BARETARGET
-appropriate, and for examining pure data in conjunction with a core
-dump.
-@end ifclear
+Use file @var{file} as the executable file to execute when appropriate,
+and for examining pure data in conjunction with a core dump.
 
 @item -se @var{file}
 Read symbol table from file @var{file} and use it as the executable
 file.
 
-@ifclear BARETARGET
 @item -core @var{file}
 @itemx -c @var{file}
 Use file @var{file} as a core dump to examine.
@@ -1156,7 +1017,6 @@ Use file @var{file} as a core dump to examine.
 Connect to process ID @var{number}, as with the @code{attach} command
 (unless there is a file in core-dump format named @var{number}, in which
 case @samp{-c} specifies that file as a core dump to read).
-@end ifclear
 
 @item -command @var{file}
 @itemx -x @var{file}
@@ -1167,7 +1027,6 @@ Files,, Command files}.
 @itemx -d @var{directory}
 Add @var{directory} to the path to search for source files.
 
-@ifclear BARETARGET
 @ifclear HPPA
 @item -m
 @itemx -mapped
@@ -1186,7 +1045,6 @@ The @file{.syms} file is specific to the host machine where @value{GDBN}
 is run.  It holds an exact image of the internal @value{GDBN} symbol
 table.  It cannot be shared across multiple host platforms.
 @end ifclear
-@end ifclear
 
 @ifclear HPPA
 @item -r
@@ -1197,7 +1055,6 @@ This makes startup slower, but makes future operations faster.
 @end ifclear
 @end table
 
-@ifclear BARETARGET
 @ifclear HPPA
 The @code{-mapped} and @code{-readnow} options are typically combined in
 order to build a @file{.syms} file that contains complete symbol
@@ -1209,7 +1066,6 @@ nothing but build a @file{.syms} file for future use is:
        gdb -batch -nx -mapped -readnow programname
 @end example
 @end ifclear
-@end ifclear
 
 @node Mode Options,  , File Options, Invoking GDB
 @subsection Choosing modes
@@ -1253,20 +1109,18 @@ terminates) is not issued when running in batch mode.
 Run @value{GDBN} using @var{directory} as its working directory,
 instead of the current directory.
 
-@ifclear DOSHOST
 @item -fullname
 @itemx -f
-@sc{gnu} Emacs sets this option when it runs @value{GDBN} as a subprocess.  It tells @value{GDBN}
-to output the full file name and line number in a standard,
-recognizable fashion each time a stack frame is displayed (which
-includes each time your program stops).  This recognizable format looks
-like two @samp{\032} characters, followed by the file name, line number
-and character position separated by colons, and a newline.  The
-Emacs-to-@value{GDBN} interface program uses the two @samp{\032} characters as
-a signal to display the source code for the frame.
-@end ifclear
+@sc{gnu} Emacs sets this option when it runs @value{GDBN} as a
+subprocess.  It tells @value{GDBN} to output the full file name and line
+number in a standard, recognizable fashion each time a stack frame is
+displayed (which includes each time your program stops).  This
+recognizable format looks like two @samp{\032} characters, followed by
+the file name, line number and character position separated by colons,
+and a newline.  The Emacs-to-@value{GDBN} interface program uses the two
+@samp{\032} characters as a signal to display the source code for the
+frame.
 
-@ifset SERIAL
 @ifclear HPPA
 @item -b @var{bps}
 Set the line speed (baud rate or bits per second) of any serial
@@ -1276,7 +1130,6 @@ interface used by @value{GDBN} for remote debugging.
 @item -tty @var{device}
 Run using @var{device} for your program's standard input and output.
 @c FIXME: kingdon thinks there is more to -tty.  Investigate.
-@end ifset
 
 @ifset HPPA
 @item -tui
@@ -1316,11 +1169,9 @@ returns to @value{GDBN} command level.  It is safe to type the interrupt
 character at any time because @value{GDBN} does not allow it to take effect
 until a time when it is safe.
 
-@ifclear BARETARGET
 If you have been using @value{GDBN} to control an attached process or
 device, you can release it with the @code{detach} command
 (@pxref{Attach, ,Debugging an already-running process}).
-@end ifclear
 
 @node Shell Commands,  , Quitting GDB, Invocation
 @section Shell commands
@@ -1334,10 +1185,8 @@ just use the @code{shell} command.
 @cindex shell escape
 @item shell @var{command string}
 Invoke a standard shell to execute @var{command string}.
-@ifclear DOSHOST
 If it exists, the environment variable @code{SHELL} determines which
 shell to run.  Otherwise @value{GDBN} uses @code{/bin/sh}.
-@end ifclear
 @end table
 
 The utility @code{make} is often needed in development environments.
@@ -1477,22 +1326,18 @@ command.
 
 If you just want to see the list of alternatives in the first place, you
 can press @kbd{M-?} rather than pressing @key{TAB} twice. @kbd{M-?}
-means @kbd{@key{META} ?}.  You can type this
-@ifclear DOSHOST
-either by holding down a
+means @kbd{@key{META} ?}.  You can type this either by holding down a
 key designated as the @key{META} shift on your keyboard (if there is
-one) while typing @kbd{?}, or
-@end ifclear
-as @key{ESC} followed by @kbd{?}.
+one) while typing @kbd{?}, or as @key{ESC} followed by @kbd{?}.
 
 @cindex quotes in commands
 @cindex completion of quoted strings
 Sometimes the string you need, while logically a ``word'', may contain
-parentheses or other characters that @value{GDBN} normally excludes from its
-notion of a word.  To permit word completion to work in this situation,
-you may enclose words in @code{'} (single quote marks) in @value{GDBN} commands.
+parentheses or other characters that @value{GDBN} normally excludes from
+its notion of a word.  To permit word completion to work in this
+situation, you may enclose words in @code{'} (single quote marks) in
+@value{GDBN} commands.
 
-@ifclear CONLY
 The most likely situation where you might need this is in typing the
 name of a C++ function.  This is because C++ allows function overloading
 (multiple definitions of the same function, distinguished by argument
@@ -1527,11 +1372,10 @@ In general, @value{GDBN} can tell that a quote is needed (and inserts it) if
 you have not yet started typing the argument list when you ask for
 completion on an overloaded symbol.
 
-For more information about overloaded functions, @pxref{Cplus
+For more information about overloaded functions, @pxref{C plus plus
 expressions, ,C++ expressions}.  You can use the command @code{set
 overload-resolution off} to disable overload resolution;
 @pxref{Debugging C plus plus, ,@value{GDBN} features for C++}.
-@end ifclear
 
 
 @node Help,  , Completion, Commands
@@ -1694,27 +1538,23 @@ Display the @sc{gnu} ``NO WARRANTY'' statement.
 
 When you run a program under @value{GDBN}, you must first generate
 debugging information when you compile it.
-@ifclear BARETARGET
-You may start @value{GDBN} with its arguments, if any, in an environment 
-of your choice.  You may redirect your program's input and output, debug an
-already running process, or kill a child process.
-@end ifclear
+
+You may start @value{GDBN} with its arguments, if any, in an environment
+of your choice.  If you are doing native debugging, you may redirect
+your program's input and output, debug an already running process, or
+kill a child process.
 
 @menu
 * Compilation::                 Compiling for debugging
 * Starting::                    Starting your program
-@ifclear BARETARGET
 * Arguments::                   Your program's arguments
 * Environment::                 Your program's environment
-@end ifclear
 
 * Working Directory::           Your program's working directory
 * Input/Output::                Your program's input and output
 * Attach::                      Debugging an already-running process
 * Kill Process::                Killing the child process
-@ifclear HPPA
 * Process Information::         Additional process information
-@end ifclear
 
 * Threads::                     Debugging programs with multiple threads
 * Processes::                   Debugging programs with multiple processes
@@ -1776,18 +1616,14 @@ format; if your @sc{gnu} C compiler has this option, do not use it.
 @kindex run
 @item run
 @itemx r
-Use the @code{run} command to start your program under @value{GDBN}.  You must
-first specify the program name
-@ifset VXWORKS
-(except on VxWorks)
-@end ifset
-with an argument to @value{GDBN} (@pxref{Invocation, ,Getting In and
-Out of @value{GDBN}}), or by using the @code{file} or @code{exec-file}
-command (@pxref{Files, ,Commands to specify files}).
+Use the @code{run} command to start your program under @value{GDBN}.
+You must first specify the program name (except on VxWorks) with an
+argument to @value{GDBN} (@pxref{Invocation, ,Getting In and Out of
+@value{GDBN}}), or by using the @code{file} or @code{exec-file} command
+(@pxref{Files, ,Commands to specify files}).
 
 @end table
 
-@ifclear BARETARGET
 If you are running your program in an execution environment that
 supports processes, @code{run} creates an inferior process and makes
 that process run your program.  (In environments without processes,
@@ -1835,7 +1671,6 @@ pipes to pass the output of the program you are debugging to another
 program; if you attempt this, @value{GDBN} is likely to wind up debugging the
 wrong program.
 @end table
-@end ifclear
 
 When you issue the @code{run} command, your program begins to execute
 immediately.  @xref{Stopping, ,Stopping and continuing}, for discussion
@@ -1848,7 +1683,6 @@ time @value{GDBN} read its symbols, @value{GDBN} discards its symbol
 table, and reads it again.  When it does this, @value{GDBN} tries to retain
 your current breakpoints.
 
-@ifclear BARETARGET
 @node Arguments, Environment, Starting, Running
 @section Your program's arguments
 
@@ -2099,14 +1933,8 @@ control whether or not you need to confirm by using the @code{set
 confirm} command (@pxref{Messages/Warnings, ,Optional warnings and
 messages}).
 
-@ifset HPPA
-@node Kill Process, Threads, Attach, Running
-@section Killing the child process
-@end ifset
-@ifclear HPPA
 @node Kill Process, Process Information, Attach, Running
 @section Killing the child process
-@end ifclear
 
 @table @code
 @kindex kill
@@ -2130,18 +1958,20 @@ next type @code{run}, @value{GDBN} notices that the file has changed, and
 reads the symbol table again (while trying to preserve your current
 breakpoint settings).
 
-@ifclear HPPA
 @node Process Information, Threads, Kill Process, Running
 @section Additional process information
 
 @kindex /proc
 @cindex process image
+
 Some operating systems provide a facility called @samp{/proc} that can
 be used to examine the image of a running process using file-system
 subroutines.  If @value{GDBN} is configured for an operating system with this
 facility, the command @code{info proc} is available to report on several
 kinds of information about the process running your program.  
 @code{info proc} works only on SVR4 systems that support @code{procfs}.
+This includes OSF/1 (Digital Unix), Solaris, Irix, and Unixware,
+but not HP-UX or Linux, for example.
 
 @table @code
 @kindex info proc
@@ -2172,16 +2002,9 @@ received.
 @item info proc all
 Show all the above information about the process.
 @end table
-@end ifclear
 
-@ifset HPPA
-@node Threads, Processes, Kill Process, Running
-@section Debugging programs with multiple threads
-@end ifset
-@ifclear HPPA
 @node Threads, Processes, Process Information, Running
 @section Debugging programs with multiple threads
-@end ifclear
 
 @cindex threads of execution
 @cindex multiple threads
@@ -2405,7 +2228,6 @@ programs with multiple threads.
 
 @xref{Set Watchpoints,,Setting watchpoints}, for information about
 watchpoints in programs with multiple threads.
-@end ifclear
 
 @ifclear HPPA
 @node Processes,  , Threads, Running
@@ -2499,40 +2321,26 @@ The principal purposes of using a debugger are so that you can stop your
 program before it terminates; or so that, if your program runs into
 trouble, you can investigate and find out why.
 
-Inside @value{GDBN}, your program may stop for any of several reasons, such
-as
-@ifclear BARETARGET
-a signal,
-@end ifclear
-a breakpoint, or reaching a new line after a @value{GDBN}
-command such as @code{step}.  You may then examine and change
-variables, set new breakpoints or remove old ones, and then continue
-execution.  Usually, the messages shown by @value{GDBN} provide ample
-explanation of the status of your program---but you can also explicitly
-request this information at any time.
+Inside @value{GDBN}, your program may stop for any of several reasons,
+such as a signal, a breakpoint, or reaching a new line after a
+@value{GDBN} command such as @code{step}.  You may then examine and
+change variables, set new breakpoints or remove old ones, and then
+continue execution.  Usually, the messages shown by @value{GDBN} provide
+ample explanation of the status of your program---but you can also
+explicitly request this information at any time.
 
 @table @code
 @kindex info program
 @item info program
 Display information about the status of your program: whether it is
-running or not,
-@ifclear BARETARGET
-what process it is,
-@end ifclear
-and why it stopped.
+running or not, what process it is, and why it stopped.
 @end table
 
 @menu
 * Breakpoints::                 Breakpoints, watchpoints, and catchpoints
 * Continuing and Stepping::     Resuming execution
-@ifset POSIX
 * Signals::                     Signals
-@end ifset
-
-@ifclear BARETARGET
 * Thread Stops::                Stopping and starting multi-thread programs
-@end ifclear
-
 @end menu
 
 @node Breakpoints, Continuing and Stepping, Stopping, Stopping
@@ -2597,13 +2405,9 @@ enable it again.
 * Disabling::                   Disabling breakpoints
 * Conditions::                  Break conditions
 * Break Commands::              Breakpoint command lists
-@ifclear CONLY
 * Breakpoint Menus::            Breakpoint menus
-@end ifclear
 
-@c  @ifclear BARETARGET
 @c  * Error in Breakpoints::        ``Cannot insert breakpoints''
-@c  @end ifclear
 @end menu
 
 @node Set Breaks, Set Watchpoints, Breakpoints, Breakpoints
@@ -2629,11 +2433,9 @@ You have several ways to say where the breakpoint should go.
 @table @code
 @item break @var{function}
 Set a breakpoint at entry to function @var{function}.  
-@ifclear CONLY
 When using source languages that permit overloading of symbols, such as
 C++, @var{function} may refer to more than one possible place to break.
 @xref{Breakpoint Menus,,Breakpoint menus}, for a discussion of that situation.
-@end ifclear
 
 @item break +@var{offset}
 @itemx break -@var{offset}
@@ -2733,11 +2535,9 @@ just like the breakpoints set with the @code{break} command.  You can
 delete them, disable them, or make them conditional the same way as any
 other breakpoint.
 
-@ifclear CONLY
 When debugging C++ programs, @code{rbreak} is useful for setting
 breakpoints on overloaded functions that are not members of any special
 classes.
-@end ifclear
 
 @kindex info breakpoints
 @cindex @code{$_} and @code{info breakpoints}
@@ -2912,7 +2712,6 @@ If you call a function interactively using @code{print} or @code{call},
 any watchpoints you have set will be inactive until GDB reaches another
 kind of breakpoint or the call completes.
 
-@ifclear BARETARGET
 @quotation
 @cindex watchpoints and threads
 @cindex threads and watchpoints
@@ -2938,7 +2737,6 @@ activity changes the expression.  (Hardware watchpoints, in contrast,
 watch an expression in all threads.)
 @end ifset
 @end quotation
-@end ifclear
 
 @node Set Catchpoints, Delete Breaks, Set Watchpoints, Breakpoints
 @subsection Setting catchpoints
@@ -3362,7 +3160,6 @@ cont
 end
 @end example
 
-@ifclear CONLY
 @node Breakpoint Menus,  , Break Commands, Breakpoints
 @subsection Breakpoint menus
 @cindex overloading
@@ -3408,7 +3205,6 @@ Use the "delete" command to delete unwanted
 (@value{GDBP})
 @end group
 @end smallexample
-@end ifclear
 
 @c  @ifclear BARETARGET
 @c  @node Error in Breakpoints
@@ -3450,16 +3246,10 @@ Use the "delete" command to delete unwanted
 completes normally.  In contrast, @dfn{stepping} means executing just
 one more ``step'' of your program, where ``step'' may mean either one
 line of source code, or one machine instruction (depending on what
-particular command you use).  Either when continuing
-or when stepping, your program may stop even sooner, due to 
-@ifset BARETARGET
-a breakpoint.
-@end ifset
-@ifclear BARETARGET
-a breakpoint or a signal.  (If due to a signal, you may want to use
-@code{handle}, or use @samp{signal 0} to resume execution.
-@xref{Signals, ,Signals}.)
-@end ifclear
+particular command you use).  Either when continuing or when stepping,
+your program may stop even sooner, due to a breakpoint or a signal.  (If
+due to a signal, you may want to use @code{handle}, or use @samp{signal
+0} to resume execution.  @xref{Signals, ,Signals}.)
 
 @table @code
 @kindex continue
@@ -3529,21 +3319,18 @@ was any debugging information about the routine.
 
 @item step @var{count}
 Continue running as in @code{step}, but do so @var{count} times.  If a
-breakpoint is reached,
-@ifclear BARETARGET
-or a signal not related to stepping occurs before @var{count} steps,
-@end ifclear
-stepping stops right away.
+breakpoint is reached, or a signal not related to stepping occurs before
+@var{count} steps, stepping stops right away.
 
 @kindex next
 @kindex n
 @item next @r{[}@var{count}@r{]}
 Continue to the next source line in the current (innermost) stack frame.
-This is similar to @code{step}, but function calls that appear within the line
-of code are executed without stopping.  Execution stops when control
-reaches a different line of code at the original stack level that was 
-executing when you gave the @code{next} command.  This command is abbreviated
-@code{n}.
+This is similar to @code{step}, but function calls that appear within
+the line of code are executed without stopping.  Execution stops when
+control reaches a different line of code at the original stack level
+that was executing when you gave the @code{next} command.  This command
+is abbreviated @code{n}.
 
 An argument @var{count} is a repeat count, as for @code{step}.
 
@@ -3645,7 +3432,6 @@ proceed until the function returns.
 An argument is a repeat count, as in @code{next}.
 @end table
 
-@ifset POSIX
 @node Signals, Thread Stops, Continuing and Stepping, Stopping
 @section Signals
 @cindex signals
@@ -3739,9 +3525,7 @@ execution; but your program would probably terminate immediately as
 a result of the fatal signal once it saw the signal.  To prevent this,
 you can continue with @samp{signal 0}.  @xref{Signaling, ,Giving your
 program a signal}. 
-@end ifset
 
-@ifclear BARETARGET
 @node Thread Stops,  , Signals, Stopping
 @section Stopping and starting multi-thread programs
 
@@ -3826,8 +3610,6 @@ GDB prompt away from the thread that you are debugging.
 Display the current scheduler locking mode.
 @end table
 
-@end ifclear
-
 
 @node Stack, Source, Stopping, Top
 @chapter Examining the Stack
@@ -4024,7 +3806,6 @@ impossible for @value{GDBN} to assign numbers properly to all frames.  In
 addition, this can be useful when your program has multiple stacks and
 switches between them.
 
-@ifclear H8EXCLUSIVE
 @ifclear HPPA
 On the SPARC architecture, @code{frame} needs two addresses to
 select an arbitrary frame: a frame pointer and a stack pointer.
@@ -4038,7 +3819,6 @@ pointer, a program counter, and a memory stack pointer.
 @c SETUP_ARBITRARY_FRAME in the tm-*.h files.  The above is up to date
 @c as of 27 Jan 1994.
 @end ifclear
-@end ifclear
 
 @kindex up
 @item up @var{n}
@@ -4149,7 +3929,6 @@ Print the local variables of the selected frame, each on a separate
 line.  These are all variables (declared either static or automatic)
 accessible at the point of execution of the selected frame.
 
-@ifclear CONLY
 @ifclear HPPA
 @kindex info catch
 @cindex catch exceptions
@@ -4161,7 +3940,6 @@ exception handlers, visit the associated frame (using the @code{up},
 @code{down}, or @code{frame} commands); then type @code{info catch}.
 @xref{Set Catchpoints, , Setting catchpoints}.
 @end ifclear
-@end ifclear
 @end table
 
 @node Alpha/MIPS Stack,  , Frame Info, Stack
@@ -4210,18 +3988,13 @@ the line where it stopped.  Likewise, when you select a stack frame
 execution in that frame has stopped.  You can print other portions of
 source files by explicit command.
 
-@ifclear DOSHOST
-If you use @value{GDBN} through its @sc{gnu} Emacs interface, you may prefer 
-to use
-Emacs facilities to view source; @pxref{Emacs, ,Using @value{GDBN} under @sc{gnu} Emacs}.
-@end ifclear
+If you use @value{GDBN} through its @sc{gnu} Emacs interface, you may
+prefer to use Emacs facilities to view source; @pxref{Emacs, ,Using
+@value{GDBN} under @sc{gnu} Emacs}.
 
 @menu
 * List::                        Printing source lines
-@ifclear DOSHOST
 * Search::                      Searching source files
-@end ifclear
-
 * Source Path::                 Specifying source directories
 * Machine Code::                Source and machine code
 @end menu
@@ -4343,7 +4116,6 @@ Specifies the line containing the program address @var{address}.
 @var{address} may be any expression.
 @end table
 
-@ifclear DOSHOST
 @node Search, Source Path, List, Source
 @section Searching source files
 @cindex searching
@@ -4369,7 +4141,6 @@ with the one before the last line listed and going backward, for a match
 for @var{regexp}.  It lists the line that is found.  You can abbreviate
 this command as @code{rev}.
 @end table
-@end ifclear
 
 @node Source Path, Machine Code, Search, Source
 @section Specifying source directories
@@ -4510,7 +4281,6 @@ surrounding this value.  Two arguments specify a range of addresses
 (first inclusive, second exclusive) to dump.
 @end table
 
-@ifclear H8EXCLUSIVE
 The following example shows the disassembly of a range of addresses of
 HP PA-RISC 2.0 code:
 
@@ -4527,28 +4297,6 @@ Dump of assembler code from 0x32c4 to 0x32e4:
 0x32e0 <main+232>:      ldil 0x3000,r31
 End of assembler dump.
 @end smallexample
-@end ifclear
-
-@ifset H8EXCLUSIVE
-For example, here is the beginning of the output for the
-disassembly of a function @code{fact}:
-
-
-@smallexample
-(@value{GDBP}) disas fact
-Dump of assembler code for function fact:
-to 0x808c:
-0x802c <fact>: 6d f2           mov.w r2,@@-r7
-0x802e <fact+2>:  6d f3                mov.w r3,@@-r7
-0x8030 <fact+4>:  6d f6                mov.w r6,@@-r7
-0x8032 <fact+6>:  0d 76                mov.w r7,r6
-0x8034 <fact+8>:  6f 70 00 08  mov.w @@(0x8,r7),r0
-0x8038 <fact+12>  19 11                sub.w   r1,r1
- .
- .
- . 
-@end smallexample
-@end ifset
 
 Some architectures have more than one commonly-used set of instruction
 mnemonics or other syntax.
@@ -4580,12 +4328,10 @@ The default is @code{i386}.
 @c document because it is nonstandard...  Under Epoch it displays in a
 @c different window or something like that.
 The usual way to examine data in your program is with the @code{print}
-command (abbreviated @code{p}), or its synonym @code{inspect}.  
-@ifclear CONLY
-It evaluates and prints the value of an expression of the language your
-program is written in (@pxref{Languages, ,Using @value{GDBN} with Different
-Languages}).
-@end ifclear
+command (abbreviated @code{p}), or its synonym @code{inspect}.  It
+evaluates and prints the value of an expression of the language your
+program is written in (@pxref{Languages, ,Using @value{GDBN} with
+Different Languages}).
 
 @table @code
 @item print @var{exp}
@@ -4607,13 +4353,10 @@ A more low-level way of examining data is with the @code{x} command.
 It examines data in memory at a specified address and prints it in a
 specified format.  @xref{Memory, ,Examining memory}.
 
-If you are interested in information about types, or about how the fields
-of a struct
-@ifclear CONLY
-or class
-@end ifclear
-are declared, use the @code{ptype @var{exp}}
-command rather than @code{print}. @xref{Symbols, ,Examining the Symbol Table}.
+If you are interested in information about types, or about how the
+fields of a struct or class are declared, use the @code{ptype @var{exp}}
+command rather than @code{print}. @xref{Symbols, ,Examining the Symbol
+Table}.
 
 @menu
 * Expressions::                 Expressions
@@ -4626,10 +4369,7 @@ command rather than @code{print}. @xref{Symbols, ,Examining the Symbol Table}.
 * Value History::               Value history
 * Convenience Vars::            Convenience variables
 * Registers::                   Registers
-@ifclear HAVE-FLOAT
 * Floating Point Hardware::     Floating point hardware
-@end ifclear
-
 @end menu
 
 @node Expressions, Variables, Data, Data
@@ -4648,7 +4388,6 @@ the user.  The syntax is @var{@{element, element@dots{}@}}.  For example,
 you can now use the command @code{print @{1, 2, 3@}} to build up an array in 
 memory that is malloc'd in the target program.
 
-@ifclear CONLY
 Because C is so widespread, most of the expressions shown in examples in
 this manual are in C.  @xref{Languages, , Using @value{GDBN} with Different
 Languages}, for information on how to use expressions in other
@@ -4661,7 +4400,6 @@ Casts are supported in all languages, not just in C, because it is so
 useful to cast a number into a pointer in order to examine a structure
 at that address in memory.
 @c FIXME: casts supported---Mod2 true?
-@end ifclear
 
 @value{GDBN} supports these operators, in addition to those common
 to programming languages:
@@ -4758,14 +4496,12 @@ to print a global value of @code{x} defined in @file{f2.c}:
 (@value{GDBP}) p 'f2.c'::x
 @end example
 
-@ifclear CONLY
 @cindex C++ scope resolution
 This use of @samp{::} is very rarely in conflict with the very similar
 use of the same notation in C++.  @value{GDBN} also supports use of the C++
 scope resolution operator in @value{GDBN} expressions.
 @c FIXME: Um, so what happens in one of those rare cases where it's in
 @c conflict??  --mew
-@end ifclear
 
 @cindex wrong values
 @cindex variable values, wrong
@@ -5382,7 +5118,6 @@ $1 = @{it = Tree, form = @{...@}@}
 @end smallexample
 @end table
 
-@ifclear CONLY
 @need 1000
 @noindent
 These settings are of interest when debugging C++ programs:
@@ -5492,7 +5227,6 @@ Do not pretty print C++ virtual function tables.
 @item show print vtbl
 Show whether C++ virtual function tables are pretty printed, or not.
 @end table
-@end ifclear
 
 @node Value History, Convenience Vars, Print Settings, Data
 @section Value history
@@ -5756,7 +5490,6 @@ code generated by your compiler.  If some registers are not saved, or if
 @value{GDBN} is unable to locate the saved registers, the selected stack
 frame makes no difference.
 
-@ifset AMD29K
 @table @code
 @kindex set rstack_high_address
 @cindex AMD 29K register stack
@@ -5777,9 +5510,7 @@ hexadecimal.
 Display the current limit of the register stack, on AMD 29000 family
 processors.
 @end table
-@end ifset
 
-@ifclear HAVE-FLOAT
 @node Floating Point Hardware,  , Registers, Data
 @section Floating point hardware
 @cindex floating point
@@ -5795,21 +5526,17 @@ point unit.  The exact contents and layout vary depending on the
 floating point chip.  Currently, @samp{info float} is supported on
 the ARM and x86 machines.
 @end table
-@end ifclear
 
-@ifclear CONLY
 @node Languages, Symbols, Data, Top
 @chapter Using @value{GDBN} with Different Languages
 @cindex languages
 
-@ifset MOD2
 Although programming languages generally have common aspects, they are
 rarely expressed in the same manner.  For instance, in ANSI C,
 dereferencing a pointer @code{p} is accomplished by @code{*p}, but in
 Modula-2, it is accomplished by @code{p^}.  Values can also be
 represented (and displayed) differently.  Hex numbers in C appear as 
 @samp{0x1ae}, while in Modula-2 they appear as @samp{1AEH}.
-@end ifset
 
 @cindex working language
 Language-specific information is built into @value{GDBN} for some languages,
@@ -5822,10 +5549,7 @@ language}.
 @menu
 * Setting::                     Switching between source languages
 * Show::                        Displaying the language
-@ifset MOD2
 * Checks::                      Type and range checks
-@end ifset
-
 * Support::                     Supported languages
 @end menu
 
@@ -5891,10 +5615,8 @@ Fortran source file
 CHILL source file.
 @end ifclear
 
-@ifset MOD2
 @item .mod
 Modula-2 source file
-@end ifset
 
 @item .s
 @itemx .S
@@ -5916,22 +5638,9 @@ your program.
 If you wish, you may set the language manually.  To do this, issue the
 command @samp{set language @var{lang}}, where @var{lang} is the name of
 a language, such as 
-@ifclear MOD2
-@code{c}.
-@end ifclear
-@ifset MOD2
 @code{c} or @code{modula-2}.
-@end ifset
 For a list of the supported languages, type @samp{set language}.
 
-@ifclear MOD2
-Setting the language manually prevents @value{GDBN} from updating the
-working language automatically.  For example, if you used the @code{c}
-setting to debug a C++ program, names might not be demangled properly,
-overload resolution would not work, user-defined operators might not be
-interpreted correctly, and so on.
-@end ifclear
-@ifset MOD2
 Setting the language manually prevents @value{GDBN} from updating the working
 language automatically.  This can lead to confusion if you try
 to debug a program when the working language is not the same as the
@@ -5949,7 +5658,6 @@ might not have the effect you intended.  In C, this means to add
 @code{b} and @code{c} and place the result in @code{a}.  The result
 printed would be the value of @code{a}.  In Modula-2, this means to compare
 @code{a} to the result of @code{b+c}, yielding a @code{BOOLEAN} value.
-@end ifset
 
 @node Automatically,  , Manually, Setting
 @subsection Having @value{GDBN} infer the source language
@@ -5970,14 +5678,8 @@ written in one source language can be used by a main program written in
 a different source language.  Using @samp{set language auto} in this
 case frees you from having to set the working language manually.
 
-@ifset MOD2
 @node Show, Checks, Setting, Languages
 @section Displaying the language
-@end ifset
-@ifclear MOD2
-@node Show, Support, Setting, Languages
-@section Displaying the language
-@end ifclear
 
 The following commands help you find out which language is the
 working language, and also what language source files were written in.
@@ -6018,7 +5720,6 @@ the source language @var{language}.
 List all the filename extensions and the associated languages.
 @end table
 
-@ifset MOD2
 @node Checks, Support, Show, Languages
 @section Type and range checking
 
@@ -6181,23 +5882,11 @@ systems).
 Show the current setting of the range checker, and whether or not it is
 being set automatically by @value{GDBN}.
 @end table
-@end ifset
 
-@ifset MOD2
 @node Support,  , Checks, Languages
 @section Supported languages
-@end ifset
-@ifclear MOD2
-@node Support,  , Show, Languages
-@section Supported languages
-@end ifclear
 
-@ifset MOD2
 @value{GDBN} supports C, C++, Fortran, Chill, assembly, and Modula-2.
-@end ifset
-@ifclear MOD2
-@value{GDBN} supports C, C++, Fortran, Chill, and assembly.
-@end ifclear
 Some @value{GDBN} features may be used in expressions regardless of the
 language you use: the @value{GDBN} @code{@@} and @code{::} operators,
 and the @samp{@{type@}addr} construct (@pxref{Expressions,
@@ -6212,27 +5901,21 @@ formats should look like for different languages.  There are many good
 books written on each of these languages; please look to these for a
 language reference or tutorial.
 
-@ifset MOD2
 @menu
-* C::                           C and C++
+* C::           C and C++
 * Modula-2::                    Modula-2
 @end menu
 
 @node C, Modula-2, , Support
 @subsection C and C++
+
 @cindex C and C++
 @cindex expressions in C or C++
-@end ifset
 
 Since C and C++ are so closely related, many features of @value{GDBN} apply
 to both languages.  Whenever this is the case, we discuss those languages
 together.
 
-@ifclear MOD2
-@c Cancel this below, under same condition, at end of this chapter!
-@raisesections
-@end ifclear
-
 @ifclear HPPA
 @cindex C++
 @kindex g++
@@ -6265,56 +5948,27 @@ explicitly with the @code{g++} command-line options @samp{-gstabs} or
 Program or @sc{gnu} CC, gcc.info, Using @sc{gnu} CC}, for more
 information.
 @end ifset
-@end ifclear
-
-@ifset CONLY
-@node C, Symbols, Data, Top
-@chapter C Language Support
-@cindex C language
-@cindex expressions in C
 
-Information specific to the C language is built into @value{GDBN} so that you
-can use C expressions while debugging.  This also permits @value{GDBN} to
-output values in a manner consistent with C conventions.
-
-@menu
-* C Operators::                 C operators
-@end menu
-@end ifset
-
-@ifclear CONLY
 @menu
 * C Operators::                 C and C++ operators
 * C Constants::                 C and C++ constants
-* Cplus expressions::           C++ expressions
+* C plus plus expressions::     C++ expressions
 * C Defaults::                  Default settings for C and C++
-@ifset MOD2
 * C Checks::                    C and C++ type and range checks
-@end ifset
-
 * Debugging C::                 @value{GDBN} and C
 * Debugging C plus plus::       @value{GDBN} features for C++
 @end menu
-@end ifclear
 
-@ifclear CONLY
-@cindex C and C++ operators
 @node C Operators, C Constants, , C
 @subsubsection C and C++ operators
-@end ifclear
-@ifset CONLY
-@cindex C operators
-@node C Operators, C Constants, C, C
-@section C operators
-@end ifset
+
+@cindex C and C++ operators
 
 Operators must be defined on values of specific types.  For instance,
 @code{+} is defined on numbers, but not on structures.  Operators are
 often defined on groups of types.  
 
-@ifclear CONLY
 For the purposes of C and C++, the following definitions hold:
-@end ifclear
 
 @itemize @bullet
 @item
@@ -6416,13 +6070,11 @@ Pointer dereferencing.  Defined on pointer types.  Same precedence as
 @item &
 Address operator.  Defined on variables.  Same precedence as @code{++}.
 
-@ifclear CONLY
 For debugging C++, @value{GDBN} implements a use of @samp{&} beyond what is
 allowed in the C++ language itself: you can use @samp{&(&@var{ref})}
 (or, if you prefer, simply @samp{&&@var{ref}}) to examine the address
 where a C++ reference variable (declared with @samp{&@var{ref}}) is
 stored.
-@end ifclear
 
 @item -
 Negative.  Defined on integral and floating-point types.  Same
@@ -6455,22 +6107,14 @@ Array indexing.  @code{@var{a}[@var{i}]} is defined as
 @item ()
 Function parameter list.  Same precedence as @code{->}.
 
-@ifclear CONLY
 @item ::
-C++ scope resolution operator.  Defined on
-@code{struct}, @code{union}, and @code{class} types.
-@end ifclear
+C++ scope resolution operator.  Defined on @code{struct}, @code{union},
+and @code{class} types.
 
 @item ::
-Doubled colons
-@ifclear CONLY
-also
-@end ifclear
-represent the @value{GDBN} scope operator (@pxref{Expressions,
-,Expressions}).
-@ifclear CONLY
-Same precedence as @code{::}, above.
-@end ifclear
+Doubled colons also represent the @value{GDBN} scope operator
+(@pxref{Expressions, ,Expressions}).  Same precedence as @code{::},
+above.
 @end table
 
 @ifset HPPA
@@ -6479,32 +6123,17 @@ attempts to invoke the redefined version instead of using the operator's
 predefined meaning.
 @end ifset
 
-@ifclear CONLY
 @menu
 * C Constants::             
 @end menu
 
-@ifset MOD2
-@node C Constants, Cplus expressions, C Operators, C
+@node C Constants, C plus plus expressions, C Operators, C
 @subsubsection C and C++ constants
-@end ifset
-@ifclear MOD2
-@node C Constants, Cplus expressions, C Operators, Support
-@subsubsection C and C++ constants
-@end ifclear
 
 @cindex C and C++ constants
-@value{GDBN} allows you to express the constants of C and C++ in the
-following ways:
-@end ifclear
-@ifset CONLY
-@cindex C constants
-@node C Constants, Debugging C, C Operators, C
-@section C constants
 
-@value{GDBN} allows you to express the constants of C in the
+@value{GDBN} allows you to express the constants of C and C++ in the
 following ways:
-@end ifset
 
 @itemize @bullet
 @item
@@ -6550,25 +6179,16 @@ integers, @samp{@{@{1,2@}, @{3,4@}, @{5,6@}@}} is a three-by-two array,
 and @samp{@{&"hi", &"there", &"fred"@}} is a three-element array of pointers.
 @end itemize
 
-@ifclear CONLY
 @menu
-* Cplus expressions::           
+* C plus plus expressions::           
 * C Defaults::                  
-@ifset MOD2
 * C Checks::                    
-@end ifset
 
 * Debugging C::                 
 @end menu
 
-@ifset MOD2
-@node Cplus expressions, C Defaults, C Constants, C
-@subsubsection C++ expressions
-@end ifset
-@ifclear MOD2
-@node Cplus expressions, C Defaults, C Constants, Support
+@node C plus plus expressions, C Defaults, C Constants, C
 @subsubsection C++ expressions
-@end ifclear
 
 @cindex expressions in C++
 @value{GDBN} expression handling can interpret most C++ expressions.
@@ -6687,14 +6307,9 @@ printing out virtual bases of objects, calling functions in a base
 subobject, casting objects, and invoking user-defined operators.
 @end ifset
 
-@ifset MOD2
-@node C Defaults, C Checks, Cplus expressions, C
+@node C Defaults, C Checks, C plus plus expressions, C
 @subsubsection C and C++ defaults
-@end ifset
-@ifclear MOD2
-@node C Defaults, Debugging C, Cplus expressions, Support
-@subsubsection C and C++ defaults
-@end ifclear
+
 @cindex C and C++ defaults
 
 @ifclear HPPA
@@ -6711,12 +6326,13 @@ these files, it sets the working language to C or C++.
 @xref{Automatically, ,Having @value{GDBN} infer the source language},
 for further details.
 
-@ifset MOD2
 @c Type checking is (a) primarily motivated by Modula-2, and (b)
 @c unimplemented.  If (b) changes, it might make sense to let this node
 @c appear even if Mod-2 does not, but meanwhile ignore it. roland 16jul93.
+
 @node C Checks, Debugging C, C Defaults, C Constants
 @subsubsection C and C++ type and range checks
+
 @cindex C and C++ checks
 
 By default, when @value{GDBN} parses C or C++ expressions, type checking
@@ -6745,52 +6361,28 @@ compilers.)
 Range checking, if turned on, is done on mathematical operations.  Array
 indices are not checked, since they are often used to index a pointer
 that is not itself an array.
-@end ifset
-@end ifclear
 
-@ifclear CONLY
-@ifset MOD2
 @node Debugging C, Debugging C plus plus, C Checks, C
 @subsubsection @value{GDBN} and C
-@end ifset
-@ifclear MOD2
-@node Debugging C, Debugging C plus plus, C Defaults, Support
-@subsubsection @value{GDBN} and C
-@end ifclear
-@end ifclear
-@ifset CONLY
-@node Debugging C,  , C Constants, C
-@section @value{GDBN} and C
-@end ifset
 
 The @code{set print union} and @code{show print union} commands apply to
 the @code{union} type.  When set to @samp{on}, any @code{union} that is
-inside a @code{struct}
-@ifclear CONLY
-or @code{class}
-@end ifclear
-is also printed.
-Otherwise, it appears as @samp{@{...@}}.
+inside a @code{struct} or @code{class} is also printed.  Otherwise, it
+appears as @samp{@{...@}}.
 
 The @code{@@} operator aids in the debugging of dynamic arrays, formed
 with pointers and a memory allocation function.  @xref{Expressions,
 ,Expressions}.
 
-@ifclear CONLY
 @menu
 * Debugging C plus plus::       
 @end menu
 
-@ifset MOD2
 @node Debugging C plus plus,  , Debugging C, C
 @subsubsection @value{GDBN} features for C++
-@end ifset
-@ifclear MOD2
-@node Debugging C plus plus,  , Debugging C, Support
-@subsubsection @value{GDBN} features for C++
-@end ifclear
 
 @cindex commands for C++
+
 Some @value{GDBN} commands are particularly useful with C++, and some are
 designed specifically for use with C++.  Here is a summary:
 
@@ -6848,7 +6440,7 @@ ANSI C++ compiler (@code{aCC}).)
 Enable overload resolution for C++ expression evaluation.  The default
 is on.  For overloaded functions, @value{GDBN} evaluates the arguments
 and searches for a function whose signature matches the argument types,
-using the standard C++ conversion rules (@pxref{Cplus expressions, ,C++
+using the standard C++ conversion rules (@pxref{C plus plus expressions, ,C++
 expressions} for details).  If it cannot find a match, it emits a
 message.
 
@@ -6870,14 +6462,10 @@ also use the @value{GDBN} command-line word completion facilities to list the
 available choices, or to finish the type list for you.
 @xref{Completion,, Command completion}, for details on how to do this.
 @end table
-@ifclear MOD2
-@c cancels "raisesections" under same conditions near bgn of chapter
-@lowersections
-@end ifclear
 
-@ifset MOD2
-@node Modula-2,  ,C , Support
+@node Modula-2,  , C, Support
 @subsection Modula-2
+
 @cindex Modula-2
 
 The extensions made to @value{GDBN} to support Modula-2 only support
@@ -7316,8 +6904,6 @@ address can be specified by an integral constant, the construct
 @cindex @code{#} in Modula-2
 In @value{GDBN} scripts, the Modula-2 inequality operator @code{#} is
 interpreted as the beginning of a comment.  Use @code{<>} instead.
-@end ifset
-@end ifclear
 
 @node Symbols, Altering, Languages, Top
 @chapter Examining the Symbol Table
@@ -7374,12 +6960,9 @@ Print the data type of @code{$}, the last value in the value history.
 @kindex ptype
 @item ptype @var{typename}
 Print a description of data type @var{typename}.  @var{typename} may be
-the name of a type, or for C code it may have the form
-@ifclear CONLY
-@samp{class @var{class-name}},
-@end ifclear
-@samp{struct @var{struct-tag}}, @samp{union @var{union-tag}} or
-@samp{enum @var{enum-tag}}.
+the name of a type, or for C code it may have the form @samp{class
+@var{class-name}}, @samp{struct @var{struct-tag}}, @samp{union
+@var{union-tag}} or @samp{enum @var{enum-tag}}.
 
 @item ptype @var{exp}
 @itemx ptype
@@ -7476,13 +7059,10 @@ which match the regular-expression @var{regexp}.
 @ifclear HPPA
 @cindex reloading symbols
 Some systems allow individual object files that make up your program to
-be replaced without stopping and restarting your program.
-@ifset VXWORKS
-For example, in VxWorks you can simply recompile a defective object file
-and keep on running.
-@end ifset
-If you are running on one of these systems, you can allow @value{GDBN} to
-reload the symbols for automatically relinked modules:
+be replaced without stopping and restarting your program.  For example,
+in VxWorks you can simply recompile a defective object file and keep on
+running.  If you are running on one of these systems, you can allow
+@value{GDBN} to reload the symbols for automatically relinked modules:
 
 @table @code
 @kindex set symbol-reloading
@@ -7561,22 +7141,13 @@ experiment, using the @value{GDBN} features for altering execution of the
 program.
 
 For example, you can store new values into variables or memory
-locations,
-@ifclear BARETARGET
-give your program a signal, restart it
-@end ifclear
-@ifset BARETARGET
-restart your program
-@end ifset
-at a different address, or even return prematurely from a function.
+locations, give your program a signal, restart it at a different
+address, or even return prematurely from a function.
 
 @menu
 * Assignment::                  Assignment to variables
 * Jumping::                     Continuing at a different address
-@ifclear BARETARGET
 * Signaling::                   Giving your program a signal
-@end ifclear
-
 * Returning::                   Returning from a function
 * Calling::                     Calling your program's functions
 * Patching::                    Patching your program
@@ -7597,10 +7168,8 @@ print x=4
 @noindent
 stores the value 4 into the variable @code{x}, and then prints the
 value of the assignment expression (which is 4).  
-@ifclear CONLY
 @xref{Languages, ,Using @value{GDBN} with Different Languages}, for more
 information on operators in supported languages.
-@end ifclear
 
 @kindex set variable
 @cindex variables, setting
@@ -7746,7 +7315,6 @@ up---perhaps with more breakpoints set---over a portion of a program
 that has already executed, in order to examine its execution in more
 detail.
 
-@ifclear BARETARGET
 @c @group
 @node Signaling, Returning, Jumping, Altering
 @section Giving your program a signal
@@ -7776,7 +7344,6 @@ causes @value{GDBN} to decide what to do with the signal depending on
 the signal handling tables (@pxref{Signals}).  The @code{signal} command
 passes the signal directly to your program.
 
-@end ifclear
 
 @node Returning, Calling, Signaling, Altering
 @section Returning from a function
@@ -7835,20 +7402,15 @@ that have separate instruction and data spaces.
 
 @node Patching,  , Calling, Altering
 @section Patching programs
+
 @cindex patching binaries
 @cindex writing into executables
-@ifclear BARETARGET
 @cindex writing into corefiles
-@end ifclear
 
-By default, @value{GDBN} opens the file containing your program's executable
-code
-@ifclear BARETARGET
-(or the corefile)
-@end ifclear
-read-only.  This prevents accidental alterations
-to machine code; but it also prevents you from intentionally patching
-your program's binary.
+By default, @value{GDBN} opens the file containing your program's
+executable code (or the corefile) read-only.  This prevents accidental
+alterations to machine code; but it also prevents you from intentionally
+patching your program's binary.
 
 If you'd like to be able to patch the binary, you can specify that
 explicitly with the @code{set write} command.  For example, you might
@@ -7859,39 +7421,27 @@ repairs.
 @kindex set write
 @item set write on
 @itemx set write off
-If you specify @samp{set write on}, @value{GDBN} opens executable 
-@ifclear BARETARGET
-and core
-@end ifclear
-files for both reading and writing; if you specify @samp{set write
+If you specify @samp{set write on}, @value{GDBN} opens executable and
+core files for both reading and writing; if you specify @samp{set write
 off} (the default), @value{GDBN} opens them read-only.
 
 If you have already loaded a file, you must load it again (using the
-@code{exec-file}
-@ifclear BARETARGET
-or @code{core-file}
-@end ifclear
-command) after changing @code{set write}, for your new setting to take
-effect.
+@code{exec-file} or @code{core-file} command) after changing @code{set
+write}, for your new setting to take effect.
 
 @item show write
 @kindex show write
-Display whether executable files 
-@ifclear BARETARGET
-and core files 
-@end ifclear
-are opened for writing as well as reading.
+Display whether executable files and core files are opened for writing
+as well as reading.
 @end table
 
 @node GDB Files, Targets, Altering, Top
 @chapter @value{GDBN} Files
 
-@value{GDBN} needs to know the file name of the program to be debugged, both in
-order to read its symbol table and in order to start your program.  
-@ifclear BARETARGET
-To debug a core dump of a previous run, you must also tell @value{GDBN}
-the name of the core dump file.
-@end ifclear
+@value{GDBN} needs to know the file name of the program to be debugged,
+both in order to read its symbol table and in order to start your
+program.  To debug a core dump of a previous run, you must also tell
+@value{GDBN} the name of the core dump file.
 
 @menu
 * Files::                       Commands to specify files
@@ -7900,20 +7450,14 @@ the name of the core dump file.
 
 @node Files, Symbol Errors, GDB Files, GDB Files
 @section Commands to specify files
-@cindex symbol table
 
-@ifclear BARETARGET
+@cindex symbol table
 @cindex core dump file
-You may want to specify executable and core dump file names.
-The usual way to do this is at start-up time, using the arguments to 
-@value{GDBN}'s start-up commands (@pxref{Invocation, ,
-Getting In and Out of @value{GDBN}}).
-@end ifclear
-@ifset BARETARGET
-The usual way to specify an executable file name is with
-the command argument given when you start @value{GDBN}, (@pxref{Invocation,
-,Getting In and Out of @value{GDBN}}.
-@end ifset
+
+You may want to specify executable and core dump file names.  The usual
+way to do this is at start-up time, using the arguments to
+@value{GDBN}'s start-up commands (@pxref{Invocation, , Getting In and
+Out of @value{GDBN}}).
 
 Occasionally it is necessary to change to a different file during a
 @value{GDBN} session.  Or you may run @value{GDBN} and forget to specify
@@ -8017,7 +7561,6 @@ load symbol table information, if you want to be sure @value{GDBN} has the
 entire symbol table available.  
 @end ifclear
 
-@ifclear BARETARGET
 @ifclear HPPA
 If memory-mapped files are available on your system through the
 @code{mmap} system call, you can use another option, @samp{-mapped}, to
@@ -8040,7 +7583,6 @@ needed.
 The @file{.syms} file is specific to the host machine where you run
 @value{GDBN}.  It holds an exact image of the internal @value{GDBN}
 symbol table.  It cannot be shared across multiple host platforms.
-@end ifclear
 
 @c FIXME: for now no mention of directories, since this seems to be in
 @c flux.  13mar1992 status is that in theory GDB would look either in
@@ -8062,13 +7604,12 @@ executable file itself for other parts.
 to be used.
 
 Note that the core file is ignored when your program is actually running
-under @value{GDBN}.  So, if you have been running your program and you wish to
-debug a core file instead, you must kill the subprocess in which the
-program is running.  To do this, use the @code{kill} command
+under @value{GDBN}.  So, if you have been running your program and you
+wish to debug a core file instead, you must kill the subprocess in which
+the program is running.  To do this, use the @code{kill} command
 (@pxref{Kill Process, ,Killing the child process}).
 @end ifclear
 
-@ifclear BARETARGET
 @ifclear HPPA
 @kindex add-symbol-file
 @cindex dynamic linking
@@ -8100,7 +7641,6 @@ operating system for the Motorola 88k.  @value{GDBN} automatically looks for
 shared libraries, however if @value{GDBN} does not find yours, you can run 
 @code{add-shared-symbol-file}.  It takes no arguments.
 @end ifclear
-@end ifclear
 
 @ifclear HPPA
 @kindex section
@@ -8117,25 +7657,19 @@ addresses.
 @kindex info target
 @item info files
 @itemx info target
-@code{info files} and @code{info target} are synonymous; both print
-the current target (@pxref{Targets, ,Specifying a Debugging Target}),
-including the
-@ifclear BARETARGET
-names of the executable and core dump files
-@end ifclear
-@ifset BARETARGET
-name of the executable file
-@end ifset
-currently in use by @value{GDBN}, and the files from which symbols were
-loaded.  The command @code{help target} lists all possible targets
-rather than current ones.
+@code{info files} and @code{info target} are synonymous; both print the
+current target (@pxref{Targets, ,Specifying a Debugging Target}),
+including the names of the executable and core dump files currently in
+use by @value{GDBN}, and the files from which symbols were loaded.  The
+command @code{help target} lists all possible targets rather than
+current ones.
+
 @end table
 
 All file-specifying commands allow both absolute and relative file names
 as arguments.  @value{GDBN} always converts the file name to an absolute file
 name and remembers it that way.
 
-@ifclear BARETARGET
 @cindex shared libraries
 @ifclear HPPA
 @c added HP-UX -- Kim (HP writer)
@@ -8207,8 +7741,6 @@ Display the current autoloading size threshold, in megabytes.
 @end table
 @end ifset
 
-@end ifclear
-
 @node Symbol Errors,  , Files, GDB Files
 @section Errors reading symbol files
 
@@ -8272,47 +7804,40 @@ with this name.
 
 @item unknown symbol type @code{0x@var{nn}}
 
-The symbol information contains new data types that @value{GDBN} does not yet
-know how to read.  @code{0x@var{nn}} is the symbol type of the misunderstood
-information, in hexadecimal.
+The symbol information contains new data types that @value{GDBN} does
+not yet know how to read.  @code{0x@var{nn}} is the symbol type of the
+misunderstood information, in hexadecimal.
 
-@value{GDBN} circumvents the error by ignoring this symbol information.  This
-usually allows you to debug your program, though certain symbols
+@value{GDBN} circumvents the error by ignoring this symbol information.
+This usually allows you to debug your program, though certain symbols
 are not accessible.  If you encounter such a problem and feel like
-debugging it, you can debug @code{@value{GDBP}} with itself, breakpoint on
-@code{complain}, then go up to the function @code{read_dbx_symtab} and
-examine @code{*bufp} to see the symbol.
+debugging it, you can debug @code{@value{GDBP}} with itself, breakpoint
+on @code{complain}, then go up to the function @code{read_dbx_symtab}
+and examine @code{*bufp} to see the symbol.
 
 @item stub type has NULL name
-@value{GDBN} could not find the full definition for
-@ifclear CONLY
-a struct or class.
-@end ifclear
-@ifset CONLY
-a struct.
-@end ifset
 
-@ifclear CONLY
-@item const/volatile indicator missing (ok if using g++ v1.x), got@dots{}
+@value{GDBN} could not find the full definition for a struct or class.
 
+@item const/volatile indicator missing (ok if using g++ v1.x), got@dots{}
 The symbol information for a C++ member function is missing some
-information that recent versions of the compiler should have output
-for it.
-@end ifclear
+information that recent versions of the compiler should have output for
+it.
 
 @item info mismatch between compiler and debugger
 
 @value{GDBN} could not parse a type specification output by the compiler.
+
 @end table
 
 @node Targets, Controlling GDB, GDB Files, Top
 @chapter Specifying a Debugging Target
+
 @cindex debugging target
 @kindex target
 
 A @dfn{target} is the execution environment occupied by your program.
 @ifclear HPPA
-@ifclear BARETARGET
 Often, @value{GDBN} runs in the same host environment as your program; in
 that case, the debugging target is specified as a side effect when you
 use the @code{file} or @code{core} commands.  When you need more
@@ -8320,7 +7845,6 @@ flexibility---for example, running @value{GDBN} on a physically separate
 host, or controlling a standalone system over a serial port or a
 realtime system over a TCP/IP connection---you 
 @end ifclear
-@end ifclear
 @ifset HPPA
 On HP-UX systems, @value{GDBN} has been configured to support debugging
 of processes running on the PA-RISC architecture.  This means that the
@@ -8342,36 +7866,31 @@ execution
 
 @value{GDBN} on HP-UX has not been configured to support remote
 debugging, or to support programs running on other platforms. You
-@end ifset
-@ifset BARETARGET
-You
-@end ifset
 can use the @code{target} command to specify one of the target types
 configured for @value{GDBN} (@pxref{Target Commands, ,Commands for managing
 targets}).
+@end ifset
 
 @menu
 * Active Targets::              Active targets
 * Target Commands::             Commands for managing targets
-@ifset REMOTESTUB
 * Byte Order::                  Choosing target byte order
 * Remote::                      Remote debugging
-@end ifset
 
 @end menu
 
 @node Active Targets, Target Commands, Targets, Targets
 @section Active targets
+
 @cindex stacking targets
 @cindex active targets
 @cindex multiple targets
 
-@ifclear BARETARGET
 There are three classes of targets: processes, core files, and
-executable files.  @value{GDBN} can work concurrently on up to three active
-targets, one in each class.  This allows you to (for example) start a
-process and inspect its activity without abandoning your work on a core
-file.
+executable files.  @value{GDBN} can work concurrently on up to three
+active targets, one in each class.  This allows you to (for example)
+start a process and inspect its activity without abandoning your work on
+a core file.
 
 For example, if you execute @samp{gdb a.out}, then the executable file
 @code{a.out} is the only active target.  If you designate a core file as
@@ -8382,48 +7901,32 @@ requests for memory addresses.  (Typically, these two classes of target
 are complementary, since core files contain only a program's
 read-write memory---variables and so on---plus machine status, while
 executable files contain only the program text and initialized data.)
-@end ifclear
 
 When you type @code{run}, your executable file becomes an active process
-target as well.  When a process target is active, all @value{GDBN} commands
-requesting memory addresses refer to that target; addresses in an 
-@ifclear BARETARGET
-active core file or 
-@end ifclear
-executable file target are obscured while the process
-target is active.
+target as well.  When a process target is active, all @value{GDBN}
+commands requesting memory addresses refer to that target; addresses in
+an active core file or executable file target are obscured while the
+process target is active.
 
-@ifset BARETARGET
-Use the @code{exec-file} command to select a
-new executable target (@pxref{Files, ,Commands to specify
-files}).
-@end ifset
-@ifclear BARETARGET
-Use the @code{core-file} and @code{exec-file} commands to select a
-new core file or executable target (@pxref{Files, ,Commands to specify
+Use the @code{core-file} and @code{exec-file} commands to select a new
+core file or executable target (@pxref{Files, ,Commands to specify
 files}).  To specify as a target a process that is already running, use
-the @code{attach} command (@pxref{Attach, ,Debugging an
-already-running process}).
-@end ifclear
+the @code{attach} command (@pxref{Attach, ,Debugging an already-running
+process}).
 
 @node Target Commands, Byte Order, Active Targets, Targets
 @section Commands for managing targets
 
 @table @code
 @item target @var{type} @var{parameters}
-Connects the @value{GDBN} host environment to a target
-@ifset BARETARGET
-machine.
-@end ifset
-@ifclear BARETARGET
-machine or process.  A target is typically a protocol for talking to
-debugging facilities.  You use the argument @var{type} to specify the
-type or protocol of the target machine.
+Connects the @value{GDBN} host environment to a target machine or
+process.  A target is typically a protocol for talking to debugging
+facilities.  You use the argument @var{type} to specify the type or
+protocol of the target machine.
 
 Further @var{parameters} are interpreted by the target protocol, but
 typically include things like device names or host names to connect
 with, process numbers, and baud rates.
-@end ifclear
 
 The @code{target} command does not repeat if you press @key{RET} again
 after executing the command.
@@ -8473,12 +7976,10 @@ These are the valid targets on HP-UX systems:
 An executable file.  @samp{target exec @var{program}} is the same as
 @samp{exec-file @var{program}}.
 
-@ifclear BARETARGET
 @kindex target core
 @item target core @var{filename}
 A core dump file.  @samp{target core @var{filename}} is the same as
 @samp{core-file @var{filename}}.
-@end ifclear
 
 @kindex target remote
 @item target remote @var{dev}
@@ -8558,7 +8059,6 @@ EST-300 ICE monitor, running on a CPU32 (M68K) board.
 @kindex target hms
 @item target hms @var{dev}
 A Hitachi SH, H8/300, or H8/500 board, attached via serial line to your host.
-@ifclear H8EXCLUSIVE
 Use special commands @code{device} and @code{speed} to control the serial
 line and the communications speed used.
 @xref{Hitachi Remote,,@value{GDBN} and Hitachi Microprocessors}.
@@ -8664,13 +8164,10 @@ is the target system's machine name or IP address.
 @item target w89k @var{dev}
 W89K monitor, running on a Winbond HPPA board.
 
-@end ifclear
 @end table
 
-@ifset GENERIC
 Different targets are available on different configurations of @value{GDBN}; 
 your configuration may have more or fewer targets.
-@end ifset
 
 Many remote targets require you to download the executable's code
 once you've successfully established a connection.
@@ -8679,7 +8176,6 @@ once you've successfully established a connection.
 
 @kindex load @var{filename}
 @item load @var{filename}
-@ifset GENERIC
 Depending on what remote debugging facilities are configured into
 @value{GDBN}, the @code{load} command may be available.  Where it exists, it
 is meant to make @var{filename} (an executable) available for debugging
@@ -8690,7 +8186,6 @@ the @code{add-symbol-file} command.
 If your @value{GDBN} does not have a @code{load} command, attempting to
 execute it gets the error message ``@code{You can't do that when your
 target is @dots{}}''
-@end ifset
 
 The file is loaded at whatever address is specified in the executable.
 For some object file formats, you can specify the load address when you
@@ -8698,19 +8193,14 @@ link the program; for other formats, like a.out, the object file format
 specifies a fixed address.
 @c FIXME! This would be a good place for an xref to the GNU linker doc.
 
-@ifset VXWORKS
 On VxWorks, @code{load} links @var{filename} dynamically on the
 current target system as well as adding its symbols in @value{GDBN}.
-@end ifset
 
-@ifset I960
 @cindex download to Nindy-960
 With the Nindy interface to an Intel 960 board, @code{load}
 downloads @var{filename} to the 960 as well as adding its symbols in
 @value{GDBN}.
-@end ifset
 
-@ifset H8
 @cindex download to H8/300 or H8/500
 @cindex H8/300 or H8/500 download
 @cindex download to Hitachi SH
@@ -8720,14 +8210,13 @@ When you select remote debugging to a Hitachi SH, H8/300, or H8/500 board
 the @code{load} command downloads your program to the Hitachi board and also
 opens it as the current executable target for @value{GDBN} on your host
 (like the @code{file} command).
-@end ifset
 
 @code{load} does not repeat if you press @key{RET} again after using it.
 @end table
 
-@ifset REMOTESTUB
 @node Byte Order, Remote, Target Commands, Targets
 @section Choosing target byte order
+
 @cindex choosing target byte order
 @cindex target byte order
 @kindex set endian big
@@ -8784,45 +8273,25 @@ communicate with @value{GDBN}.
 
 Other remote targets may be available in your
 configuration of @value{GDBN}; use @code{help target} to list them.
-@end ifset
 
-@ifset GENERIC
 @c Text on starting up GDB in various specific cases; it goes up front
 @c in manuals configured for any of those particular situations, here
 @c otherwise.
 @menu
-@ifset REMOTESTUB
 * Remote Serial::               @value{GDBN} remote serial protocol
-@end ifset
-@ifset I960
 * i960-Nindy Remote::          @value{GDBN} with a remote i960 (Nindy)
-@end ifset
-@ifset AMD29K
 * UDI29K Remote::               The UDI protocol for AMD29K
 * EB29K Remote::               The EBMON protocol for AMD29K
-@end ifset
-@ifset VXWORKS
 * VxWorks Remote::             @value{GDBN} and VxWorks
-@end ifset
-@ifset ST2000
 * ST2000 Remote::               @value{GDBN} with a Tandem ST2000
-@end ifset
-@ifset H8
 * Hitachi Remote::              @value{GDBN} and Hitachi Microprocessors
-@end ifset
-@ifset MIPS
 * MIPS Remote::                        @value{GDBN} and MIPS boards
-@end ifset
-@ifset SPARCLET
 * Sparclet Remote::             @value{GDBN} and Sparclet boards
-@end ifset
-@ifset SIMS
 * Simulator::                   Simulated CPU target
-@end ifset
 @end menu
 
 @include remote.texi
-@end ifset
+
 
 @node Controlling GDB
 @chapter Controlling @value{GDBN}
@@ -9268,7 +8737,6 @@ In addition, a pseudo-command, @samp{stop} exists.  Defining
 execution stops in your program: before breakpoint commands are run,
 displays are printed, or the stack frame is printed.
 
-@ifclear BARETARGET
 For example, to ignore @code{SIGALRM} signals while
 single-stepping, but treat them normally during normal execution,
 you could define:
@@ -9286,7 +8754,6 @@ define hook-continue
 handle SIGLARM pass
 end
 @end example
-@end ifclear
 
 You can define a hook for any single-word command in @value{GDBN}, but
 not for command aliases; you should define a hook for the basic command
@@ -9321,7 +8788,6 @@ options (such as @code{set complaints}) which affect the processing of
 the command line options and operands.  The init files are not executed
 if you use the @samp{-nx} option; @pxref{Mode Options, ,Choosing modes}.
 
-@ifset GENERIC
 @cindex init file name
 On some configurations of @value{GDBN}, the init file is known by a
 different name (these are typically environments where a specialized
@@ -9342,7 +8808,6 @@ OS68K (Enea Data Systems real-time OS): @samp{.os68gdbinit}
 @item
 ES-1800 (Ericsson Telecom AB M68000 emulator): @samp{.esgdbinit}
 @end itemize
-@end ifset
 
 You can also request the execution of a command file with the
 @code{source} command:
@@ -9438,7 +8903,6 @@ string are the simple ones that consist of backslash followed by a
 letter.
 @end table
 
-@ifclear DOSHOST
 @node Emacs, GDB Bugs, Sequences, Top
 @chapter Using @value{GDBN} under @sc{gnu} Emacs
 
@@ -9614,7 +9078,6 @@ environment.  Users of this environment can use a new command,
 @code{inspect} which performs identically to @code{print} except that
 each value is printed in its own window.
 @end ignore
-@end ifclear
 
 @node GDB Bugs
 @c links whacked to pacify makeinfo
index 99f081dcda4a39f7a4c284d70441a8127df3bef3..3ebeae58f0ecb3ff513a5ea5e8021f971521a49a 100644 (file)
@@ -1017,10 +1017,6 @@ This macro is used as the argument to lseek (or, most commonly,
 bfd_seek).  FIXME, should be replaced by SEEK_SET instead, which is the
 POSIX equivalent.
 
-@item MAINTENANCE_CMDS
-If the value of this is 1, then a number of optional maintenance
-commands are compiled in.
-
 @item MALLOC_INCOMPATIBLE
 Define this if the system's prototype for @code{malloc} differs from the
 @sc{ANSI} definition.
@@ -1048,6 +1044,10 @@ of functions to indicate that they never return.  The default is already
 set correctly if compiling with GCC.  This will almost never need to be
 defined.
 
+@item USE_GENERIC_DUMMY_FRAMES
+Define this to 1 if the target is using the generic inferior function
+call code.  See @code{blockframe.c} for more information.
+
 @item USE_MMALLOC
 GDB will use the @code{mmalloc} library for memory allocation for symbol
 reading if this symbol is defined.  Be careful defining it since there
@@ -1198,15 +1198,24 @@ instruction for a breakpoint, it's not required; for instance, the bit
 pattern could be an invalid instruction.  The breakpoint must be no
 longer than the shortest instruction of the architecture.
 
+@var{BREAKPOINT} has been deprecated in favour of
+@var{BREAKPOINT_FROM_PC}.
+
 @item BIG_BREAKPOINT
 @item LITTLE_BREAKPOINT
 Similar to BREAKPOINT, but used for bi-endian targets.
 
+@var{BIG_BREAKPOINT} and @var{LITTLE_BREAKPOINT} have been deprecated in
+favour of @var{BREAKPOINT_FROM_PC}.
+
 @item REMOTE_BREAKPOINT
 @item LITTLE_REMOTE_BREAKPOINT
 @item BIG_REMOTE_BREAKPOINT
 Similar to BREAKPOINT, but used for remote targets.
 
+@var{BIG_REMOTE_BREAKPOINT} and @var{LITTLE_REMOTE_BREAKPOINT} have been
+deprecated in favour of @var{BREAKPOINT_FROM_PC}.
+
 @item BREAKPOINT_FROM_PC (pcptr, lenptr)
 
 Use the program counter to determine the contents and size of a
@@ -1220,14 +1229,40 @@ not required; for instance, the bit pattern could be an invalid
 instruction.  The breakpoint must be no longer than the shortest
 instruction of the architecture.
 
-Replaces all the other BREAKPOINTs.
+Replaces all the other @var{BREAKPOINT} macros.
+
+@item CALL_DUMMY_P
+A C expresson that is non-zero when the target suports inferior function
+calls.
+
+@item CALL_DUMMY_WORDS
+Pointer to an array of @var{LONGEST} words of data containing
+host-byte-ordered @var{REGISTER_BYTES} sized values that partially
+specify the sequence of instructions needed for an inferior function
+call.
+
+Should be deprecated in favour of a macro that uses target-byte-ordered
+data.
+
+@item SIZEOF_CALL_DUMMY_WORDS
+The size of @var{CALL_DUMMY_WORDS}.  When @var{CALL_DUMMY_P} this must
+return a positive value.  See also @var{CALL_DUMMY_LENGTH}.
 
 @item CALL_DUMMY
-valops.c
+A static initializer for @var{CALL_DUMMY_WORDS}.  Deprecated.
+
 @item CALL_DUMMY_LOCATION
 inferior.h
+
 @item CALL_DUMMY_STACK_ADJUST
-valops.c
+Stack adjustment needed when performing an inferior function call.
+
+Should be deprecated in favor of something like @var{STACK_ALIGN}.
+
+@item CALL_DUMMY_STACK_ADJUST_P
+Predicate for use of @var{CALL_DUMMY_STACK_ADJUST}.
+
+Should be deprecated in favor of something like @var{STACK_ALIGN}.
 
 @item CANNOT_FETCH_REGISTER (regno)
 A C expression that should be nonzero if @var{regno} cannot be fetched
@@ -1375,7 +1410,7 @@ pointer.  It examines the current state of the machine as needed.
 
 @item GET_SAVED_REGISTER
 Define this if you need to supply your own definition for the function
-@code{get_saved_register}.  Currently this is only done for the a29k.
+@code{get_saved_register}.
 
 @item HAVE_REGISTER_WINDOWS
 Define this if the target has register windows.
@@ -1507,6 +1542,9 @@ register state.
 Return the name of register @var{i} as a string.  May return @var{NULL}
 or @var{NUL} to indicate that register @var{i} is not valid.
 
+@item REGISTER_NAMES
+Deprecated in favor of @var{REGISTER_NAME}.
+
 @item REG_STRUCT_HAS_ADDR (gcc_p, type)
 Define this to return 1 if the given type will be passed by pointer
 rather than directly.
index 816b65837de99e2a5a4bc0ca7409f1a19c6f2604..adf8e0094f3dd4440ae237531a966dc1252f0f82 100644 (file)
@@ -1,11 +1,7 @@
 @c                                                             -*- Texinfo -*-
 @c Copyright (c) 1990 1991 1992 1993 Free Software Foundation, Inc.
 @c This file is part of the source for the GDB manual.
-@c This text diverted to "Remote Debugging" section in general case;
-@c however, if we're doing a manual specifically for one of these, it
-@c belongs up front (in "Getting In and Out" chapter).
 
-@ifset REMOTESTUB
 @node Remote Serial
 @subsection The @value{GDBN} remote serial protocol
 
@@ -47,11 +43,9 @@ you must link with your program a few special-purpose subroutines that
 implement the @value{GDBN} remote serial protocol.  The file containing these
 subroutines is called  a @dfn{debugging stub}.
 
-@ifset GDBSERVER
 On certain remote targets, you can use an auxiliary program
 @code{gdbserver} instead of linking a stub into your program.
 @xref{Server,,Using the @code{gdbserver} program}, for details.
-@end ifset
 @end table
 
 The debugging stub is specific to the architecture of the remote
@@ -102,12 +96,8 @@ recently added stubs.
 * Bootstrapping::       What you must do for the stub
 * Debug Session::       Putting it all together
 * Protocol::            Outline of the communication protocol
-@ifset GDBSERVER
 * Server::             Using the `gdbserver' program
-@end ifset
-@ifset GDBSERVE
 * NetWare::            Using the `gdbserve.nlm' program
-@end ifset
 @end menu
 
 @node Stub Contents
@@ -221,7 +211,7 @@ should be a simple jump, not a jump to subroutine.
 For the 386, @var{exception_address} should be installed as an interrupt
 gate so that interrupts are masked while the handler runs.  The gate
 should be at privilege level 0 (the most privileged level).  The
-@sc{sparc} and 68k stubs are able to mask interrup themselves without
+@sc{sparc} and 68k stubs are able to mask interrupts themselves without
 help from @code{exceptionHandler}.
 
 @item void flush_i_cache()
@@ -460,7 +450,6 @@ packet-debugging information is printed on the @value{GDBN} standard output
 stream.  @code{set remotedebug off} turns it off, and @code{show
 remotedebug} shows you its current state.
 
-@ifset GDBSERVER
 @node Server
 @subsubsection Using the @code{gdbserver} program
 
@@ -562,9 +551,7 @@ the @code{target remote} command.  Otherwise you may get an error whose
 text depends on the host system, but which usually looks something like
 @samp{Connection refused}.
 @end table
-@end ifset
 
-@ifset GDBSERVE
 @node NetWare
 @subsubsection Using the @code{gdbserve.nlm} program
 
@@ -621,11 +608,7 @@ argument is a device name (usually a serial device, like
 @noindent
 communications with the server via serial line @file{/dev/ttyb}.
 @end table
-@end ifset
 
-@end ifset
-
-@ifset I960
 @node i960-Nindy Remote
 @subsection @value{GDBN} with a remote i960 (Nindy)
 
@@ -728,9 +711,7 @@ circuit to perform a hard reset (or some other interesting action) when
 a break is detected.
 @end table
 @c @end group
-@end ifset
 
-@ifset AMD29K
 @node UDI29K Remote
 @subsection The UDI protocol for AMD29K
 
@@ -943,9 +924,6 @@ of the commands sent to it.  Running @samp{tail -f} on this file in
 another window often helps to understand trouble with @code{EBMON}, or
 unexpected events on the PC side of the connection.
 
-@end ifset
-
-@ifset ST2000
 @node ST2000 Remote
 @subsection @value{GDBN} with a Tandem ST2000
 
@@ -991,11 +969,10 @@ sequences gets you back to the @value{GDBN} command prompt:
 @kbd{@key{RET}~.} (Return, followed by tilde and period) or
 @kbd{@key{RET}~@key{C-d}} (Return, followed by tilde and control-D).
 @end table
-@end ifset
 
-@ifset VXWORKS
 @node VxWorks Remote
 @subsection @value{GDBN} and VxWorks
+
 @cindex VxWorks
 
 @value{GDBN} enables developers to spawn and debug tasks running on networked
@@ -1141,9 +1118,7 @@ follows:
 where @var{task} is the VxWorks hexadecimal task ID.  The task can be running
 or suspended when you attach to it.  Running tasks are suspended at
 the time of attachment.
-@end ifset
 
-@ifset SPARCLET
 @node Sparclet Remote
 @subsection @value{GDBN} and Sparclet
 @cindex Sparclet
@@ -1292,9 +1267,6 @@ Breakpoint 1, main (argc=1, argv=0xeffff21c) at prog.c:3
 (gdbslet)                           
 @end example
 
-@end ifset
-
-@ifset H8
 @node Hitachi Remote
 @subsection @value{GDBN} and Hitachi microprocessors
 @value{GDBN} needs to know these things to talk to your
@@ -1312,11 +1284,8 @@ H8/300, or H8/500.)
 what serial device connects your host to your Hitachi board (the first
 serial device available on your host is the default).
 
-@ifclear H8EXCLUSIVE
-@c this is only for Unix hosts, not of interest to Hitachi
 @item
 what speed to use over the serial device.
-@end ifclear
 @end enumerate
 
 @menu
@@ -1328,7 +1297,6 @@ what speed to use over the serial device.
 @node Hitachi Boards
 @subsubsection Connecting to Hitachi boards
 
-@ifclear H8EXCLUSIVE
 @c only for Unix hosts
 @kindex device
 @cindex serial device, Hitachi micros
@@ -1348,13 +1316,11 @@ com2:9600,n,8,1,p}} for a 9600 bps connection).
 The @samp{device} and @samp{speed} commands are available only when you
 use a Unix host to debug your Hitachi microprocessor programs.  If you
 use a DOS host,
-@end ifclear
 @value{GDBN} depends on an auxiliary terminate-and-stay-resident program
 called @code{asynctsr} to communicate with the development board
 through a PC serial port.  You must also use the DOS @code{mode} command
 to set up the serial port on the DOS side.
 
-@ifset DOSHOST
 The following sample session illustrates the steps needed to start a
 program under @value{GDBN} control on an H8/300.  The example uses a
 sample H8/300 program called @file{t.x}.  The procedure is the same for
@@ -1440,7 +1406,6 @@ to detect program completion.
 
 In either case, @value{GDBN} sees the effect of a @sc{reset} on the
 development board as a ``normal exit'' of your program.
-@end ifset
 
 @node Hitachi ICE
 @subsubsection Using the E7000 in-circuit emulator
@@ -1487,9 +1452,6 @@ memory}.  The accepted values for @var{mod} are @code{small},
 @code{big}, @code{medium}, and @code{compact}.
 @end table
 
-@end ifset
-
-@ifset MIPS
 @node MIPS Remote
 @subsection @value{GDBN} and remote MIPS boards
 
@@ -1622,13 +1584,10 @@ is waiting for your program to stop.  In that case, @value{GDBN} waits
 forever because it has no way of knowing how long the program is going
 to run before stopping.
 @end table
-@end ifset
 
-@ifset SIMS
 @node Simulator
 @subsection Simulated CPU target
 
-@ifset GENERIC
 @cindex simulator
 @cindex simulator, Z8000
 @cindex Z8000 simulator
@@ -1642,33 +1601,16 @@ can use instead of a hardware CPU to debug your programs.
 Currently, simulators are available for ARM, D10V, D30V, FR30, H8/300,
 H8/500, i960, M32R, MIPS, MN10200, MN10300, PowerPC, SH, Sparc, V850,
 W65, and Z8000.
-@end ifset
-
-@ifclear GENERIC
-@ifset H8
-@cindex simulator, H8/300 or H8/500
-@cindex Hitachi H8/300 or H8/500 simulator
-@cindex simulator, Hitachi SH
-@cindex Hitachi SH simulator
-When configured for debugging Hitachi microprocessor targets,
-@value{GDBN} includes a CPU simulator for the target chip (a Hitachi SH,
-H8/300, or H8/500).
-@end ifset
 
-@ifset Z8K
 @cindex simulator, Z8000
 @cindex Zilog Z8000 simulator
 When configured for debugging Zilog Z8000 targets, @value{GDBN} includes
 a Z8000 simulator.
-@end ifset
-@end ifclear
 
-@ifset Z8K
 For the Z8000 family, @samp{target sim} simulates either the Z8002 (the
 unsegmented variant of the Z8000 architecture) or the Z8001 (the
 segmented variant).  The simulator recognizes which architecture is
 appropriate by inspecting the object code.
-@end ifset
 
 @table @code
 @item target sim @var{args}
@@ -1703,6 +1645,5 @@ You can refer to these values in @value{GDBN} expressions with the usual
 conventions; for example, @w{@samp{b fputc if $cycles>5000}} sets a
 conditional breakpoint that suspends only after at least 5000
 simulated clock ticks.
-@end ifset
 
 @c need to add much more detail about sims!
index a4f0bc939894d0203b1e0b4e3409e581b6ea1d9a..2e4f7b81ad2548333b392a863011959ff75c615b 100644 (file)
@@ -3048,7 +3048,7 @@ the derivation of this class is encoded as follows.
 @node Virtual Base Classes
 @section Virtual Base Classes
 
-A derived class object consists of a concatination in memory of the data
+A derived class object consists of a concatenation in memory of the data
 areas defined by each base class, starting with the leftmost and ending
 with the rightmost in the list of base classes.  The exception to this
 rule is for virtual inheritence.  In the example above, class @code{D}
index cf5206631ec869e0225ca08c904f5a2f762e3ae4..35be19d7f8ede6deaa2fe839ec04a2949711645f 100644 (file)
@@ -302,13 +302,28 @@ static struct partial_die_info zeroed_partial_die;
    in buildsym.c.  */
 static struct pending **list_in_scope = &file_symbols;
 
-/* FIXME: The following variables pass additional information from
-   decode_locdesc to the caller.  */
-static int optimized_out;      /* Kludge to identify optimized out variables */
-static int isreg;              /* Kludge to identify register variables */
-static int offreg;             /* Kludge to identify basereg references */
-static int basereg;            /* Which base register is it relative to?  */
-static int islocal;            /* Kludge to identify local variables */
+/* FIXME: decode_locdesc sets these variables to describe the location
+   to the caller.  These ought to be a structure or something.   If
+   none of the flags are set, the object lives at the address returned
+   by decode_locdesc.  */
+
+static int optimized_out;      /* No ops in location in expression,
+                                  so object was optimized out.  */
+static int isreg;              /* Object lives in register.
+                                  decode_locdesc's return value is
+                                  the register number.  */
+static int offreg;             /* Object's address is the sum of the
+                                  register specified by basereg, plus
+                                  the offset returned.  */
+static int basereg;            /* See `offreg'.  */
+static int isderef;            /* Value described by flags above is
+                                  the address of a pointer to the object.  */
+static int islocal;            /* Variable is at the returned offset
+                                  from the frame start, but there's
+                                  no identified frame pointer for
+                                  this function, so we can't say
+                                  which register it's relative to;
+                                  use LOC_LOCAL.  */
 
 /* DW_AT_frame_base values for the current function.
    frame_base_reg is -1 if DW_AT_frame_base is missing, otherwise it
@@ -464,6 +479,10 @@ static struct complaint dwarf2_unsupported_stack_op =
 {
   "unsupported stack op: '%s'", 0, 0
 };
+static struct complaint dwarf2_complex_location_expr =
+{
+  "location expression too complex", 0, 0
+};
 static struct complaint dwarf2_unsupported_tag =
 {
   "unsupported tag: '%s'", 0, 0
@@ -1595,7 +1614,9 @@ read_func_scope (die, objfile)
   if (attr)
     {
       CORE_ADDR addr = decode_locdesc (DW_BLOCK (attr), objfile);
-      if (isreg)
+      if (isderef)
+       complain (&dwarf2_unsupported_at_frame_base, name);
+      else if (isreg)
        frame_base_reg = addr;
       else if (offreg)
        {
@@ -3922,7 +3943,12 @@ dwarf_decode_lines (offset, comp_dir, abfd)
                {
                case DW_LNE_end_sequence:
                  end_sequence = 1;
-                 record_line (current_subfile, line, address);
+                 /* Don't call record_line here.  The end_sequence
+                    instruction provides the address of the first byte
+                    *after* the last line in the sequence; it's not the
+                    address of any real source line.  However, the GDB
+                    linetable structure only records the starts of lines,
+                    not the ends.  This is a weakness of GDB.  */
                  break;
                case DW_LNE_set_address:
                  address = read_address (abfd, line_ptr) + baseaddr;
@@ -4238,8 +4264,17 @@ new_symbol (die, type, objfile)
                }
              else if (offreg)
                {
-                 SYMBOL_CLASS (sym) = LOC_BASEREG_ARG;
-                 SYMBOL_BASEREG (sym) = basereg;
+                 if (isderef)
+                   {
+                     if (basereg != frame_base_reg)
+                       complain (&dwarf2_complex_location_expr);
+                     SYMBOL_CLASS (sym) = LOC_REF_ARG;
+                   }
+                 else
+                   {
+                     SYMBOL_CLASS (sym) = LOC_BASEREG_ARG;
+                     SYMBOL_BASEREG (sym) = basereg;
+                   }
                }
              else
                {
@@ -5643,6 +5678,7 @@ decode_locdesc (blk, objfile)
   stack[stacki] = 0;
   isreg = 0;
   offreg = 0;
+  isderef = 0;
   islocal = 0;
   optimized_out = 1;
 
@@ -5816,6 +5852,14 @@ decode_locdesc (blk, objfile)
          stacki--;
          break;
 
+       case DW_OP_deref:
+         isderef = 1;
+         /* If we're not the last op, then we definitely can't encode
+             this using GDB's address_class enum.  */
+         if (i < size)
+           complain (&dwarf2_complex_location_expr);
+         break;
+
        default:
          complain (&dwarf2_unsupported_stack_op, dwarf_stack_op_name(op));
          return (stack[stacki]);
index 87aed010f018988fc492016dbced6c7f3e55a6cb..600a905c8ba989508076295947302381ba96d002 100644 (file)
@@ -191,7 +191,7 @@ exec_file_attach (args, from_tty)
       if (argv == NULL)
        nomem (0);
 
-      make_cleanup ((make_cleanup_func) freeargv, (char *) argv);
+      make_cleanup_freeargv (argv);
 
       for (; (*argv != NULL) && (**argv == '-'); argv++) {;}
       if (*argv == NULL)
index 939919a425ae84a85447ca69729e8d2f04b97c15..7cd35ece7066a02a796d56b4a61f363eac5e8530 100644 (file)
@@ -497,8 +497,6 @@ op_string(op)
   return NULL;
 }
 
-#ifdef MAINTENANCE_CMDS
-
 /* Support for dumping the raw data from expressions in a human readable
    form.  */
 
@@ -899,5 +897,3 @@ dump_postfix_expression (exp, stream, note)
     elt = dump_subexp (exp, stream, elt);
   fputs_filtered ("\n", stream);
 }
-
-#endif /* MAINTENANCE_CMDS */
index 310b2e297acb582ac0b6021a4369e3d0909010ec..52471c5a9f631d928ca5e3f85f50766f35c473ef 100644 (file)
@@ -370,13 +370,11 @@ extern void print_expression PARAMS ((struct expression *, GDB_FILE *));
 
 extern char *op_string PARAMS ((enum exp_opcode));
 
-#ifdef MAINTENANCE_CMDS
 extern void dump_prefix_expression PARAMS ((struct expression *,
                                            GDB_FILE *,
                                            char *));
 extern void dump_postfix_expression PARAMS ((struct expression *,
                                             GDB_FILE *,
                                             char *));
-#endif /* MAINTENANCE_CMDS */
 
 #endif /* !defined (EXPRESSION_H) */
index 5bfecc22a7eff05a371b2875a2be5928d9d46643..74be8c7c5d7d1e4333e166fbaa8cbc8f3420a454 100644 (file)
@@ -43,6 +43,8 @@ const struct floatformat floatformat_unknown;
 
 static void write_register_gen PARAMS ((int, char *));
 
+static int read_relative_register_raw_bytes_for_frame PARAMS ((int regnum, char *myaddr, struct frame_info *frame));
+
 /* Basic byte-swapping routines.  GDB has needed these for a long time...
    All extract a target-format integer at ADDR which is LEN bytes long.  */
 
@@ -252,25 +254,6 @@ store_address (addr, len, val)
      int len;
      LONGEST val;
 {
-  if( TARGET_BYTE_ORDER == BIG_ENDIAN
-      &&  len != sizeof( LONGEST )) {
-    /* On big-endian machines (e.g., HPPA 2.0, narrow mode)
-     * just letting this fall through to the call below will
-     * lead to the wrong bits being stored.
-     *
-     * Only the simplest case is fixed here, the others just
-     * get the old behavior.
-     */
-    if( (len == sizeof( CORE_ADDR ))
-       &&  (sizeof( LONGEST ) == 2 * sizeof( CORE_ADDR ))) {
-      /* Watch out!  The high bits are garbage! */
-      CORE_ADDR coerce[2];
-      *(LONGEST*)&coerce = val;
-
-      store_unsigned_integer (addr, len, coerce[1] ); /* BIG_ENDIAN code! */
-      return;
-    }
-  }
   store_unsigned_integer (addr, len, val);
 }
 \f
@@ -393,7 +376,6 @@ store_floating (addr, len, val)
     }
 }
 \f
-#if !defined (GET_SAVED_REGISTER)
 
 /* Return the address in which frame FRAME's value of register REGNUM
    has been saved in memory.  Or return zero if it has not been saved.
@@ -477,7 +459,7 @@ find_saved_register (frame, regnum)
    The argument RAW_BUFFER must point to aligned memory.  */
 
 void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
+default_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
      char *raw_buffer;
      int *optimized;
      CORE_ADDR *addrp;
@@ -523,7 +505,22 @@ get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
   if (addrp != NULL)
     *addrp = addr;
 }
-#endif /* GET_SAVED_REGISTER.  */
+
+#if !defined (GET_SAVED_REGISTER)
+#define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
+  default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
+#endif
+void
+get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
+     char *raw_buffer;
+     int *optimized;
+     CORE_ADDR *addrp;
+     struct frame_info *frame;
+     int regnum;
+     enum lval_type *lval;
+{
+  GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
+}
 
 /* Copy the bytes of register REGNUM, relative to the input stack frame,
    into our memory at MYADDR, in target byte order.
@@ -531,7 +528,7 @@ get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 
    Returns 1 if could not be read, 0 if could.  */
 
-int
+static int
 read_relative_register_raw_bytes_for_frame (regnum, myaddr, frame)
      int regnum;
      char *myaddr;
@@ -627,15 +624,14 @@ value_of_register (regnum)
    or it will get garbage.  (a change from GDB version 3, in which
    the caller got the value from the last stop).  */
 
-/* Contents of the registers in target byte order.
-   We allocate some extra slop since we do a lot of memcpy's around 
-   `registers', and failing-soft is better than failing hard.  */
+/* Contents and state of the registers (in target byte order). */
 
-char registers[REGISTER_BYTES + /* SLOP */ 256];
+char *registers;
 
-/* Nonzero if that register has been fetched,
-   -1 if register value not available. */
-SIGNED char register_valid[NUM_REGS];
+/* VALID_REGISTER is non-zero if it has been fetched, -1 if the
+   register value was not available. */
+
+signed char *register_valid;
 
 /* The thread/process associated with the current set of registers.  For now,
    -1 is special, and means `no current process'.  */
@@ -1628,3 +1624,25 @@ locate_var_value (var, frame)
     }
   return 0;  /* For lint -- never reached */
 }
+
+\f
+static void build_findvar PARAMS ((void));
+static void
+build_findvar ()
+{
+  /* We allocate some extra slop since we do a lot of memcpy's around
+     `registers', and failing-soft is better than failing hard.  */
+  int sizeof_registers = REGISTER_BYTES + /* SLOP */ 256;
+  int sizeof_register_valid = NUM_REGS * sizeof (*register_valid);
+  registers = xmalloc (sizeof_registers);
+  memset (registers, 0, sizeof_registers);
+  register_valid = xmalloc (sizeof_register_valid);
+  memset (register_valid, 0, sizeof_register_valid);
+}
+
+void _initialize_findvar PARAMS ((void));
+void
+_initialize_findvar ()
+{
+  build_findvar ();
+}
index 0d442dafa4dd17274bd7998a398da8cc2c798afe..ae3b886f9a96aeb2089efd94cd8cedaed36462b2 100644 (file)
@@ -56,6 +56,48 @@ fr30_pop_frame ()
   flush_cached_frames ();
 }
 
+
+/* Function: fr30_store_return_value
+   Put a value where a caller expects to see it.  Used by the 'return'
+   command.  */
+void
+fr30_store_return_value (struct type *type,
+                        char *valbuf)
+{
+  /* Here's how the FR30 returns values (gleaned from gcc/config/
+     fr30/fr30.h):
+
+     If the return value is 32 bits long or less, it goes in r4.
+
+     If the return value is 64 bits long or less, it goes in r4 (most
+     significant word) and r5 (least significant word.
+
+     If the function returns a structure, of any size, the caller
+     passes the function an invisible first argument where the callee
+     should store the value.  But GDB doesn't let you do that anyway.
+
+     If you're returning a value smaller than a word, it's not really
+     necessary to zero the upper bytes of the register; the caller is
+     supposed to ignore them.  However, the FR30 typically keeps its
+     values extended to the full register width, so we should emulate
+     that.  */
+
+  /* The FR30 is big-endian, so if we return a small value (like a
+     short or a char), we need to position it correctly within the
+     register.  We round the size up to a register boundary, and then
+     adjust the offset so as to place the value at the right end.  */
+  int value_size = TYPE_LENGTH (type);
+  int returned_size = (value_size + FR30_REGSIZE - 1) & ~(FR30_REGSIZE - 1);
+  int offset = (REGISTER_BYTE (RETVAL_REG)
+               + (returned_size - value_size));
+  char *zeros = alloca (returned_size);
+  memset (zeros, 0, returned_size);
+
+  write_register_bytes (REGISTER_BYTE (RETVAL_REG), zeros, returned_size);
+  write_register_bytes (offset, valbuf, value_size);
+}
+
+
 /* Function: skip_prologue
    Return the address of the first code past the prologue of the function.  */
 
@@ -180,11 +222,13 @@ fr30_push_arguments(nargs, args, sp, struct_return, struct_addr)
   return sp;
 }
 
-_initialize_fr30_tdep()
-{
-       extern int print_insn_fr30(bfd_vma, disassemble_info *);
+void _initialize_fr30_tdep PARAMS ((void));
 
-       tm_print_insn = print_insn_fr30;
+void
+_initialize_fr30_tdep ()
+{
+  extern int print_insn_fr30(bfd_vma, disassemble_info *);
+  tm_print_insn = print_insn_fr30;
 }
 
 /* Function: check_prologue_cache
index 6836c6ce1b426fc217496a2cd3b9718896f21229..0bb9b6f30d07a9b43590bbcf1a422086c8a9b0f3 100644 (file)
@@ -42,7 +42,7 @@ struct frame_saved_regs
    frame_info".  The innermost one gets allocated (in
    wait_for_inferior) each time the inferior stops; current_frame
    points to it.  Additional frames get allocated (in
-   get_prev_frame_info) as needed, and are chained through the next
+   get_prev_frame) as needed, and are chained through the next
    and prev fields.  Any time that the frame cache becomes invalid
    (most notably when we execute something, but also if we change how
    we interpret the frames (e.g. "set heuristic-fence-post" in
@@ -106,20 +106,6 @@ struct frame_info
 extern void *frame_obstack_alloc PARAMS ((unsigned long size));
 extern void frame_saved_regs_zalloc PARAMS ((struct frame_info *));
 
-/* Dummy frame.  This saves the processor state just prior to setting up the
-   inferior function call.  On most targets, the registers are saved on the
-   target stack, but that really slows down function calls.  */
-
-struct dummy_frame
-{
-  struct dummy_frame *next;
-
-  CORE_ADDR pc;
-  CORE_ADDR fp;
-  CORE_ADDR sp;
-  char regs[REGISTER_BYTES];
-};
-
 /* Return the frame address from FR.  Except in the machine-dependent
    *FRAME* macros, a frame address has no defined meaning other than
    as a magic cookie which identifies a frame over calls to the
@@ -171,8 +157,6 @@ extern struct frame_info *selected_frame;
 
 extern int selected_frame_level;
 
-extern struct frame_info *get_prev_frame_info PARAMS ((struct frame_info *));
-
 extern struct frame_info *create_new_frame PARAMS ((CORE_ADDR, CORE_ADDR));
 
 extern void flush_cached_frames PARAMS ((void));
@@ -218,6 +202,8 @@ extern void print_frame_args PARAMS ((struct symbol *, struct frame_info *,
 
 extern struct frame_info *find_relative_frame PARAMS ((struct frame_info *, int*));
 
+extern void show_and_print_stack_frame PARAMS ((struct frame_info *fi, int level, int source));
+
 extern void print_stack_frame PARAMS ((struct frame_info *, int, int));
 
 extern void print_only_stack_frame PARAMS ((struct frame_info *, int, int));
@@ -250,6 +236,7 @@ extern void      generic_pop_current_frame   PARAMS ((void (*) (struct frame_inf
 extern void      generic_pop_dummy_frame     PARAMS ((void));
 
 extern int       generic_pc_in_call_dummy    PARAMS ((CORE_ADDR pc, 
+                                                     CORE_ADDR sp, 
                                                      CORE_ADDR fp));
 extern char *    generic_find_dummy_frame    PARAMS ((CORE_ADDR pc, 
                                                      CORE_ADDR fp));
index 154fa8f9982866fa1af05b9f89b331dcf59259ed..b9ee31037862b3b9f9bafa1f95e82d7f666664d7 100644 (file)
@@ -18,9 +18,23 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
-#include "bfd.h"
-#include "gdbcmd.h"
 
+/* Just include everything in sight so that the every old definition
+   of macro is visible. */
+#include "gdb_string.h"
+#include <ctype.h>
+#include "symtab.h"
+#include "frame.h"
+#include "inferior.h"
+#include "breakpoint.h"
+#include "wait.h"
+#include "gdbcore.h"
+#include "gdbcmd.h"
+#include "target.h"
+#include "gdbthread.h"
+#include "annotate.h"
+#include "symfile.h"           /* for overlay functions */
+#include "symcat.h"
 
 
 /* Non-zero if we want to trace architecture code.  */
@@ -40,6 +54,7 @@ int gdbarch_debug = GDBARCH_DEBUG;
 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
 #endif
 #endif
+#if !TARGET_BYTE_ORDER_SELECTABLE_P
 #ifndef TARGET_BYTE_ORDER_DEFAULT
 /* compat - Catch old non byte-order selectable targets that do not
    define TARGET_BYTE_ORDER_DEFAULT and instead expect
@@ -48,6 +63,10 @@ int gdbarch_debug = GDBARCH_DEBUG;
    below will get a strange compiler warning. */
 #define TARGET_BYTE_ORDER_DEFAULT TARGET_BYTE_ORDER
 #endif
+#endif
+#ifndef TARGET_BYTE_ORDER_DEFAULT
+#define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN /* arbitrary */
+#endif
 int target_byte_order = TARGET_BYTE_ORDER_DEFAULT;
 int target_byte_order_auto = 1;
 
@@ -177,20 +196,37 @@ const struct bfd_arch_info *target_architecture = &bfd_default_arch_struct;
 int (*target_architecture_hook) PARAMS ((const struct bfd_arch_info *ap));
 
 /* Do the real work of changing the current architecture */
+enum set_arch { set_arch_auto, set_arch_manual };
 static void
-set_arch (arch)
+set_arch (arch, type)
      const struct bfd_arch_info *arch;
+     enum set_arch type;
 {
-  /* FIXME: Is it compatible with gdb? */
-  /* Check with the target on the setting */
-  if (target_architecture_hook != NULL
-      && !target_architecture_hook (arch))
-    printf_unfiltered ("Target does not support `%s' architecture.\n",
-                      arch->printable_name);
-  else
+  /* FIXME: Should be performing the more basic check that the binary
+     is compatible with GDB. */
+  /* Check with the target that the architecture is valid. */
+  int arch_valid = (target_architecture_hook != NULL
+                   && !target_architecture_hook (arch));
+  switch (type)
     {
-      target_architecture_auto = 0;
+    case set_arch_auto:
+      if (!arch_valid)
+       warning ("Target may not support %s architecture",
+                arch->printable_name);
       target_architecture = arch;
+      break;
+    case set_arch_manual:
+      if (!arch_valid)
+       {
+         printf_unfiltered ("Target does not support `%s' architecture.\n",
+                            arch->printable_name);
+       }
+      else
+       {
+         target_architecture_auto = 0;
+         target_architecture = arch;
+       }
+      break;
     }
 }
 
@@ -229,7 +265,7 @@ set_architecture (args, from_tty)
     {
       const struct bfd_arch_info *arch = bfd_scan_arch (args);
       if (arch != NULL)
-       set_arch (arch);
+       set_arch (arch, set_arch_manual);
       else
        printf_unfiltered ("Architecture `%s' not reconized.\n", args);
     }
@@ -268,7 +304,7 @@ set_architecture_from_arch_mach (arch, mach)
 {
   const struct bfd_arch_info *wanted = bfd_lookup_arch (arch, mach);
   if (wanted != NULL)
-    set_arch (wanted);
+    set_arch (wanted, set_arch_manual);
   else
     fatal ("hardwired architecture/machine not reconized");
 }
@@ -282,11 +318,7 @@ set_architecture_from_file (abfd)
   const struct bfd_arch_info *wanted = bfd_get_arch_info (abfd);
   if (target_architecture_auto)
     {
-      if (target_architecture_hook != NULL
-         && !target_architecture_hook (wanted))
-       warning ("Target may not support %s architecture",
-                wanted->printable_name);
-      target_architecture = wanted;
+      set_arch (wanted, set_arch_auto);
     }
   else if (wanted != target_architecture)
     {
@@ -318,6 +350,13 @@ set_gdbarch_from_file (abfd)
 }
 
 
+#if defined (CALL_DUMMY)
+/* FIXME - this should go away */
+LONGEST call_dummy_words[] = CALL_DUMMY;
+int sizeof_call_dummy_words = sizeof (call_dummy_words);
+#endif
+
+
 extern void _initialize_gdbarch PARAMS ((void));
 void
 _initialize_gdbarch ()
@@ -348,7 +387,6 @@ _initialize_gdbarch ()
   tm_print_insn_info.memory_error_func = dis_asm_memory_error;
   tm_print_insn_info.print_address_func = dis_asm_print_address;
 
-#ifdef MAINTENANCE_CMDS
   add_show_from_set (add_set_cmd ("archdebug",
                                  class_maintenance,
                                  var_zinteger,
@@ -356,5 +394,4 @@ _initialize_gdbarch ()
                                  "Set architecture debugging.\n\
 When non-zero, architecture debugging is enabled.", &setlist),
                     &showlist);
-#endif
 }
index 098db4c2860c3dc0ffcad0a76b77ed59e0976be5..beb206b1ba80fa39fd989ed97502ea17ab3d4879 100644 (file)
@@ -20,7 +20,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #ifndef GDBARCH_H
 #define GDBARCH_H
 
-
 /* The target-system-dependant byte order is dynamic */
 
 /* TARGET_BYTE_ORDER_SELECTABLE_P determines if the target endianness
@@ -100,6 +99,21 @@ extern disassemble_info tm_print_insn_info;
 
 
 
+/* Explicit test for D10V architecture.
+   USE of these macro's is *STRONGLY* discouraged. */
+
+#define GDB_TARGET_IS_D10V (TARGET_ARCHITECTURE->arch == bfd_arch_d10v)
+#ifndef D10V_MAKE_DADDR
+#define D10V_MAKE_DADDR(X) (abort (), 0)
+#endif
+#ifndef D10V_MAKE_IADDR
+#define D10V_MAKE_IADDR(X) (abort (), 0)
+#endif
+
+
+
+
+
 /* Set the dynamic target-system-dependant parameters (architecture,
    byte-order, ...) using information found in the BFD */
 
index 03934623d19a6b42b9c6910eb88cf3e4763117ca..ca9764b1eb98356abe97c7a9399b62e04c3f60fb 100644 (file)
@@ -78,6 +78,8 @@ static void print_bit_vector PARAMS ((B_TYPE *, int));
 static void print_arg_types PARAMS ((struct type **, int));
 static void dump_fn_fieldlists PARAMS ((struct type *, int));
 static void print_cplus_stuff PARAMS ((struct type *, int));
+static void virtual_base_list_aux PARAMS ((struct type *dclass));
+
 
 /* Alloc a new type structure and fill it with some defaults.  If
    OBJFILE is non-NULL, then allocate the space for the type structure
@@ -1719,15 +1721,15 @@ static struct vbase * current_vbase_list = NULL;
    Note: the list goes backward, right-to-left. virtual_base_list()
    copies the items out in reverse order.  */
 
-struct vbase *
+static void
 virtual_base_list_aux (dclass)
-  struct type * dclass;
+     struct type * dclass;
 {
   struct vbase * tmp_vbase;
   register int i;
 
   if (TYPE_CODE(dclass) != TYPE_CODE_CLASS)
-    return NULL;
+    return;
 
   for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
     {
@@ -2390,10 +2392,6 @@ rank_one_type (parm, arg)
  
 /* End of functions for overload resolution */ 
 
-
-
-#if MAINTENANCE_CMDS
-
 static void
 print_bit_vector (bits, nbits)
      B_TYPE *bits;
@@ -2766,9 +2764,6 @@ recursive_dump_type (type, spaces)
     obstack_free (&dont_print_type_obstack, NULL);
 }
 
-#endif /* MAINTENANCE_CMDS */
-
-
 static void build_gdbtypes PARAMS ((void));
 static void
 build_gdbtypes ()
index 107eb46eb3086d1d9f3e9f91966a713cc5a68544..5b7d77d07632df09e9ce9fe0d1b59e914886693c 100644 (file)
@@ -1112,10 +1112,7 @@ rank_function PARAMS ((struct type **, int, struct type **, int));
 extern int
 rank_one_type PARAMS ((struct type *, struct type *));
 
-
-#if MAINTENANCE_CMDS
 extern void recursive_dump_type PARAMS ((struct type *, int));
-#endif
 
 /* printcmd.c */
 
@@ -1124,9 +1121,7 @@ print_scalar_formatted PARAMS ((char *, struct type *, int, int, GDB_FILE *));
 
 extern int can_dereference PARAMS ((struct type *));
 
-#if MAINTENANCE_CMDS
 extern void maintenance_print_type PARAMS ((char *, int));
-#endif
 
 /* typeprint.c */
 
index 156d981f68fccb6a0574b873c1d1f26c3778fb83..795f8a855106098faad7d919d7b92dabd5ca881c 100644 (file)
@@ -23,6 +23,7 @@
 */
 
 #include <stdio.h>
+#include <string.h>
 #include <errno.h>
 #include <signal.h>
 #include <assert.h>
@@ -32,7 +33,8 @@
 
 /* We include this because we don't need the access macros and they conflict
    with gdb's definitions (ick).  This is very non standard!  */
-#include <waitflags.h>
+#define _SYS_WAIT_H            /* Inhibit warning from <bits/waitflags.h>.  */
+#include <bits/waitflags.h>
 
 #include <mach.h>
 #include <mach/message.h>
@@ -84,7 +86,6 @@ int gnu_debug_flag = 0;
 /* Forward decls */
 
 extern struct target_ops gnu_ops;
-extern char *strerror();
 
 int inf_update_procs (struct inf *inf);
 struct inf *make_inf ();
@@ -1911,7 +1912,7 @@ gnu_create_inferior (exec_file, allargs, env)
       if (ptrace (PTRACE_TRACEME) != 0)
        error ("ptrace (PTRACE_TRACEME) failed!");
     }
-  int attach_to_child (int pid)
+  void attach_to_child (int pid)
     {
       /* Attach to the now stopped child, which is actually a shell...  */
       inf_debug (inf, "attaching to child: %d", pid);
@@ -1930,13 +1931,12 @@ gnu_create_inferior (exec_file, allargs, env)
       inferior_pid = inf_pick_first_thread ();
 
       startup_inferior (inf->pending_execs);
-
-      return inferior_pid;
     }
 
   inf_debug (inf, "creating inferior");
 
-    fork_inferior (exec_file, allargs, env, trace_me, attach_to_child, NULL, NULL);
+  fork_inferior (exec_file, allargs, env, trace_me, attach_to_child,
+                NULL, NULL);
 
   inf_update_signal_thread (inf);
   inf_set_traced (inf, inf->want_signals);
@@ -2082,10 +2082,11 @@ gnu_stop ()
   error ("to_stop target function not implemented");
 }
 
-static void
+static char *
 gnu_pid_to_exec_file ()
 {
   error ("to_pid_to_exec_file target function not implemented");
+  return NULL;
 }
  
 
@@ -3169,11 +3170,9 @@ _initialize_gnu_nat ()
   add_task_commands ();
   add_thread_commands ();
 
-#if MAINTENANCE_CMDS
   add_set_cmd ("gnu-debug", class_maintenance,
               var_boolean, (char *)&gnu_debug_flag,
               "Set debugging output for the gnu backend.", &maintenancelist);
-#endif
 }
 \f
 #ifdef FLUSH_INFERIOR_CACHE
index d238dc04a9549ff1d3ed2f18f62ce67c414e70f0..f50ba60a95fc094639da2a63265dbe1e19daa266 100644 (file)
@@ -81,13 +81,10 @@ extern thread_state_t proc_get_state (struct proc *proc, int will_modify);
        debug ("{proc %d/%d %p}: " msg, \
              __proc_pid (__proc), __proc->tid, __proc , ##args); } while (0)
 
-#if MAINTENANCE_CMDS
 extern int gnu_debug_flag;
+
 #define debug(msg, args...) \
  do { if (gnu_debug_flag) \
         fprintf (stderr, "%s: " msg "\r\n", __FUNCTION__ , ##args); } while (0)
-#else
-#define debug(msg, args...) (void)0
-#endif
 
 #endif /* __GNU_NAT_H__ */
index 3fbe9e1bb28628971fbf431a294a8867db2cee1b..4fc502e4fa978461569aff9331add7c00f67ad56 100644 (file)
@@ -750,22 +750,6 @@ h8300_store_return_value (type, valbuf)
   }
 }
 
-/* Function: get_saved_register
-   Just call the generic_get_saved_register function.  */
-
-void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
-     char *raw_buffer;
-     int *optimized;
-     CORE_ADDR *addrp;
-     struct frame_info *frame;
-     int regnum;
-     enum lval_type *lval;
-{
-  generic_get_saved_register (raw_buffer, optimized, addrp, 
-                             frame, regnum, lval);
-}
-
 struct cmd_list_element *setmemorylist;
 
 static void
index 38f68e1bdb7b90038f208b2029c40bbbd4f332ec..e3ee41b95434a75df24494ec1ad8722b22997fda 100644 (file)
@@ -148,7 +148,6 @@ store_inferior_register (regno, regaddr)
 #endif /* not HPUX_VERSION_5 */
     {
       register int i;
-      extern char registers[];
       
       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int))
        {
index d911750811216d0bd666783abaedb9a9c26420b1..69188c7367741a57a29d219048c4f7a225596de5 100644 (file)
@@ -1425,20 +1425,16 @@ push_dummy_frame (inf_status)
     {
       unsigned int sid;
       int_buffer &= ~0x2;
-      memcpy (inf_status->registers, &int_buffer, 4);
-      memcpy (inf_status->registers + REGISTER_BYTE (PCOQ_HEAD_REGNUM), &pc, 4);
-      pc += 4;
-      memcpy (inf_status->registers + REGISTER_BYTE (PCOQ_TAIL_REGNUM), &pc, 4);
-      pc -= 4;
+      write_inferior_status_register (inf_status, 0, int_buffer);
+      write_inferior_status_register (inf_status, PCOQ_HEAD_REGNUM, pc + 0);
+      write_inferior_status_register (inf_status, PCOQ_TAIL_REGNUM, pc + 4);
       sid = (pc >> 30) & 0x3;
       if (sid == 0)
        pcspace = read_register (SR4_REGNUM);
       else
        pcspace = read_register (SR4_REGNUM + 4 + sid);
-      memcpy (inf_status->registers + REGISTER_BYTE (PCSQ_HEAD_REGNUM),
-             &pcspace, 4);
-      memcpy (inf_status->registers + REGISTER_BYTE (PCSQ_TAIL_REGNUM),
-             &pcspace, 4);
+      write_inferior_status_register (inf_status, PCSQ_HEAD_REGNUM, pcspace);
+      write_inferior_status_register (inf_status, PCSQ_TAIL_REGNUM, pcspace);
     }
   else
     pcspace = read_register (PCSQ_HEAD_REGNUM);
@@ -2429,6 +2425,13 @@ pa_register_look_aside(raw_regs, regnum, raw_val)
          have to cast away the type in our offset calculation:
          otherwise we get an offset of 1! */
 
+      /* NB: save_state_t is not available before HPUX 9.
+        The ss_wide field is not available previous to HPUX 10.20,
+         so to avoid compile-time warnings, we only compile this for
+         PA 2.0 processors.  This control path should only be followed
+         if we're debugging a PA 2.0 processor, so this should not cause
+         problems. */
+
       /* #if the following code out so that this file can still be
          compiled on older HPUX boxes (< 10.20) which don't have
          this structure/structure member.  */
@@ -4276,9 +4279,6 @@ child_get_current_exception_event ()
   return &current_ex_event;
 }
 
-
-#ifdef MAINTENANCE_CMDS
-
 static void
 unwind_command (exp, from_tty)
      char *exp;
@@ -4350,7 +4350,6 @@ unwind_command (exp, from_tty)
   pin (Entry_GR);
   pin (Total_frame_size);
 }
-#endif /* MAINTENANCE_CMDS */
 
 #ifdef PREPARE_TO_PROCEED
 
@@ -4437,9 +4436,7 @@ _initialize_hppa_tdep ()
 {
   tm_print_insn = print_insn_hppa;
 
-#ifdef MAINTENANCE_CMDS
   add_cmd ("unwind", class_maintenance, unwind_command,
           "Print unwind table entry at given address.",
           &maintenanceprintlist);
-#endif /* MAINTENANCE_CMDS */
 }
index 52ce1fdc4a58310a880678ad4e63c3808a3c9aa7..a795e0250cb3e3e735ff1dbca795c81eaa1a1ae1 100644 (file)
@@ -106,7 +106,6 @@ store_inferior_registers (regno)
 {
   register unsigned int regaddr;
   char buf[80];
-  extern char registers[];
   register int i;
   unsigned int offset = U_REGS_OFFSET;
   int scratch;
index ac7f69f0a34cf07bdb64be8ee32f8ca7c1f1c5ca..dbf41c425ceb2c8206e1ca1331067c75fa9e7bb6 100644 (file)
@@ -55,7 +55,6 @@ store_inferior_registers (regno)
 {
   register unsigned int regaddr;
   char buf[80];
-  extern char registers[];
   register int i;
   unsigned int offset = U_REGS_OFFSET;
   int scratch;
index 1daa81d6aeedd4477c0909d9ffafd910ee4bc81a..228b1acdde7ce5e5638cb6298bd67f3fd74d61cb 100644 (file)
@@ -56,6 +56,12 @@ static char *valid_flavors[] = {
 };
 static char *disassembly_flavor = att_flavor;
 
+/* This is used to keep the bfd arch_info in sync with the disassembly flavor.  */
+static void set_disassembly_flavor_sfunc PARAMS ((char *, int, struct cmd_list_element *));
+static void set_disassembly_flavor ();
+
+void (*disassembly_flavor_hook) PARAMS((char *args, int from_tty));
+
 /* Stdio style buffering was used to minimize calls to ptrace, but this
    buffering did not take into account that the code section being accessed
    may not be an even number of buffers long (even if the buffer is only
@@ -366,7 +372,7 @@ i386_frame_num_args (fi)
        nameless arguments.  */
     return -1;
 
-  pfi = get_prev_frame_info (fi);                      
+  pfi = get_prev_frame (fi);                   
   if (pfi == 0)
     {
       /* Note:  this can happen if we are looking at the frame for
@@ -772,23 +778,58 @@ gdb_print_insn_i386 (memaddr, info)
     return print_insn_i386_att (memaddr, info);
   else if (disassembly_flavor == intel_flavor)
     return print_insn_i386_intel (memaddr, info);
+  /* Never reached - disassembly_flavour is always either att_flavor
+     or intel_flavor */
+  abort ();
+}
+
+/* If the disassembly mode is intel, we have to also switch the
+   bfd mach_type.  This function is run in the set disassembly_flavor
+   command, and does that.  */
+
+static void
+set_disassembly_flavor_sfunc (args, from_tty, c)
+     char *args;
+     int from_tty;
+     struct cmd_list_element *c;
+{
+  set_disassembly_flavor ();
+  
+  if (disassembly_flavor_hook != NULL)
+    disassembly_flavor_hook(args, from_tty);
+}
+
+static void
+set_disassembly_flavor ()
+{
+  if (disassembly_flavor == att_flavor)
+    set_architecture_from_arch_mach (bfd_arch_i386, bfd_mach_i386_i386);
+  else if (disassembly_flavor == intel_flavor)
+    set_architecture_from_arch_mach (bfd_arch_i386, bfd_mach_i386_i386_intel_syntax);
 }
 
 void
 _initialize_i386_tdep ()
 {
+  struct cmd_list_element *new_cmd;
+  
   tm_print_insn = gdb_print_insn_i386;
   tm_print_insn_info.mach = bfd_lookup_arch (bfd_arch_i386, 0)->mach;
 
   /* Add the variable that controls the disassembly flavor */
-  add_show_from_set(
-           add_set_enum_cmd ("disassembly-flavor", no_class,
+
+  new_cmd = add_set_enum_cmd ("disassembly-flavor", no_class,
                                  valid_flavors,
                                  (char *) &disassembly_flavor,
                                  "Set the disassembly flavor, the valid values are \"att\" and \"intel\", \
 and the default value is \"att\".",
-                                 &setlist),
-           &showlist);
+                                 &setlist);
+  new_cmd->function.sfunc = set_disassembly_flavor_sfunc;
+  add_show_from_set(new_cmd, &showlist);
+  
+  /* Finally, initialize the disassembly flavor to the default given
+     in the disassembly_flavor variable */
 
+  set_disassembly_flavor ();
   
 }
index 20e656e704caed0c2f688ef8a8c13ee32e8c1cd3..83e9624a00f6453d183afe3dfa98d1c867850621 100644 (file)
@@ -253,7 +253,6 @@ store_register (regno)
      int regno;
 {
   char buf[80];
-  extern char registers[];
   errno = 0;
   if (regno < FP0_REGNUM)
     ptrace (PT_WRITE_GPR, inferior_pid, PT_REG(regmap[regno]),
index f843d7f95a3587897a7cc5e3e22634e02bb47436..91090db155221e8fbc0392105d45631d978cc1d5 100644 (file)
@@ -44,7 +44,6 @@ fetch_inferior_registers (regno)
 {
   struct regs inferior_registers;
   struct fp_state inferior_fp_registers;
-  extern char registers[];
 
   registers_fetched ();
 
@@ -73,7 +72,6 @@ store_inferior_registers (regno)
 {
   struct regs inferior_registers;
   struct fp_state inferior_fp_registers;
-  extern char registers[];
 
   memcpy (&inferior_registers, registers, 20 * 4);
 
@@ -121,7 +119,6 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
      CORE_ADDR reg_addr;       /* Unused in this version */
 {
   int val;
-  extern char registers[];
 
   switch (which) {
   case 0:
index ea84c651c4663772176e14e9fd6f2b46250375cc..074c1daf4b9f872b3e9ff7678519584111e8c0df 100644 (file)
@@ -19,6 +19,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
 #include "value.h"
+#include "inferior.h"
 
 #ifdef HAVE_SYS_REG_H
 #include <sys/reg.h>
@@ -127,7 +128,6 @@ fill_gregset (gregsetp, regno)
 {
   int regi;
   register greg_t *regp = (greg_t *) gregsetp;
-  extern char registers[];
   extern int regmap[];
 
   for (regi = 0 ; regi < (NUM_REGS - NUM_FREGS) ; regi++)
index e33415d73999fd3df2f9dde3d9d104c660df6d7e..bb2087a73eb7276ff7495d43a3c7df92cb868df4 100644 (file)
@@ -581,7 +581,8 @@ pop_frame ()
   get_frame_saved_regs (current_fi, &fsr);
   for (i = G0_REGNUM; i < G14_REGNUM; i++)
     {
-      if (save_addr = fsr.regs[i])
+      save_addr = fsr.regs[i];
+      if (save_addr != 0)
        write_register (i, read_memory_integer (save_addr, 4));
     }
 
index 4add1f043cbf6112e85df33341d9e2fef29b58d9..b6df2e9afe1a532c759b22ea0064f043ea8696ff 100644 (file)
@@ -94,9 +94,7 @@ void _initialize_infcmd PARAMS ((void));
 
 #define GO_USAGE   "Usage: go <location>\n"
 
-#ifdef CALL_DUMMY_BREAKPOINT_OFFSET
 static void breakpoint_auto_delete_contents PARAMS ((PTR));
-#endif
 
 #define ERROR_NO_INFERIOR \
    if (!target_has_execution) error ("The program is not being run.");
@@ -570,8 +568,6 @@ signal_command (signum_exp, from_tty)
 /* Call breakpoint_auto_delete on the current contents of the bpstat
    pointed to by arg (which is really a bpstat *).  */
 
-#ifdef CALL_DUMMY_BREAKPOINT_OFFSET
-
 static void
 breakpoint_auto_delete_contents (arg)
      PTR arg;
@@ -579,7 +575,6 @@ breakpoint_auto_delete_contents (arg)
   breakpoint_auto_delete (*(bpstat *)arg);
 }
 
-#endif /* CALL_DUMMY_BREAKPOINT_OFFSET */
 
 /* Execute a "stack dummy", a piece of code stored in the stack
    by the debugger to be executed in the inferior.
@@ -604,7 +599,7 @@ static int stack_dummy_testing = 0;
 int
 run_stack_dummy (addr, buffer)
      CORE_ADDR addr;
-     char buffer[REGISTER_BYTES];
+     char *buffer;
 {
   struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
 
@@ -615,43 +610,45 @@ run_stack_dummy (addr, buffer)
       POP_FRAME;
       return(0);
     }
-#ifdef CALL_DUMMY_BREAKPOINT_OFFSET
-  {
-    struct breakpoint *bpt;
-    struct symtab_and_line sal;
-
-    INIT_SAL (&sal);   /* initialize to zeroes */
-#if CALL_DUMMY_LOCATION != AT_ENTRY_POINT
-    sal.pc = addr - CALL_DUMMY_START_OFFSET + CALL_DUMMY_BREAKPOINT_OFFSET;
-#else
-    sal.pc = CALL_DUMMY_ADDRESS ();
-#endif
-    sal.section = find_pc_overlay (sal.pc);
-
-    /* Set up a FRAME for the dummy frame so we can pass it to
-       set_momentary_breakpoint.  We need to give the breakpoint a
-       frame in case there is only one copy of the dummy (e.g.
-       CALL_DUMMY_LOCATION == AFTER_TEXT_END).  */
-    flush_cached_frames ();
-    set_current_frame (create_new_frame (read_fp (), sal.pc));
-
-    /* If defined, CALL_DUMMY_BREAKPOINT_OFFSET is where we need to put
-       a breakpoint instruction.  If not, the call dummy already has the
-       breakpoint instruction in it.
-
-       addr is the address of the call dummy plus the CALL_DUMMY_START_OFFSET,
-       so we need to subtract the CALL_DUMMY_START_OFFSET.  */
-    bpt = set_momentary_breakpoint (sal,
-                                   get_current_frame (),
-                                   bp_call_dummy);
-    bpt->disposition = del;
-
-    /* If all error()s out of proceed ended up calling normal_stop (and
-       perhaps they should; it already does in the special case of error
-       out of resume()), then we wouldn't need this.  */
-    make_cleanup (breakpoint_auto_delete_contents, &stop_bpstat);
-  }
-#endif /* CALL_DUMMY_BREAKPOINT_OFFSET.  */
+  if (CALL_DUMMY_BREAKPOINT_OFFSET_P)
+    {
+      struct breakpoint *bpt;
+      struct symtab_and_line sal;
+      
+      INIT_SAL (&sal); /* initialize to zeroes */
+      if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
+       {
+         sal.pc = CALL_DUMMY_ADDRESS ();
+       }
+      else
+       {
+         sal.pc = addr - CALL_DUMMY_START_OFFSET + CALL_DUMMY_BREAKPOINT_OFFSET;
+       }
+      sal.section = find_pc_overlay (sal.pc);
+      
+      /* Set up a FRAME for the dummy frame so we can pass it to
+        set_momentary_breakpoint.  We need to give the breakpoint a
+        frame in case there is only one copy of the dummy (e.g.
+        CALL_DUMMY_LOCATION == AFTER_TEXT_END).  */
+      flush_cached_frames ();
+      set_current_frame (create_new_frame (read_fp (), sal.pc));
+      
+      /* If defined, CALL_DUMMY_BREAKPOINT_OFFSET is where we need to put
+        a breakpoint instruction.  If not, the call dummy already has the
+        breakpoint instruction in it.
+        
+        addr is the address of the call dummy plus the CALL_DUMMY_START_OFFSET,
+        so we need to subtract the CALL_DUMMY_START_OFFSET.  */
+      bpt = set_momentary_breakpoint (sal,
+                                     get_current_frame (),
+                                     bp_call_dummy);
+      bpt->disposition = del;
+      
+      /* If all error()s out of proceed ended up calling normal_stop (and
+        perhaps they should; it already does in the special case of error
+        out of resume()), then we wouldn't need this.  */
+      make_cleanup (breakpoint_auto_delete_contents, &stop_bpstat);
+    }
 
   disable_watchpoints_before_interactive_call_start ();
   proceed_to_finish = 1;       /* We want stop_registers, please... */
@@ -665,7 +662,7 @@ run_stack_dummy (addr, buffer)
 
   /* On return, the stack dummy has been popped already.  */
 
-  memcpy (buffer, stop_registers, sizeof stop_registers);
+  memcpy (buffer, stop_registers, REGISTER_BYTES);
   return 0;
 }
 \f
index fa59c2a5ff7e91008e9e9af8eaddc0b4b52855fd..02d942ec1afdb63d4a79abcc7a2a85d29a247ff5 100644 (file)
@@ -27,42 +27,25 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 /* For enum target_signal.  */
 #include "target.h"
 
-/* Structure in which to save the status of the inferior.  Save
+/* Structure in which to save the status of the inferior.  Create/Save
    through "save_inferior_status", restore through
    "restore_inferior_status".
+
    This pair of routines should be called around any transfer of
    control to the inferior which you don't want showing up in your
    control variables.  */
 
-struct inferior_status
-  {
-    enum target_signal stop_signal;
-    CORE_ADDR stop_pc;
-    bpstat stop_bpstat;
-    int stop_step;
-    int stop_stack_dummy;
-    int stopped_by_random_signal;
-    int trap_expected;
-    CORE_ADDR step_range_start;
-    CORE_ADDR step_range_end;
-    CORE_ADDR step_frame_address;
-    int step_over_calls;
-    CORE_ADDR step_resume_break_address;
-    int stop_after_trap;
-    int stop_soon_quietly;
-    CORE_ADDR selected_frame_address;
-    char stop_registers[REGISTER_BYTES];
-
-    /* These are here because if call_function_by_hand has written some
-     registers and then decides to call error(), we better not have changed
-     any registers.  */
-    char registers[REGISTER_BYTES];
-
-    int selected_level;
-    int breakpoint_proceeded;
-    int restore_stack_info;
-    int proceed_to_finish;
-  };
+#ifdef __STDC__
+struct inferior_status;
+#endif
+
+extern struct inferior_status *save_inferior_status PARAMS ((int));
+
+extern void restore_inferior_status PARAMS ((struct inferior_status *));
+
+extern void discard_inferior_status PARAMS ((struct inferior_status *));
+
+extern void write_inferior_status_register PARAMS ((struct inferior_status *inf_status, int regno, LONGEST val));
 
 /* This macro gives the number of registers actually in use by the
    inferior.  This may be less than the total number of registers,
@@ -72,10 +55,6 @@ struct inferior_status
 #define ARCH_NUM_REGS NUM_REGS
 #endif
 
-extern void save_inferior_status PARAMS ((struct inferior_status *, int));
-
-extern void restore_inferior_status PARAMS ((struct inferior_status *));
-
 extern void set_sigint_trap PARAMS ((void));
 
 extern void clear_sigint_trap PARAMS ((void));
@@ -117,15 +96,15 @@ extern int inferior_ignoring_leading_exec_events;
 
 extern struct environ *inferior_environ;
 
-/* Character array containing an image of the inferior programs' registers.  */
+/* Character array containing an image of the inferior programs'
+   registers. */
 
-extern char registers[];
+extern char *registers;
 
-/* Array of validity bits (one per register).  Nonzero at position XXX_REGNUM
-   means that `registers' contains a valid copy of inferior register XXX.
-   -1 if register value is not available. */
+/* Character array containing the current state of each register
+   (unavailable<0, valid=0, invalid>0). */
 
-extern SIGNED char register_valid[NUM_REGS];
+extern signed char *register_valid;
 
 extern void clear_proceed_status PARAMS ((void));
 
@@ -137,7 +116,7 @@ extern void generic_mourn_inferior PARAMS ((void));
 
 extern void terminal_ours PARAMS ((void));
 
-extern int run_stack_dummy PARAMS ((CORE_ADDR, char[REGISTER_BYTES]));
+extern int run_stack_dummy PARAMS ((CORE_ADDR, char*));
 
 extern CORE_ADDR read_pc PARAMS ((void));
 
@@ -202,6 +181,7 @@ extern int attach PARAMS ((int));
 
 extern void detach PARAMS ((int));
 
+/* PTRACE method of waiting for inferior process.  */
 int ptrace_wait PARAMS ((int, int *));
 
 extern void child_resume PARAMS ((int, int, enum target_signal));
@@ -340,7 +320,7 @@ extern int proceed_to_finish;
    Thus this contains the return value from the called function (assuming
    values are returned in a register).  */
 
-extern char stop_registers[REGISTER_BYTES];
+extern char *stop_registers;
 
 /* Nonzero if the child process in inferior_pid was attached rather
    than forked.  */
@@ -376,57 +356,103 @@ extern int attach_flag;
 #define AFTER_TEXT_END 3
 #define AT_ENTRY_POINT 4
 
+#if !defined (USE_GENERIC_DUMMY_FRAMES)
+#define USE_GENERIC_DUMMY_FRAMES 0
+#endif
+
 #if !defined (CALL_DUMMY_LOCATION)
 #define CALL_DUMMY_LOCATION ON_STACK
 #endif /* No CALL_DUMMY_LOCATION.  */
 
-/* Are we in a call dummy?  The code below which allows DECR_PC_AFTER_BREAK
-   below is for infrun.c, which may give the macro a pc without that
-   subtracted out.  */
-#if !defined (PC_IN_CALL_DUMMY)
-#if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
-extern CORE_ADDR text_end;
-#define PC_IN_CALL_DUMMY(pc, sp, frame_address) \
-  ((pc) >= text_end - CALL_DUMMY_LENGTH         \
-   && (pc) <= text_end + DECR_PC_AFTER_BREAK)
+#if !defined (CALL_DUMMY_ADDRESS)
+#define CALL_DUMMY_ADDRESS() (abort (), 0) /* anything to abort GDB */
+#endif
+#if !defined (CALL_DUMMY_START_OFFSET)
+#define CALL_DUMMY_START_OFFSET (abort (), 0) /* anything to abort GDB */
+#endif
+#if !defined (CALL_DUMMY_BREAKPOINT_OFFSET)
+#define CALL_DUMMY_BREAKPOINT_OFFSET_P (0)
+#define CALL_DUMMY_BREAKPOINT_OFFSET (abort (), 0) /* anything to abort GDB */
+#endif
+#if !defined CALL_DUMMY_BREAKPOINT_OFFSET_P
+#define CALL_DUMMY_BREAKPOINT_OFFSET_P (1)
+#endif
+#if !defined (CALL_DUMMY_LENGTH)
+#define CALL_DUMMY_LENGTH (abort (), 0) /* anything to abort GDB */
+#endif
+
+#if defined (CALL_DUMMY_STACK_ADJUST)
+#if !defined (CALL_DUMMY_STACK_ADJUST_P)
+#define CALL_DUMMY_STACK_ADJUST_P (1)
+#endif
+#endif
+#if !defined (CALL_DUMMY_STACK_ADJUST)
+#define CALL_DUMMY_STACK_ADJUST (abort (), 0)
+#endif
+#if !defined (CALL_DUMMY_STACK_ADJUST_P)
+#define CALL_DUMMY_STACK_ADJUST_P (0)
+#endif
+
+#if !defined (CALL_DUMMY_P)
+#if defined (CALL_DUMMY)
+#define CALL_DUMMY_P 1
+#else
+#define CALL_DUMMY_P 0
+#endif
+#endif
+
+#if !defined (CALL_DUMMY_WORDS)
+#if defined (CALL_DUMMY)
+extern LONGEST call_dummy_words[];
+#define CALL_DUMMY_WORDS (call_dummy_words)
+#else
+#define CALL_DUMMY_WORDS (abort (), (void*) 0) /* anything to abort GDB */
+#endif
+#endif
+
+#if !defined (SIZEOF_CALL_DUMMY_WORDS)
+#if defined (CALL_DUMMY)
+extern int sizeof_call_dummy_words;
+#define SIZEOF_CALL_DUMMY_WORDS (sizeof_call_dummy_words)
+#else
+#define SIZEOF_CALL_DUMMY_WORDS (abort (), 0) /* anything to abort GDB */
+#endif
+#endif
+
+#if !defined PUSH_DUMMY_FRAME
+#define PUSH_DUMMY_FRAME (abort ())
+#endif
+
+#if !defined FIX_CALL_DUMMY
+#define FIX_CALL_DUMMY(a1,a2,a3,a4,a5,a6,a7) (abort ())
+#endif
+
+#if !defined STORE_STRUCT_RETURN
+#define STORE_STRUCT_RETURN(a1,a2) (abort ())
+#endif
+
+
+/* Are we in a call dummy? */
+
+extern int pc_in_call_dummy_before_text_end PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address));
+#if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == BEFORE_TEXT_END
+#define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_before_text_end (pc, sp, frame_address)
 #endif /* Before text_end.  */
 
-#if CALL_DUMMY_LOCATION == AFTER_TEXT_END
-extern CORE_ADDR text_end;
-#define PC_IN_CALL_DUMMY(pc, sp, frame_address) \
-  ((pc) >= text_end   \
-   && (pc) <= text_end + CALL_DUMMY_LENGTH + DECR_PC_AFTER_BREAK)
-#endif /* After text_end.  */
-
-#if CALL_DUMMY_LOCATION == ON_STACK
-/* Is the PC in a call dummy?  SP and FRAME_ADDRESS are the bottom and
-   top of the stack frame which we are checking, where "bottom" and
-   "top" refer to some section of memory which contains the code for
-   the call dummy.  Calls to this macro assume that the contents of
-   SP_REGNUM and FP_REGNUM (or the saved values thereof), respectively,
-   are the things to pass.
-
-   This won't work on the 29k, where SP_REGNUM and FP_REGNUM don't
-   have that meaning, but the 29k doesn't use ON_STACK.  This could be
-   fixed by generalizing this scheme, perhaps by passing in a frame
-   and adding a few fields, at least on machines which need them for
-   PC_IN_CALL_DUMMY.
-
-   Something simpler, like checking for the stack segment, doesn't work,
-   since various programs (threads implementations, gcc nested function
-   stubs, etc) may either allocate stack frames in another segment, or
-   allocate other kinds of code on the stack.  */
-
-#define PC_IN_CALL_DUMMY(pc, sp, frame_address) \
-  (INNER_THAN ((sp), (pc)) && (frame_address != 0) && INNER_THAN ((pc), (frame_address)))
-#endif /* On stack.  */
-
-#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
-#define PC_IN_CALL_DUMMY(pc, sp, frame_address)                        \
-  ((pc) >= CALL_DUMMY_ADDRESS ()                               \
-   && (pc) <= (CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK))
-#endif /* At entry point.  */
-#endif /* No PC_IN_CALL_DUMMY.  */
+extern int pc_in_call_dummy_after_text_end PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address));
+#if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == AFTER_TEXT_END
+#define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_after_text_end (pc, sp, frame_address) 
+#endif
+
+extern int pc_in_call_dummy_on_stack PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address));
+#if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == ON_STACK
+#define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_on_stack (pc, sp, frame_address)
+#endif
+
+extern int pc_in_call_dummy_at_entry_point PARAMS ((CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address));
+#if !defined (PC_IN_CALL_DUMMY) && CALL_DUMMY_LOCATION == AT_ENTRY_POINT
+#define PC_IN_CALL_DUMMY(pc, sp, frame_address) pc_in_call_dummy_at_entry_point (pc, sp, frame_address)
+#endif
 
 /* It's often not enough for our clients to know whether the PC is merely
    somewhere within the call dummy.  They may need to know whether the
index 9033675162205d5907558c941a7fa9c633475f77..d6a3bb1421aca14d4e9f75d564a76605b03f9d7d 100644 (file)
@@ -33,6 +33,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
 
 #ifdef HAVE_TERMIOS
 #define PROCESS_GROUP_TYPE pid_t
index 5fd8fc107c7bf23f1c7b2e54039711dd9b2d2d0a..12f1cd390d3ee58906a2bcbcd2ca810dee8f9f59 100644 (file)
@@ -1,6 +1,5 @@
 /* Target-struct-independent code to start (run) and stop an inferior process.
-   Copyright 1986, 87, 88, 89, 91, 92, 93, 94, 95, 96, 97, 1998
-   Free Software Foundation, Inc.
+   Copyright 1986-1989, 1991-1999 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -32,6 +31,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "gdbthread.h"
 #include "annotate.h"
 #include "symfile.h"           /* for overlay functions */
+#include "top.h"
 
 #include <signal.h>
 
@@ -51,16 +51,35 @@ static int hook_stop_stub PARAMS ((PTR));
 
 static void delete_breakpoint_current_contents PARAMS ((PTR));
 
+static void set_follow_fork_mode_command PARAMS ((char *arg, int from_tty, struct cmd_list_element *c));
+
 int inferior_ignoring_startup_exec_events = 0;
 int inferior_ignoring_leading_exec_events = 0;
 
-#ifdef HPUXHPPA
 /* wait_for_inferior and normal_stop use this to notify the user
    when the inferior stopped in a different thread than it had been
    running in. */
 static int switched_from_inferior_pid;
+
+/* This will be true for configurations that may actually report an
+   inferior pid different from the original.  At present this is only
+   true for HP-UX native.  */
+
+#ifndef MAY_SWITCH_FROM_INFERIOR_PID
+#define MAY_SWITCH_FROM_INFERIOR_PID (0)
+#endif
+
+static int may_switch_from_inferior_pid = MAY_SWITCH_FROM_INFERIOR_PID;
+
+/* This is true for configurations that may follow through execl() and
+   similar functions.  At present this is only true for HP-UX native.  */
+
+#ifndef MAY_FOLLOW_EXEC
+#define MAY_FOLLOW_EXEC (0)
 #endif
 
+static int may_follow_exec = MAY_FOLLOW_EXEC;
+
 /* resume and wait_for_inferior use this to ensure that when
    stepping over a hit breakpoint in a threaded application
    only the thread that hit the breakpoint is stepped and the
@@ -76,6 +95,15 @@ static int switched_from_inferior_pid;
    thread steps and others wait" shouldn't do this. */
 static int thread_step_needed = 0;
 
+/* This is true if thread_step_needed should actually be used.  At
+   present this is only true for HP-UX native.  */
+
+#ifndef USE_THREAD_STEP_NEEDED
+#define USE_THREAD_STEP_NEEDED (0)
+#endif
+
+static int use_thread_step_needed = USE_THREAD_STEP_NEEDED;
+
 void _initialize_infrun PARAMS ((void));
 
 /* GET_LONGJMP_TARGET returns the PC at which longjmp() will resume the
@@ -164,6 +192,30 @@ void _initialize_infrun PARAMS ((void));
 #define INSTRUCTION_NULLIFIED 0
 #endif
 
+/* Convert the #defines into values.  This is temporary until wfi control
+   flow is completely sorted out.  */
+
+#ifndef HAVE_STEPPABLE_WATCHPOINT
+#define HAVE_STEPPABLE_WATCHPOINT 0
+#else
+#undef  HAVE_STEPPABLE_WATCHPOINT
+#define HAVE_STEPPABLE_WATCHPOINT 1
+#endif
+
+#ifndef HAVE_NONSTEPPABLE_WATCHPOINT
+#define HAVE_NONSTEPPABLE_WATCHPOINT 0
+#else
+#undef  HAVE_NONSTEPPABLE_WATCHPOINT
+#define HAVE_NONSTEPPABLE_WATCHPOINT 1
+#endif
+
+#ifndef HAVE_CONTINUABLE_WATCHPOINT
+#define HAVE_CONTINUABLE_WATCHPOINT 0
+#else
+#undef  HAVE_CONTINUABLE_WATCHPOINT
+#define HAVE_CONTINUABLE_WATCHPOINT 1
+#endif
+
 /* Tables of how to react to signals; the user sets them.  */
 
 static unsigned char *signal_stop;
@@ -239,7 +291,7 @@ int proceed_to_finish;
    Thus this contains the return value from the called function (assuming
    values are returned in a register).  */
 
-char stop_registers[REGISTER_BYTES];
+char *stop_registers;
 
 /* Nonzero if program stopped due to error trying to insert breakpoints.  */
 
@@ -308,7 +360,6 @@ static char *follow_fork_mode_kind_names[] =
 static char *follow_fork_mode_string = NULL;
 \f
 
-#if defined(HPUXHPPA)
 static void
 follow_inferior_fork (parent_pid, child_pid, has_forked, has_vforked)
      int parent_pid;
@@ -349,7 +400,9 @@ follow_inferior_fork (parent_pid, child_pid, has_forked, has_vforked)
       if (!has_vforked || !follow_vfork_when_exec)
        {
          detach_breakpoints (child_pid);
+#ifdef SOLIB_REMOVE_INFERIOR_HOOK
          SOLIB_REMOVE_INFERIOR_HOOK (child_pid);
+#endif
        }
 
       /* Detach from the child. */
@@ -381,7 +434,9 @@ follow_inferior_fork (parent_pid, child_pid, has_forked, has_vforked)
       remove_breakpoints ();
 
       /* Also reset the solib inferior hook from the parent. */
+#ifdef SOLIB_REMOVE_INFERIOR_HOOK
       SOLIB_REMOVE_INFERIOR_HOOK (inferior_pid);
+#endif
 
       /* Detach from the parent. */
       dont_repeat ();
@@ -508,16 +563,17 @@ follow_vfork (parent_pid, child_pid)
       free (pending_follow.execd_pathname);
     }
 }
-#endif /* HPUXHPPA */
 
 static void
 follow_exec (pid, execd_pathname)
      int pid;
      char *execd_pathname;
 {
-#ifdef HPUXHPPA
   int saved_pid = pid;
-  extern struct target_ops child_ops;
+  struct target_ops *tgt;
+
+  if (!may_follow_exec)
+    return;
 
   /* Did this exec() follow a vfork()?  If so, we must follow the
      vfork now too.  Do it before following the exec. */
@@ -571,10 +627,17 @@ follow_exec (pid, execd_pathname)
 
   /* We've followed the inferior through an exec.  Therefore, the
      inferior has essentially been killed & reborn. */
+
+  /* First collect the run target in effect.  */
+  tgt = find_run_target ();
+  /* If we can't find one, things are in a very strange state...  */
+  if (tgt == NULL)
+    error ("Could find run target to save before following exec");
+
   gdb_flush (gdb_stdout);
   target_mourn_inferior ();
-  inferior_pid = saved_pid;    /* Because mourn_inferior resets inferior_pid. */
-  push_target (&child_ops);
+  inferior_pid = saved_pid;   /* Because mourn_inferior resets inferior_pid. */
+  push_target (tgt);
 
   /* That a.out is now the one to use. */
   exec_file_attach (execd_pathname, 0);
@@ -585,8 +648,12 @@ follow_exec (pid, execd_pathname)
   /* Reset the shared library package.  This ensures that we get
      a shlib event when the child reaches "_start", at which point
      the dld will have had a chance to initialize the child. */
+#if defined(SOLIB_RESTART)
   SOLIB_RESTART ();
+#endif
+#ifdef SOLIB_CREATE_INFERIOR_HOOK
   SOLIB_CREATE_INFERIOR_HOOK (inferior_pid);
+#endif
 
   /* Reinsert all breakpoints.  (Those which were symbolic have
      been reset to the proper address in the new a.out, thanks
@@ -597,7 +664,6 @@ follow_exec (pid, execd_pathname)
      startup breakpoints.  (If the user had also set bp's on
      "main" from the old (parent) process, then they'll auto-
      matically get reset there in the new process.) */
-#endif
 }
 
 /* Non-zero if we just simulating a single-step.  This is needed
@@ -680,7 +746,6 @@ resume (step, sig)
   DO_DEFERRED_STORES;
 #endif
 
-#ifdef HPUXHPPA
   /* If there were any forks/vforks/execs that were caught and are
      now to be followed, then do so. */
   switch (pending_follow.kind)
@@ -717,15 +782,13 @@ resume (step, sig)
     default:
       break;
     }
-#endif /* HPUXHPPA */
 
   /* Install inferior's terminal modes.  */
   target_terminal_inferior ();
 
   if (should_resume)
     {
-#ifdef HPUXHPPA
-      if (thread_step_needed)
+      if (use_thread_step_needed && thread_step_needed)
        {
          /* We stopped on a BPT instruction;
             don't continue other threads and
@@ -753,7 +816,6 @@ resume (step, sig)
            }
        }
       else
-#endif /* HPUXHPPA */
        {
          /* Vanilla resume. */
 
@@ -1004,9 +1066,6 @@ wait_for_inferior ()
   CORE_ADDR stop_func_start;
   CORE_ADDR stop_func_end;
   char *stop_func_name;
-#if 0
-  CORE_ADDR prologue_pc = 0;
-#endif
   CORE_ADDR tmp;
   struct symtab_and_line sal;
   int remove_breakpoints_on_following_step = 0;
@@ -1021,10 +1080,7 @@ wait_for_inferior ()
   int enable_hw_watchpoints_after_wait = 0;
   int stepping_through_sigtramp = 0;
   int new_thread_event;
-
-#ifdef HAVE_NONSTEPPABLE_WATCHPOINT
   int stepped_after_stopped_by_watchpoint;
-#endif
 
   old_cleanups = make_cleanup (delete_breakpoint_current_contents,
                               &step_resume_breakpoint);
@@ -1045,15 +1101,12 @@ wait_for_inferior ()
   ;
   thread_step_needed = 0;
 
-#ifdef HPUXHPPA
   /* We'll update this if & when we switch to a new thread. */
-  switched_from_inferior_pid = inferior_pid;
-#endif
+  if (may_switch_from_inferior_pid)
+    switched_from_inferior_pid = inferior_pid;
 
   while (1)
     {
-      extern int overlay_cache_invalid;        /* declared in symfile.h */
-
       overlay_cache_invalid = 1;
 
       /* We have to invalidate the registers BEFORE calling target_wait because
@@ -1081,10 +1134,7 @@ wait_for_inferior ()
          enable_hw_watchpoints_after_wait = 0;
        }
 
-
-#ifdef HAVE_NONSTEPPABLE_WATCHPOINT
       stepped_after_stopped_by_watchpoint = 0;
-#endif
 
       /* Gross.
 
@@ -1105,14 +1155,7 @@ wait_for_inferior ()
        {
          add_thread (pid);
 
-
-#ifdef HPUXHPPA
-         fprintf_unfiltered (gdb_stderr, "[New %s]\n",
-                             target_pid_or_tid_to_str (pid));
-
-#else
-         printf_filtered ("[New %s]\n", target_pid_to_str (pid));
-#endif
+         printf_filtered ("[New %s]\n", target_pid_or_tid_to_str (pid));
 
 #if 0
          /* NOTE: This block is ONLY meant to be invoked in case of a
@@ -1148,8 +1191,6 @@ wait_for_inferior ()
 #ifdef SOLIB_ADD
          if (!stop_soon_quietly)
            {
-             extern int auto_solib_add;
-
              /* Remove breakpoints, SOLIB_ADD might adjust
                 breakpoint addresses via breakpoint_re_set.  */
              if (breakpoints_inserted)
@@ -1255,12 +1296,10 @@ wait_for_inferior ()
          inferior_pid = pid;
          stop_bpstat = bpstat_stop_status
            (&stop_pc,
-#if DECR_PC_AFTER_BREAK
-            (prev_pc != stop_pc - DECR_PC_AFTER_BREAK
-             && CURRENTLY_STEPPING ())
-#else /* DECR_PC_AFTER_BREAK zero */
-            0
-#endif /* DECR_PC_AFTER_BREAK zero */
+            (DECR_PC_AFTER_BREAK ? 
+             (prev_pc != stop_pc - DECR_PC_AFTER_BREAK
+              && CURRENTLY_STEPPING ())
+             : 0)
            );
          random_signal = !bpstat_explains_signal (stop_bpstat);
          inferior_pid = saved_inferior_pid;
@@ -1310,13 +1349,11 @@ wait_for_inferior ()
          stop_pc = read_pc ();
          stop_bpstat = bpstat_stop_status
            (&stop_pc,
-#if DECR_PC_AFTER_BREAK
-            (prev_pc != stop_pc - DECR_PC_AFTER_BREAK
-             && CURRENTLY_STEPPING ())
-#else /* DECR_PC_AFTER_BREAK zero */
-            0
-#endif /* DECR_PC_AFTER_BREAK zero */
-           );
+            (DECR_PC_AFTER_BREAK ? 
+             (prev_pc != stop_pc - DECR_PC_AFTER_BREAK
+              && CURRENTLY_STEPPING ())
+             : 0)
+            );
          random_signal = !bpstat_explains_signal (stop_bpstat);
          goto process_event_stop_test;
 
@@ -1380,13 +1417,11 @@ wait_for_inferior ()
          inferior_pid = pid;
          stop_bpstat = bpstat_stop_status
            (&stop_pc,
-#if DECR_PC_AFTER_BREAK
-            (prev_pc != stop_pc - DECR_PC_AFTER_BREAK
-             && CURRENTLY_STEPPING ())
-#else /* DECR_PC_AFTER_BREAK zero */
-            0
-#endif /* DECR_PC_AFTER_BREAK zero */
-           );
+            (DECR_PC_AFTER_BREAK ? 
+             (prev_pc != stop_pc - DECR_PC_AFTER_BREAK
+              && CURRENTLY_STEPPING ())
+             : 0)
+            );
          random_signal = !bpstat_explains_signal (stop_bpstat);
          inferior_pid = saved_inferior_pid;
          goto process_event_stop_test;
@@ -1508,8 +1543,14 @@ wait_for_inferior ()
                      insert_breakpoints ();
                    }
 
-                 /* We need to restart all the threads now.  */
-                 target_resume (-1, 0, TARGET_SIGNAL_0);
+                   /* We need to restart all the threads now,
+                    * unles we're running in scheduler-locked mode. 
+                    * FIXME: shouldn't we look at CURRENTLY_STEPPING ()?
+                    */
+                   if (scheduler_mode == schedlock_on)
+                     target_resume (pid, 0, TARGET_SIGNAL_0);
+                   else
+                     target_resume (-1, 0, TARGET_SIGNAL_0);
                  continue;
                }
              else
@@ -1594,9 +1635,8 @@ wait_for_inferior ()
                             stepping_through_solib_catchpoints,
                             stepping_through_sigtramp);
 
-#ifdef HPUXHPPA
-         switched_from_inferior_pid = inferior_pid;
-#endif
+         if (may_switch_from_inferior_pid)
+           switched_from_inferior_pid = inferior_pid;
 
          inferior_pid = pid;
 
@@ -1630,16 +1670,11 @@ wait_for_inferior ()
         it so that the user won't be confused when GDB appears to be ready
         to execute it. */
 
-#if 0                          /* XXX DEBUG */
-      printf ("infrun.c:1607: pc = 0x%x\n", read_pc ());
-#endif
       /*      if (INSTRUCTION_NULLIFIED && CURRENTLY_STEPPING ()) */
       if (INSTRUCTION_NULLIFIED)
        {
          struct target_waitstatus tmpstatus;
-#if 0
-         all_registers_info ((char *) 0, 0);
-#endif
+
          registers_changed ();
          target_resume (pid, 1, TARGET_SIGNAL_0);
 
@@ -1655,37 +1690,36 @@ wait_for_inferior ()
          goto have_waited;
        }
 
-#ifdef HAVE_STEPPABLE_WATCHPOINT
       /* It may not be necessary to disable the watchpoint to stop over
         it.  For example, the PA can (with some kernel cooperation)
         single step over a watchpoint without disabling the watchpoint.  */
-      if (STOPPED_BY_WATCHPOINT (w))
+      if (HAVE_STEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (w))
        {
          resume (1, 0);
          continue;
        }
-#endif
 
-#ifdef HAVE_NONSTEPPABLE_WATCHPOINT
-      /* It is far more common to need to disable a watchpoint
-        to step the inferior over it.  FIXME.  What else might
-        a debug register or page protection watchpoint scheme need
-        here?  */
-      if (STOPPED_BY_WATCHPOINT (w))
+      /* It is far more common to need to disable a watchpoint to step
+        the inferior over it.  FIXME.  What else might a debug
+        register or page protection watchpoint scheme need here?  */
+      if (HAVE_NONSTEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (w))
        {
-/* At this point, we are stopped at an instruction which has attempted to write
-   to a piece of memory under control of a watchpoint.  The instruction hasn't
-   actually executed yet.  If we were to evaluate the watchpoint expression
-   now, we would get the old value, and therefore no change would seem to have
-   occurred.
-
-   In order to make watchpoints work `right', we really need to complete the
-   memory write, and then evaluate the watchpoint expression.  The following
-   code does that by removing the watchpoint (actually, all watchpoints and
-   breakpoints), single-stepping the target, re-inserting watchpoints, and then
-   falling through to let normal single-step processing handle proceed.  Since
-   this includes evaluating watchpoints, things will come to a stop in the
-   correct manner.  */
+         /* At this point, we are stopped at an instruction which has
+            attempted to write to a piece of memory under control of
+            a watchpoint.  The instruction hasn't actually executed
+            yet.  If we were to evaluate the watchpoint expression
+            now, we would get the old value, and therefore no change
+            would seem to have occurred.
+
+            In order to make watchpoints work `right', we really need
+            to complete the memory write, and then evaluate the
+            watchpoint expression.  The following code does that by
+            removing the watchpoint (actually, all watchpoints and
+            breakpoints), single-stepping the target, re-inserting
+            watchpoints, and then falling through to let normal
+            single-step processing handle proceed.  Since this
+            includes evaluating watchpoints, things will come to a
+            stop in the correct manner.  */
 
          write_pc (stop_pc - DECR_PC_AFTER_BREAK);
 
@@ -1705,12 +1739,10 @@ wait_for_inferior ()
          stepped_after_stopped_by_watchpoint = 1;
          goto have_waited;
        }
-#endif
 
-#ifdef HAVE_CONTINUABLE_WATCHPOINT
       /* It may be possible to simply continue after a watchpoint.  */
-      STOPPED_BY_WATCHPOINT (w);
-#endif
+      if (HAVE_CONTINUABLE_WATCHPOINT)
+       STOPPED_BY_WATCHPOINT (w);
 
       stop_func_start = 0;
       stop_func_end = 0;
@@ -1800,23 +1832,21 @@ wait_for_inferior ()
            random_signal
              = !(bpstat_explains_signal (stop_bpstat)
                  || trap_expected
-#ifndef CALL_DUMMY_BREAKPOINT_OFFSET
-                 || PC_IN_CALL_DUMMY (stop_pc, read_sp (),
-                                      FRAME_FP (get_current_frame ()))
-#endif /* No CALL_DUMMY_BREAKPOINT_OFFSET.  */
+                 || (!CALL_DUMMY_BREAKPOINT_OFFSET_P
+                     && PC_IN_CALL_DUMMY (stop_pc, read_sp (),
+                                          FRAME_FP (get_current_frame ())))
                  || (step_range_end && step_resume_breakpoint == NULL));
 
          else
            {
              random_signal
                = !(bpstat_explains_signal (stop_bpstat)
-             /* End of a stack dummy.  Some systems (e.g. Sony
-                      news) give another signal besides SIGTRAP,
-                      so check here as well as above.  */
-#ifndef CALL_DUMMY_BREAKPOINT_OFFSET
-                   || PC_IN_CALL_DUMMY (stop_pc, read_sp (),
-                                        FRAME_FP (get_current_frame ()))
-#endif /* No CALL_DUMMY_BREAKPOINT_OFFSET.  */
+                   /* End of a stack dummy.  Some systems (e.g. Sony
+                      news) give another signal besides SIGTRAP, so
+                      check here as well as above.  */
+                   || (!CALL_DUMMY_BREAKPOINT_OFFSET_P
+                       && PC_IN_CALL_DUMMY (stop_pc, read_sp (),
+                                            FRAME_FP (get_current_frame ())))
                );
              if (!random_signal)
                stop_signal = TARGET_SIGNAL_TRAP;
@@ -2063,8 +2093,6 @@ wait_for_inferior ()
          case BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK:
 #ifdef SOLIB_ADD
            {
-             extern int auto_solib_add;
-
              /* Remove breakpoints, we eventually want to step over the
                 shlib event breakpoint, and SOLIB_ADD might adjust
                 breakpoint addresses via breakpoint_re_set.  */
@@ -2177,29 +2205,30 @@ wait_for_inferior ()
          goto stop_stepping;
        }
 
-#ifndef CALL_DUMMY_BREAKPOINT_OFFSET
-      /* This is the old way of detecting the end of the stack dummy.
-        An architecture which defines CALL_DUMMY_BREAKPOINT_OFFSET gets
-        handled above.  As soon as we can test it on all of them, all
-        architectures should define it.  */
-
-      /* If this is the breakpoint at the end of a stack dummy,
-        just stop silently, unless the user was doing an si/ni, in which
-        case she'd better know what she's doing.  */
-
-      if (CALL_DUMMY_HAS_COMPLETED (stop_pc, read_sp (),
-                                   FRAME_FP (get_current_frame ()))
-         && !step_range_end)
+      if (!CALL_DUMMY_BREAKPOINT_OFFSET_P)
        {
-         stop_print_frame = 0;
-         stop_stack_dummy = 1;
+         /* This is the old way of detecting the end of the stack dummy.
+            An architecture which defines CALL_DUMMY_BREAKPOINT_OFFSET gets
+            handled above.  As soon as we can test it on all of them, all
+            architectures should define it.  */
+         
+         /* If this is the breakpoint at the end of a stack dummy,
+            just stop silently, unless the user was doing an si/ni, in which
+            case she'd better know what she's doing.  */
+         
+         if (CALL_DUMMY_HAS_COMPLETED (stop_pc, read_sp (),
+                                       FRAME_FP (get_current_frame ()))
+             && !step_range_end)
+           {
+             stop_print_frame = 0;
+             stop_stack_dummy = 1;
 #ifdef HP_OS_BUG
-         trap_expected_after_continue = 1;
+             trap_expected_after_continue = 1;
 #endif
-         break;
+             break;
+           }
        }
-#endif /* No CALL_DUMMY_BREAKPOINT_OFFSET.  */
-
+      
       if (step_resume_breakpoint)
        /* Having a step-resume breakpoint overrides anything
           else having to do with stepping commands until
@@ -2207,34 +2236,20 @@ wait_for_inferior ()
        /* I'm not sure whether this needs to be check_sigtramp2 or
           whether it could/should be keep_going.  */
        goto check_sigtramp2;
-
+      
       if (step_range_end == 0)
        /* Likewise if we aren't even stepping.  */
        /* I'm not sure whether this needs to be check_sigtramp2 or
           whether it could/should be keep_going.  */
        goto check_sigtramp2;
-
+      
       /* If stepping through a line, keep going if still within it.
-
+        
          Note that step_range_end is the address of the first instruction
          beyond the step range, and NOT the address of the last instruction
          within it! */
       if (stop_pc >= step_range_start
-         && stop_pc < step_range_end
-#if 0
-/* I haven't a clue what might trigger this clause, and it seems wrong
-   anyway, so I've disabled it until someone complains.  -Stu 10/24/95 */
-
-      /* The step range might include the start of the
-            function, so if we are at the start of the
-            step range and either the stack or frame pointers
-            just changed, we've stepped outside */
-         && !(stop_pc == step_range_start
-              && FRAME_FP (get_current_frame ())
-              && (INNER_THAN (read_sp (), step_sp)
-                  || FRAME_FP (get_current_frame ()) != step_frame_address))
-#endif
-       )
+         && stop_pc < step_range_end)
        {
          /* We might be doing a BPSTAT_WHAT_SINGLE and getting a signal.
             So definately need to check for sigtramp here.  */
@@ -2338,91 +2353,11 @@ wait_for_inferior ()
          goto keep_going;
        }
 
-#if 0
-      /* I disabled this test because it was too complicated and slow.
-        The SKIP_PROLOGUE was especially slow, because it caused
-        unnecessary prologue examination on various architectures.
-        The code in the #else clause has been tested on the Sparc,
-        Mips, PA, and Power architectures, so it's pretty likely to
-        be correct.  -Stu 10/24/95 */
-
-      /* See if we left the step range due to a subroutine call that
-        we should proceed to the end of.  */
-
-      if (stop_func_start)
-       {
-         struct symtab *s;
-
-         /* Do this after the IN_SIGTRAMP check; it might give
-            an error.  */
-         prologue_pc = stop_func_start;
-
-         /* Don't skip the prologue if this is assembly source */
-         s = find_pc_symtab (stop_pc);
-         if (s && s->language != language_asm)
-           SKIP_PROLOGUE (prologue_pc);
-       }
-
-      if (!(INNER_THAN (step_sp, read_sp ()))  /* don't mistake (sig)return
-                                                  as a call */
-         && (                  /* Might be a non-recursive call.  If the symbols are missing
-                enough that stop_func_start == prev_func_start even though
-                they are really two functions, we will treat some calls as
-                jumps.  */
-              stop_func_start != prev_func_start
-
-      /* Might be a recursive call if either we have a prologue
-                or the call instruction itself saves the PC on the stack.  */
-              || prologue_pc != stop_func_start
-              || read_sp () != step_sp)
-         && (                  /* PC is completely out of bounds of any known objfiles.  Treat
-                like a subroutine call. */
-              !stop_func_start
-
-      /* If we do a call, we will be at the start of a function...  */
-              || stop_pc == stop_func_start
-
-      /* ...except on the Alpha with -O (and also Irix 5 and
-                perhaps others), in which we might call the address
-                after the load of gp.  Since prologues don't contain
-                calls, we can't return to within one, and we don't
-                jump back into them, so this check is OK.  */
-
-              || stop_pc < prologue_pc
-
-      /* ...and if it is a leaf function, the prologue might
-                consist of gp loading only, so the call transfers to
-                the first instruction after the prologue.  */
-              || (stop_pc == prologue_pc
-
-      /* Distinguish this from the case where we jump back
-                    to the first instruction after the prologue,
-                    within a function.  */
-                  && stop_func_start != prev_func_start)
-
-      /* If we end up in certain places, it means we did a subroutine
-                call.  I'm not completely sure this is necessary now that we
-                have the above checks with stop_func_start (and now that
-                find_pc_partial_function is pickier).  */
-              || IN_SOLIB_CALL_TRAMPOLINE (stop_pc, stop_func_name)
-
-      /* If none of the above apply, it is a jump within a function,
-                or a return from a subroutine.  The other case is longjmp,
-                which can no longer happen here as long as the
-                handling_longjmp stuff is working.  */
-         ))
-#else
-      /* This test is a much more streamlined, (but hopefully correct)
-          replacement for the code above.  It's been tested on the Sparc,
-          Mips, PA, and Power architectures with good results.  */
-
       if (stop_pc == stop_func_start   /* Quick test */
          || (in_prologue (stop_pc, stop_func_start) &&
              !IN_SOLIB_RETURN_TRAMPOLINE (stop_pc, stop_func_name))
          || IN_SOLIB_CALL_TRAMPOLINE (stop_pc, stop_func_name)
          || stop_func_name == 0)
-#endif
-
        {
          /* It's a subroutine call.  */
 
@@ -2853,7 +2788,6 @@ stop_stepping:
          while (parent_pid != inferior_pid);
        }
 
-
       /* Assuming the inferior still exists, set these up for next
         time, just like we did above if we didn't break out of the
         loop.  */
@@ -2941,23 +2875,21 @@ stopped_for_shlib_catchpoint (bs, cp_p)
 void
 normal_stop ()
 {
-
-#ifdef HPUXHPPA
   /* As with the notification of thread events, we want to delay
      notifying the user that we've switched thread context until
      the inferior actually stops.
 
      (Note that there's no point in saying anything if the inferior
      has exited!) */
-  if ((switched_from_inferior_pid != inferior_pid) &&
-      target_has_execution)
+  if (may_switch_from_inferior_pid
+      && (switched_from_inferior_pid != inferior_pid)
+      && target_has_execution)
     {
       target_terminal_ours_for_output ();
       printf_filtered ("[Switched to %s]\n",
                       target_pid_or_tid_to_str (inferior_pid));
       switched_from_inferior_pid = inferior_pid;
     }
-#endif
 
   /* Make sure that the current_frame's pc is correct.  This
      is a correction for setting up the frame info before doing
@@ -3190,7 +3122,7 @@ handle_command (args, from_tty)
     {
       nomem (0);
     }
-  old_chain = make_cleanup ((make_cleanup_func) freeargv, (char *) argv);
+  old_chain = make_cleanup_freeargv (argv);
 
   /* Walk through the args, looking for signal oursigs, signal names, and
      actions.  Signal numbers and signal names may be interspersed with
@@ -3357,7 +3289,7 @@ xdb_handle_command (args, from_tty)
     {
       nomem (0);
     }
-  old_chain = make_cleanup ((make_cleanup_func) freeargv, (char *) argv);
+  old_chain = make_cleanup_freeargv (argv);
   if (argv[1] != (char *) NULL)
     {
       char *argBuf;
@@ -3455,15 +3387,82 @@ signals_info (signum_exp, from_tty)
   printf_filtered ("\nUse the \"handle\" command to change these tables.\n");
 }
 \f
+struct inferior_status
+{
+  enum target_signal stop_signal;
+  CORE_ADDR stop_pc;
+  bpstat stop_bpstat;
+  int stop_step;
+  int stop_stack_dummy;
+  int stopped_by_random_signal;
+  int trap_expected;
+  CORE_ADDR step_range_start;
+  CORE_ADDR step_range_end;
+  CORE_ADDR step_frame_address;
+  int step_over_calls;
+  CORE_ADDR step_resume_break_address;
+  int stop_after_trap;
+  int stop_soon_quietly;
+  CORE_ADDR selected_frame_address;
+  char *stop_registers;
+
+  /* These are here because if call_function_by_hand has written some
+     registers and then decides to call error(), we better not have changed
+     any registers.  */
+  char *registers;
+
+  int selected_level;
+  int breakpoint_proceeded;
+  int restore_stack_info;
+  int proceed_to_finish;
+};
+
+
+static struct inferior_status *xmalloc_inferior_status PARAMS ((void));
+static struct inferior_status *
+xmalloc_inferior_status ()
+{
+  struct inferior_status *inf_status;
+  inf_status = xmalloc (sizeof (struct inferior_status));
+  inf_status->stop_registers = xmalloc (REGISTER_BYTES);
+  inf_status->registers = xmalloc (REGISTER_BYTES);
+  return inf_status;
+}
+
+static void free_inferior_status PARAMS ((struct inferior_status *));
+static void
+free_inferior_status (inf_status)
+     struct inferior_status *inf_status;
+{
+  free (inf_status->registers);
+  free (inf_status->stop_registers);
+  free (inf_status);
+}
+
+void
+write_inferior_status_register (inf_status, regno, val)
+     struct inferior_status *inf_status;
+     int regno;
+     LONGEST val;
+{
+  int size = REGISTER_RAW_SIZE(regno);
+  void *buf = alloca (size);
+  store_signed_integer (buf, size, val);
+  memcpy (&inf_status->registers[REGISTER_BYTE (regno)], buf, size);
+}
+
+
+
 /* Save all of the information associated with the inferior<==>gdb
    connection.  INF_STATUS is a pointer to a "struct inferior_status"
    (defined in inferior.h).  */
 
-void
-save_inferior_status (inf_status, restore_stack_info)
-     struct inferior_status *inf_status;
+struct inferior_status *
+save_inferior_status (restore_stack_info)
      int restore_stack_info;
 {
+  struct inferior_status *inf_status = xmalloc_inferior_status ();
+
   inf_status->stop_signal = stop_signal;
   inf_status->stop_pc = stop_pc;
   inf_status->stop_step = stop_step;
@@ -3478,20 +3477,21 @@ save_inferior_status (inf_status, restore_stack_info)
   inf_status->stop_soon_quietly = stop_soon_quietly;
   /* Save original bpstat chain here; replace it with copy of chain.
      If caller's caller is walking the chain, they'll be happier if we
-     hand them back the original chain when restore_i_s is called.  */
+     hand them back the original chain when restore_inferior_status is
+     called.  */
   inf_status->stop_bpstat = stop_bpstat;
   stop_bpstat = bpstat_copy (stop_bpstat);
   inf_status->breakpoint_proceeded = breakpoint_proceeded;
   inf_status->restore_stack_info = restore_stack_info;
   inf_status->proceed_to_finish = proceed_to_finish;
-
+  
   memcpy (inf_status->stop_registers, stop_registers, REGISTER_BYTES);
 
   read_register_bytes (0, inf_status->registers, REGISTER_BYTES);
 
   record_selected_frame (&(inf_status->selected_frame_address),
                         &(inf_status->selected_level));
-  return;
+  return inf_status;
 }
 
 struct restore_selected_frame_args
@@ -3502,11 +3502,6 @@ struct restore_selected_frame_args
 
 static int restore_selected_frame PARAMS ((PTR));
 
-/* Restore the selected frame.  args is really a struct
-   restore_selected_frame_args * (declared as char * for catch_errors)
-   telling us what frame to restore.  Returns 1 for success, or 0 for
-   failure.  An error message will have been printed on error.  */
-
 static int
 restore_selected_frame (args)
      PTR args;
@@ -3560,6 +3555,7 @@ restore_inferior_status (inf_status)
   breakpoint_proceeded = inf_status->breakpoint_proceeded;
   proceed_to_finish = inf_status->proceed_to_finish;
 
+  /* FIXME: Is the restore of stop_registers always needed */
   memcpy (stop_registers, inf_status->stop_registers, REGISTER_BYTES);
 
   /* The inferior can be gone if the user types "print exit(0)"
@@ -3567,9 +3563,6 @@ restore_inferior_status (inf_status)
   if (target_has_execution)
     write_register_bytes (0, inf_status->registers, REGISTER_BYTES);
 
-  /* The inferior can be gone if the user types "print exit(0)"
-     (and perhaps other times).  */
-
   /* FIXME: If we are being called after stopping in a function which
      is called from gdb, we should not be trying to restore the
      selected frame; it just prints a spurious error message (The
@@ -3595,11 +3588,20 @@ restore_inferior_status (inf_status)
        select_frame (get_current_frame (), 0);
 
     }
-}
-\f
 
+  free_inferior_status (inf_status);
+}
 
 void
+discard_inferior_status (inf_status)
+     struct inferior_status *inf_status;
+{
+  /* See save_inferior_status for info on stop_bpstat. */
+  bpstat_clear (&inf_status->stop_bpstat);
+  free_inferior_status (inf_status);
+}
+
+static void
 set_follow_fork_mode_command (arg, from_tty, c)
      char *arg;
      int from_tty;
@@ -3615,7 +3617,15 @@ set_follow_fork_mode_command (arg, from_tty, c)
     free (follow_fork_mode_string);
   follow_fork_mode_string = savestring (arg, strlen (arg));
 }
+
+
 \f
+static void build_infrun PARAMS ((void));
+static void
+build_infrun ()
+{
+  stop_registers = xmalloc (REGISTER_BYTES);
+}
 
 
 void
@@ -3625,6 +3635,8 @@ _initialize_infrun ()
   register int numsigs;
   struct cmd_list_element *c;
 
+  build_infrun ();
+
   add_info ("signals", signals_info,
            "What debugger does when program gets various signals.\n\
 Specify a signal as argument to print info on that signal only.");
index af5cd3d6c0c47dfb343fd8b6016386477b287262..43c2248172353331999e7c39fc5cc2d429444cd1 100644 (file)
@@ -147,7 +147,7 @@ child_wait (pid, ourstatus)
 {
   int save_errno;
   int status;
-  char *  execd_pathname;
+  char *execd_pathname = NULL;
   int  exit_status;
   int  related_pid;
   int  syscall_id;
index 59539a0da9ff16d60505e5b059b10cbe27f7cafb..cddf758f73eaf898ca508c214037479176b69042 100644 (file)
@@ -26,6 +26,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "jv-lang.h"
 #include "gdb_string.h"
 #include "typeprint.h"
+#include "c-lang.h"
 
 static void
 java_type_print_derivation_info (stream, type)
@@ -147,10 +148,12 @@ java_type_print_base (type, stream, show, level)
          
          fprintf_filtered (stream, "{\n");
          if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
-           if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
-             fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
-           else
-             fprintfi_filtered (level + 4, stream, "<no data fields>\n");
+           {
+             if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
+               fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
+             else
+               fprintfi_filtered (level + 4, stream, "<no data fields>\n");
+           }
 
          /* If there is a base class for this type,
             do not print the field that it occupies.  */
@@ -171,12 +174,14 @@ java_type_print_base (type, stream, show, level)
              print_spaces_filtered (level + 4, stream);
 
              if (HAVE_CPLUS_STRUCT (type))
-               if (TYPE_FIELD_PROTECTED (type, i))
-                 fprintf_filtered (stream, "protected ");
-               else if (TYPE_FIELD_PRIVATE (type, i))
-                 fprintf_filtered (stream, "private ");
-               else
-                 fprintf_filtered (stream, "public ");
+               {
+                 if (TYPE_FIELD_PROTECTED (type, i))
+                   fprintf_filtered (stream, "protected ");
+                 else if (TYPE_FIELD_PRIVATE (type, i))
+                   fprintf_filtered (stream, "private ");
+                 else
+                   fprintf_filtered (stream, "public ");
+               }
 
              if (TYPE_FIELD_STATIC (type, i))
                fprintf_filtered (stream, "static ");
@@ -313,6 +318,9 @@ java_type_print_base (type, stream, show, level)
 
 /* LEVEL is the depth to indent lines by.  */
 
+extern void
+c_type_print_varspec_suffix PARAMS ((struct type *, GDB_FILE *, int, int, int));
+
 void
 java_print_type (type, varstring, stream, show, level)
      struct type *type;
index 6bfae7e3274e9fa8b4d98389047f27c9d5dda72b..797c16a9123ed6d00c2a852ea09a22d9394c066e 100644 (file)
@@ -20,6 +20,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "defs.h"
 #include "symtab.h"
 #include "gdbtypes.h"
+#include "gdbcore.h"
 #include "expression.h"
 #include "value.h"
 #include "demangle.h"
@@ -27,6 +28,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "language.h"
 #include "jv-lang.h"
 #include "c-lang.h"
+#include "annotate.h"
 
 int
 java_value_print (val, stream, format, pretty)
@@ -402,6 +404,8 @@ java_print_value_fields (type, valaddr, address, stream,
                                 stream, format, 0, recurse+1, pretty);
                    }
                }
+             else if (TYPE_FIELD_TYPE (type, i) == NULL)
+               fputs_filtered ("<unknown type>", stream);
              else
                {
                   val_print (TYPE_FIELD_TYPE (type, i), 
index e33686914919e3e3563653ff629270d0a29d8c9a..6b489a096a965925542b246c0f2e18402b29cfa8 100644 (file)
@@ -422,11 +422,11 @@ extern struct type * lang_bool_type PARAMS ((void));
 
 /* Misc:  The string representing a particular enum language.  */
 
-extern const struct language_defn *
-language_def PARAMS ((enum language));
+extern enum language language_enum PARAMS ((char *str));
 
-extern char *
-language_str PARAMS ((enum language));
+extern const struct language_defn *language_def PARAMS ((enum language));
+
+extern char *language_str PARAMS ((enum language));
 
 /* Add a language to the set known by GDB (at initialization time).  */
 
index 2be833e32e29020e78beaed7287968ab21e37e0a..ac18e1c6cc5bfa1c2073ae8cf99e6fc5a4aa6101 100644 (file)
@@ -221,7 +221,8 @@ m32r_supply_register (regname, regnamelen, val, vallen)
   if (regno == ACCL_REGNUM)
     { /* special handling for 64-bit acc reg */
       monitor_supply_register (ACCH_REGNUM, val);
-      if (val = (char *) strchr(val, ':'))  /* skip past ':' to get 2nd word */
+      val = strchr (val, ':'); /* skip past ':' to get 2nd word */
+      if (val != NULL)
        monitor_supply_register (ACCL_REGNUM, val + 1);
     }
   else
@@ -525,10 +526,12 @@ m32r_upload_command (args, from_tty)
     args = get_exec_file (1);
 
   if (args[0] != '/' && download_path == 0)
-    if (current_directory)
-      download_path = strsave (current_directory);
-    else
-      error ("Need to know default download path (use 'set download-path')");
+    {
+      if (current_directory)
+       download_path = strsave (current_directory);
+      else
+       error ("Need to know default download path (use 'set download-path')");
+    }
 
   start_time = time (NULL);
   monitor_printf ("uhip %s\r", server_addr);
@@ -553,7 +556,8 @@ m32r_upload_command (args, from_tty)
     printf_filtered (" -- Ethernet load complete.\n");
 
   end_time = time (NULL);
-  if (abfd = bfd_openr (args, 0))
+  abfd = bfd_openr (args, 0);
+  if (abfd != NULL)
     { /* Download is done -- print section statistics */
       if (bfd_check_format (abfd, bfd_object) == 0)
        {
index 60c828ffbe25a81f5a54a4d5768e459ab3bb54f9..7055fe013af2736bbf2d338cf78214f9a07baf2e 100644 (file)
@@ -189,6 +189,7 @@ static void stash_registers(void);
 static void restore_registers(void);
 static int  prepare_to_step(int);
 static int  finish_from_step(void);
+static unsigned long crc32 (unsigned char *, int, unsigned long);
 
 static void gdb_error(char *, char *);
 static int  gdb_putchar(int), gdb_puts(char *), gdb_write(char *, int);
@@ -486,9 +487,11 @@ handle_exception(int exceptionVector)
            if ((registers[PC] & 2) != 0)
              prepare_to_step(1);
          }
+
        return;
 
       case 'D':        /* Detach */
+#if 0
        /* I am interpreting this to mean, release the board from control 
           by the remote stub.  To do this, I am restoring the original
           (or at least previous) exception vectors.
@@ -497,6 +500,32 @@ handle_exception(int exceptionVector)
          exceptionHandler (i, save_vectors[i]);
        putpacket ("OK");
        return;         /* continue the inferior */
+#else
+       strcpy(remcomOutBuffer,"OK");
+       break;
+#endif
+    case 'q':
+      ptr = &remcomInBuffer[1];
+      if (*ptr++ == 'C' &&
+         *ptr++ == 'R' &&
+         *ptr++ == 'C' &&
+         *ptr++ == ':')
+       {
+         unsigned long start, len, our_crc;
+
+         if (hexToInt (&ptr, (int *) &start) &&
+             *ptr++ == ','                   &&
+             hexToInt (&ptr, (int *) &len))
+           {
+             remcomOutBuffer[0] = 'C';
+             our_crc = crc32 ((unsigned char *) start, len, 0xffffffff);
+             mem2hex ((char *) &our_crc, 
+                      &remcomOutBuffer[1], 
+                      sizeof (long), 
+                      0); 
+           } /* else do nothing */
+       } /* else do nothing */
+      break;
 
       case 'k': /* kill the program */
        continue;
@@ -507,6 +536,39 @@ handle_exception(int exceptionVector)
   }
 }
 
+/* qCRC support */
+
+/* Table used by the crc32 function to calcuate the checksum. */
+static unsigned long crc32_table[256] = {0, 0};
+
+static unsigned long
+crc32 (buf, len, crc)
+     unsigned char *buf;
+     int len;
+     unsigned long crc;
+{
+  if (! crc32_table[1])
+    {
+      /* Initialize the CRC table and the decoding table. */
+      int i, j;
+      unsigned long c;
+
+      for (i = 0; i < 256; i++)
+       {
+         for (c = i << 24, j = 8; j > 0; --j)
+           c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
+         crc32_table[i] = c;
+       }
+    }
+
+  while (len--)
+    {
+      crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
+      buf++;
+    }
+  return crc;
+}
+
 static int 
 hex(ch)
      unsigned char ch;
@@ -756,7 +818,7 @@ bin2mem (buf, mem, count, may_fault)
             case 0x4:  /* $ */
             case 0x5d: /* escape char */
               buf++;
-              *buf += 0x20;
+              *buf |= 0x20;
               break;
             default:
               /* nothing */
@@ -985,13 +1047,13 @@ branchDestination(instr, branchCode)
   case 2:                                      /* JL or JMP */ 
     return registers[instr[1] & 0x0F] & ~3;    /* jump thru a register */ 
   case 3:              /* BC, BNC, BL, BRA (short, 8-bit relative offset) */ 
-    return (((int) instr) & ~3) + ((unsigned char) instr[1] << 2);
+    return (((int) instr) & ~3) + ((char) instr[1] << 2);
   case 4:              /* BC, BNC, BL, BRA (long, 24-bit relative offset) */ 
     return ((int) instr + 
-           ((((unsigned char) instr[1] << 16) | (instr[2] << 8) | (instr[3])) << 2)); 
+           ((((char) instr[1] << 16) | (instr[2] << 8) | (instr[3])) << 2)); 
   case 5:              /* BNE, BEQ (16-bit relative offset) */ 
   case 6:              /* BNEZ, BLTZ, BLEZ, BGTZ, BGEZ ,BEQZ (ditto) */ 
-    return ((int) instr + ((((unsigned char) instr[2] << 8) | (instr[3])) << 2)); 
+    return ((int) instr + ((((char) instr[2] << 8) | (instr[3])) << 2)); 
   }
 
   /* An explanatory note: in the last three return expressions, I have
index acd34fa84e4b90fdee3c8d31481cf22a0aa492f5..b0195e8cdbc8c1faf79c24f58a8b52b68ae319ce 100644 (file)
@@ -265,25 +265,25 @@ static void decode_prologue (start_pc, scan_limit,
   if (current_pc >= scan_limit)
     {
       if (pl_endptr) 
+       {
 #if 1
-       if (after_stack_adjust != 0)
-         /* We did not find a "mv fp,sp", but we DID find
-            a stack_adjust.  Is it safe to use that as the
-            end of the prologue?  I just don't know. */
-         {
-           *pl_endptr = after_stack_adjust;
-           if (framelength)
-             *framelength = framesize;
-         }
-       else
+         if (after_stack_adjust != 0)
+           /* We did not find a "mv fp,sp", but we DID find
+              a stack_adjust.  Is it safe to use that as the
+              end of the prologue?  I just don't know. */
+           {
+             *pl_endptr = after_stack_adjust;
+             if (framelength)
+               *framelength = framesize;
+           }
+         else
 #endif
-      /* We reached the end of the loop without finding the end
-        of the prologue.  No way to win -- we should report failure.  
-        The way we do that is to return the original start_pc.
-        GDB will set a breakpoint at the start of the function (etc.) */
-
-       *pl_endptr = start_pc;
-       
+           /* We reached the end of the loop without finding the end
+              of the prologue.  No way to win -- we should report failure.  
+              The way we do that is to return the original start_pc.
+              GDB will set a breakpoint at the start of the function (etc.) */
+           *pl_endptr = start_pc;
+       }       
       return;
     }
   if (after_prologue == 0) 
@@ -703,22 +703,6 @@ m32r_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
   *(unsigned long *) (dummy) = (fun & 0x00ffffff) | 0xe8000000;
 }
 
-/* Function: get_saved_register
-   Just call the generic_get_saved_register function.  */
-
-void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
-     char *raw_buffer;
-     int *optimized;
-     CORE_ADDR *addrp;
-     struct frame_info *frame;
-     int regnum;
-     enum lval_type *lval;
-{
-  generic_get_saved_register (raw_buffer, optimized, addrp, 
-                             frame, regnum, lval);
-}
-
 
 /* Function: m32r_write_sp
    Because SP is really a read-only register that mirrors either SPU or SPI,
index d597efa0ec7eb056d30c2f15f654b0112037036a..c751604aefdc2e5438072803d1550ac230561d53 100644 (file)
@@ -23,6 +23,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "gdbcore.h"
 #include "value.h"
 #include "gdb_string.h"
+#include "inferior.h"
 
 \f
 /* Push an empty stack frame, to record the current PC, etc.  */
@@ -372,7 +373,6 @@ int regno;
 {
   register int regi;
   register greg_t *regp = (greg_t *) gregsetp;
-  extern char registers[];
 
   for (regi = 0 ; regi < R_PC ; regi++)
     {
@@ -427,7 +427,6 @@ int regno;
   int regi;
   char *to;
   char *from;
-  extern char registers[];
 
   for (regi = FP0_REGNUM ; regi < FPC_REGNUM ; regi++)
     {
index 19e9392ea666169b8eae2ac884fdc59743ccab38..27d72544606e5a4b5a314cc33105ec3eb5bb01a7 100644 (file)
@@ -59,7 +59,6 @@ extern int have_symbol_file_p();
 extern jmp_buf stack_jmp;
 
 extern int errno;
-extern char registers[REGISTER_BYTES];
 
 void
 fetch_inferior_registers (regno)
@@ -262,7 +261,6 @@ fill_gregset (gregsetp, regno)
 {
     int regi;
     register greg_t *regp = (greg_t *) gregsetp;
-    extern char registers[];
 
     for (regi = 0 ; regi <= R_R31 ; regi++)
        if ((regno == -1) || (regno == regi))
index 18c24459e8deadf68889e845a18075ad7763b2f3..1fef7bcfa67aea82ea73ecab5302c1f39c52a574 100644 (file)
@@ -19,11 +19,13 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
-#include <setjmp.h>
 #include "top.h"
 #include "target.h"
 #include "inferior.h"
 #include "call-cmds.h"
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
 
 #include "getopt.h"
 
index cf4ceb7e9a1b3edb40888dbc53d8934e3e355508..f32b159d36f372e6db7be49bbd5d81b91cea4cac 100644 (file)
@@ -20,9 +20,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 
 #include "defs.h"
-
-#if MAINTENANCE_CMDS   /* Entire rest of file goes away if not including maint cmds */
-
 #include <ctype.h>
 #include <signal.h>
 #include "command.h"
@@ -342,12 +339,9 @@ maintenance_translate_address (arg, from_tty)
   return;
 }
 
-#endif /* MAINTENANCE_CMDS */
-
 void
 _initialize_maint_cmds ()
 {
-#if MAINTENANCE_CMDS   /* Entire file goes away if not including maint cmds */
   add_prefix_cmd ("maintenance", class_maintenance, maintenance_command,
                  "Commands for use by GDB maintainers.\n\
 Includes commands to dump specific internal GDB structures in\n\
@@ -445,5 +439,4 @@ When non-zero, this timeout is used instead of waiting forever for a target to\n
 finish a low-level step or continue operation.  If the specified amount of time\n\
 passes without a response from the target, an error occurs.", &setlist),
                     &showlist);
-#endif /* MAINTENANCE_CMDS */
 }
index 1064490dcff652b8879ae22ed751a3fcdccf7bb9..6b6c86e7534733494b1d3214a797b81c2aebf545 100644 (file)
@@ -988,26 +988,28 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets)
 
              case stMember:
                if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
-                 /* If the type of the member is Nil (or Void),
-                    without qualifiers, assume the tag is an
-                    enumeration.
-                    Alpha cc -migrate enums are recognized by a zero
-                    index and a zero symbol value.
-                    DU 4.0 cc enums are recognized by a member type of
-                    btEnum without qualifiers and a zero symbol value.  */
-                 if (tsym.index == indexNil
-                     || (tsym.index == 0 && sh->value == 0))
-                   type_code = TYPE_CODE_ENUM;
-                 else
-                   {
-                     (*debug_swap->swap_tir_in) (bigend,
-                                                 &ax[tsym.index].a_ti,
-                                                 &tir);
-                     if ((tir.bt == btNil || tir.bt == btVoid
-                          || (tir.bt == btEnum && sh->value == 0))
-                         && tir.tq0 == tqNil)
-                       type_code = TYPE_CODE_ENUM;
-                   }
+                 {
+                   /* If the type of the member is Nil (or Void),
+                      without qualifiers, assume the tag is an
+                      enumeration.
+                      Alpha cc -migrate enums are recognized by a zero
+                      index and a zero symbol value.
+                      DU 4.0 cc enums are recognized by a member type of
+                      btEnum without qualifiers and a zero symbol value.  */
+                   if (tsym.index == indexNil
+                       || (tsym.index == 0 && sh->value == 0))
+                     type_code = TYPE_CODE_ENUM;
+                   else
+                     {
+                       (*debug_swap->swap_tir_in) (bigend,
+                                                   &ax[tsym.index].a_ti,
+                                                   &tir);
+                       if ((tir.bt == btNil || tir.bt == btVoid
+                            || (tir.bt == btEnum && sh->value == 0))
+                           && tir.tq0 == tqNil)
+                         type_code = TYPE_CODE_ENUM;
+                     }
+                 }
                nfields++;
                if (tsym.value > max_value)
                  max_value = tsym.value;
@@ -1090,10 +1092,12 @@ parse_symbol (sh, ax, ext_sh, bigend, section_offsets)
           here.) */
 
        if (type_code == TYPE_CODE_UNDEF)
-         if (nfields > 1 && max_value == 0)
-           type_code = TYPE_CODE_UNION;
-         else
-           type_code = TYPE_CODE_STRUCT;
+         {
+           if (nfields > 1 && max_value == 0)
+             type_code = TYPE_CODE_UNION;
+           else
+             type_code = TYPE_CODE_STRUCT;
+         }
 
        /* Create a new type or use the pending type.  */
        pend = is_pending_symbol (cur_fdr, ext_sh);
index e4aa2bb297bac0d02e877cdf718500330f3337e7..80bf1c42a18b77a94d2c042aa8cbc1140f953f08 100644 (file)
@@ -36,8 +36,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "opcode/mips.h"
 
-/* Some MIPS boards don't support floating point, so we permit the
-   user to turn it off.  */
+/* Some MIPS boards don't support floating point while others only
+   support single-precision floating-point operations.  See also
+   FP_REGISTER_DOUBLE. */
 
 enum mips_fpu_type
 {
@@ -53,11 +54,17 @@ static int mips_fpu_type_auto = 1;
 static enum mips_fpu_type mips_fpu_type = MIPS_DEFAULT_FPU_TYPE;
 #define MIPS_FPU_TYPE mips_fpu_type
 
-
-#define VM_MIN_ADDRESS (CORE_ADDR)0x400000
+#ifndef MIPS_SAVED_REGSIZE
+#define MIPS_SAVED_REGSIZE MIPS_REGSIZE
+#endif
 
 /* Do not use "TARGET_IS_MIPS64" to test the size of floating point registers */
+#ifndef FP_REGISTER_DOUBLE
 #define FP_REGISTER_DOUBLE (REGISTER_VIRTUAL_SIZE(FP0_REGNUM) == 8)
+#endif
+
+
+#define VM_MIN_ADDRESS (CORE_ADDR)0x400000
 
 #if 0
 static int mips_in_lenient_prologue PARAMS ((CORE_ADDR, CORE_ADDR));
@@ -223,7 +230,7 @@ mips_use_struct_convention (gcc_p, type)
      struct type *type;
 {
   if (MIPS_EABI)
-    return (TYPE_LENGTH (type) > 2 * MIPS_REGSIZE);
+    return (TYPE_LENGTH (type) > 2 * MIPS_SAVED_REGSIZE);
   else
     return 1; /* Structures are returned by ref in extra arg0 */
 }
@@ -933,7 +940,7 @@ mips_find_saved_regs (fci)
     if (gen_mask & 0x80000000)
       {
        fci->saved_regs[ireg] = reg_position;
-       reg_position -= MIPS_REGSIZE;
+       reg_position -= MIPS_SAVED_REGSIZE;
       }
 
   /* The MIPS16 entry instruction saves $s0 and $s1 in the reverse order
@@ -951,13 +958,13 @@ mips_find_saved_regs (fci)
          /* Check if the ra register was pushed on the stack.  */
          reg_position = fci->frame + PROC_REG_OFFSET (proc_desc);
          if (inst & 0x20)
-           reg_position -= MIPS_REGSIZE;
+           reg_position -= MIPS_SAVED_REGSIZE;
 
          /* Check if the s0 and s1 registers were pushed on the stack.  */
          for (reg = 16; reg < sreg_count+16; reg++)
            {
              fci->saved_regs[reg] = reg_position;
-             reg_position -= MIPS_REGSIZE;
+             reg_position -= MIPS_SAVED_REGSIZE;
            }
        }
     }
@@ -969,7 +976,7 @@ mips_find_saved_regs (fci)
   /* The freg_offset points to where the first *double* register
      is saved.  So skip to the high-order word. */
   if (! GDB_TARGET_IS_MIPS64)
-    reg_position += MIPS_REGSIZE;
+    reg_position += MIPS_SAVED_REGSIZE;
 
   /* Fill in the offsets for the float registers which float_mask says
      were saved.  */
@@ -977,7 +984,7 @@ mips_find_saved_regs (fci)
     if (float_mask & 0x80000000)
       {
        fci->saved_regs[FP0_REGNUM+ireg] = reg_position;
-       reg_position -= MIPS_REGSIZE;
+       reg_position -= MIPS_SAVED_REGSIZE;
       }
 
   fci->saved_regs[PC_REGNUM] = fci->saved_regs[RA_REGNUM];
@@ -999,7 +1006,7 @@ read_next_frame_reg(fi, regno)
          if (fi->saved_regs == NULL)
            mips_find_saved_regs (fi);
          if (fi->saved_regs[regno])
-           return read_memory_integer(fi->saved_regs[regno], MIPS_REGSIZE);
+           return read_memory_integer(fi->saved_regs[regno], MIPS_SAVED_REGSIZE);
        }
     }
   return read_register (regno);
@@ -1065,9 +1072,9 @@ mips_frame_saved_pc(frame)
              : (proc_desc ? PROC_PC_REG(proc_desc) : RA_REGNUM);
 
   if (proc_desc && PROC_DESC_IS_DUMMY(proc_desc))
-    saved_pc = read_memory_integer(frame->frame - MIPS_REGSIZE, MIPS_REGSIZE);
+    saved_pc = read_memory_integer (frame->frame - MIPS_SAVED_REGSIZE, MIPS_SAVED_REGSIZE);
   else
-    saved_pc = read_next_frame_reg(frame, pcreg);
+    saved_pc = read_next_frame_reg (frame, pcreg);
 
   return ADDR_BITS_REMOVE (saved_pc);
 }
@@ -1359,7 +1366,7 @@ mips16_heuristic_proc_desc(start_pc, limit_pc, next_frame, sp)
          {
            PROC_REG_MASK(&temp_proc_desc) |= 1 << reg;
            set_reg_offset (reg, sp + offset);
-           offset += MIPS_REGSIZE;
+           offset += MIPS_SAVED_REGSIZE;
          }
 
        /* Check if the ra register was pushed on the stack.  */
@@ -1368,7 +1375,7 @@ mips16_heuristic_proc_desc(start_pc, limit_pc, next_frame, sp)
          {
            PROC_REG_MASK(&temp_proc_desc) |= 1 << RA_REGNUM;
            set_reg_offset (RA_REGNUM, sp + offset);
-           offset -= MIPS_REGSIZE;
+           offset -= MIPS_SAVED_REGSIZE;
          }
 
        /* Check if the s0 and s1 registers were pushed on the stack.  */
@@ -1376,7 +1383,7 @@ mips16_heuristic_proc_desc(start_pc, limit_pc, next_frame, sp)
          {
            PROC_REG_MASK(&temp_proc_desc) |= 1 << reg;
            set_reg_offset (reg, sp + offset);
-           offset -= MIPS_REGSIZE;
+           offset -= MIPS_SAVED_REGSIZE;
          }
       }
 }
@@ -1754,7 +1761,7 @@ setup_arbitrary_frame (argc, argv)
 #define STACK_ARGSIZE 8
 #else
 #define MIPS_NABI32   0
-#define STACK_ARGSIZE MIPS_REGSIZE
+#define STACK_ARGSIZE MIPS_SAVED_REGSIZE
 #endif
 
 CORE_ADDR
@@ -1782,13 +1789,13 @@ mips_push_arguments(nargs, args, sp, struct_return, struct_addr)
      On at least one MIPS variant, stack frames need to be 128-bit
      aligned, so we round to this widest known alignment. */
   sp = ROUND_DOWN (sp, 16);
-  struct_addr = ROUND_DOWN (struct_addr, MIPS_REGSIZE);
+  struct_addr = ROUND_DOWN (struct_addr, MIPS_SAVED_REGSIZE);
       
   /* Now make space on the stack for the args. We allocate more
      than necessary for EABI, because the first few arguments are
      passed in registers, but that's OK. */
   for (argnum = 0; argnum < nargs; argnum++)
-    len += ROUND_UP (TYPE_LENGTH(VALUE_TYPE(args[argnum])), MIPS_REGSIZE);
+    len += ROUND_UP (TYPE_LENGTH(VALUE_TYPE(args[argnum])), MIPS_SAVED_REGSIZE);
   sp -= ROUND_UP (len, 16);
 
   /* Initialize the integer and float register pointers.  */
@@ -1813,12 +1820,12 @@ mips_push_arguments(nargs, args, sp, struct_return, struct_addr)
 
       /* The EABI passes structures that do not fit in a register by
         reference. In all other cases, pass the structure by value.  */
-      if (MIPS_EABI && len > MIPS_REGSIZE &&
+      if (MIPS_EABI && len > MIPS_SAVED_REGSIZE &&
          (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
        {
-         store_address (valbuf, MIPS_REGSIZE, VALUE_ADDRESS (arg));
+         store_address (valbuf, MIPS_SAVED_REGSIZE, VALUE_ADDRESS (arg));
          typecode = TYPE_CODE_PTR;
-         len = MIPS_REGSIZE;
+         len = MIPS_SAVED_REGSIZE;
          val = valbuf;
        }
       else
@@ -1887,11 +1894,11 @@ mips_push_arguments(nargs, args, sp, struct_return, struct_addr)
             where gcc sometimes puts them on the stack.  For maximum
             compatibility, we will put them in both places.  */
 
-         int odd_sized_struct = ((len > MIPS_REGSIZE) && 
-                                 (len % MIPS_REGSIZE != 0));
+         int odd_sized_struct = ((len > MIPS_SAVED_REGSIZE) && 
+                                 (len % MIPS_SAVED_REGSIZE != 0));
          while (len > 0)
            {
-             int partial_len = len < MIPS_REGSIZE ? len : MIPS_REGSIZE;
+             int partial_len = len < MIPS_SAVED_REGSIZE ? len : MIPS_SAVED_REGSIZE;
 
              if (argreg > MIPS_LAST_ARG_REGNUM || odd_sized_struct)
                {
@@ -1901,16 +1908,18 @@ mips_push_arguments(nargs, args, sp, struct_return, struct_addr)
 
                  int longword_offset = 0;
                  if (TARGET_BYTE_ORDER == BIG_ENDIAN)
-                   if (STACK_ARGSIZE == 8 &&
-                       (typecode == TYPE_CODE_INT ||
-                        typecode == TYPE_CODE_PTR ||
-                        typecode == TYPE_CODE_FLT) && len <= 4)
-                     longword_offset = STACK_ARGSIZE - len;
-                   else if ((typecode == TYPE_CODE_STRUCT ||
-                             typecode == TYPE_CODE_UNION) &&
-                            TYPE_LENGTH (arg_type) < STACK_ARGSIZE)
-                     longword_offset = STACK_ARGSIZE - len;
-
+                   {
+                     if (STACK_ARGSIZE == 8 &&
+                         (typecode == TYPE_CODE_INT ||
+                          typecode == TYPE_CODE_PTR ||
+                          typecode == TYPE_CODE_FLT) && len <= 4)
+                       longword_offset = STACK_ARGSIZE - len;
+                     else if ((typecode == TYPE_CODE_STRUCT ||
+                               typecode == TYPE_CODE_UNION) &&
+                              TYPE_LENGTH (arg_type) < STACK_ARGSIZE)
+                       longword_offset = STACK_ARGSIZE - len;
+                   }
+                 
                  write_memory (sp + stack_offset + longword_offset, 
                                val, partial_len);
                }
@@ -1934,12 +1943,12 @@ mips_push_arguments(nargs, args, sp, struct_return, struct_addr)
                     binaries. */
 
                  if (!MIPS_EABI
-                     && (MIPS_REGSIZE < 8)
+                     && MIPS_SAVED_REGSIZE < 8
                      && TARGET_BYTE_ORDER == BIG_ENDIAN
-                     && (partial_len < MIPS_REGSIZE)
+                     && partial_len < MIPS_SAVED_REGSIZE
                      && (typecode == TYPE_CODE_STRUCT ||
                          typecode == TYPE_CODE_UNION))
-                   regval <<= ((MIPS_REGSIZE - partial_len) * 
+                   regval <<= ((MIPS_SAVED_REGSIZE - partial_len) * 
                                TARGET_CHAR_BIT);
 
                  write_register (argreg, regval);
@@ -1981,21 +1990,33 @@ mips_push_arguments(nargs, args, sp, struct_return, struct_addr)
 }
 
 static void
-mips_push_register(CORE_ADDR *sp, int regno)
+mips_push_register (CORE_ADDR *sp, int regno)
 {
   char buffer[MAX_REGISTER_RAW_SIZE];
-  int regsize = REGISTER_RAW_SIZE (regno);
-
+  int regsize;
+  int offset;
+  if (MIPS_SAVED_REGSIZE < REGISTER_RAW_SIZE (regno))
+    {
+      regsize = MIPS_SAVED_REGSIZE;
+      offset = (TARGET_BYTE_ORDER == BIG_ENDIAN
+               ? REGISTER_RAW_SIZE (regno) - MIPS_SAVED_REGSIZE
+               : 0);
+    }
+  else
+    {
+      regsize = REGISTER_RAW_SIZE (regno);
+      offset = 0;
+    }
   *sp -= regsize;
   read_register_gen (regno, buffer);
-  write_memory (*sp, buffer, regsize);
+  write_memory (*sp, buffer + offset, regsize);
 }
 
 /* MASK(i,j) == (1<<i) + (1<<(i+1)) + ... + (1<<j)). Assume i<=j<(MIPS_NUMREGS-1). */
 #define MASK(i,j) (((1 << ((j)+1))-1) ^ ((1 << (i))-1))
 
 void
-mips_push_dummy_frame()
+mips_push_dummy_frame ()
 {
   int ireg;
   struct linked_proc_info *link = (struct linked_proc_info*)
@@ -2046,7 +2067,7 @@ mips_push_dummy_frame()
   /* Save general CPU registers */
   PROC_REG_MASK(proc_desc) = GEN_REG_SAVE_MASK;
   /* PROC_REG_OFFSET is the offset of the first saved register from FP.  */
-  PROC_REG_OFFSET(proc_desc) = sp - old_sp - MIPS_REGSIZE;
+  PROC_REG_OFFSET(proc_desc) = sp - old_sp - MIPS_SAVED_REGSIZE;
   for (ireg = 32; --ireg >= 0; )
     if (PROC_REG_MASK(proc_desc) & (1 << ireg))
       mips_push_register (&sp, ireg);
@@ -2091,7 +2112,7 @@ mips_pop_frame()
          && frame->saved_regs[regnum])
        write_register (regnum,
                        read_memory_integer (frame->saved_regs[regnum],
-                                            MIPS_REGSIZE)); 
+                                            MIPS_SAVED_REGSIZE)); 
     }
   write_register (SP_REGNUM, new_sp);
   flush_cached_frames ();
@@ -2119,12 +2140,15 @@ mips_pop_frame()
       free (pi_ptr);
 
       write_register (HI_REGNUM,
-               read_memory_integer (new_sp - 2*MIPS_REGSIZE, MIPS_REGSIZE));
+                     read_memory_integer (new_sp - 2*MIPS_SAVED_REGSIZE,
+                                          MIPS_SAVED_REGSIZE));
       write_register (LO_REGNUM,
-               read_memory_integer (new_sp - 3*MIPS_REGSIZE, MIPS_REGSIZE));
+                     read_memory_integer (new_sp - 3*MIPS_SAVED_REGSIZE,
+                                          MIPS_SAVED_REGSIZE));
       if (MIPS_FPU_TYPE != MIPS_FPU_NONE)
        write_register (FCRCS_REGNUM,
-               read_memory_integer (new_sp - 4*MIPS_REGSIZE, MIPS_REGSIZE));
+                       read_memory_integer (new_sp - 4*MIPS_SAVED_REGSIZE,
+                                            MIPS_SAVED_REGSIZE));
     }
 }
 
@@ -2614,14 +2638,143 @@ mips_in_lenient_prologue (startaddr, pc)
 }
 #endif
 
-/* Given a return value in `regbuf' with a type `valtype', 
-   extract and copy its value into `valbuf'.  */
+/* Determine how a return value is stored within the MIPS register
+   file, given the return type `valtype'. */
+
+struct return_value_word
+{
+  int len;
+  int reg;
+  int reg_offset;
+  int buf_offset;
+};
+
+static void return_value_location PARAMS ((struct type *, struct return_value_word *, struct return_value_word *));
+
+static void
+return_value_location (valtype, hi, lo)
+     struct type *valtype;
+     struct return_value_word *hi;
+     struct return_value_word *lo;
+{
+  int len = TYPE_LENGTH (valtype);
+  
+  if (TYPE_CODE (valtype) == TYPE_CODE_FLT
+      && ((MIPS_FPU_TYPE == MIPS_FPU_DOUBLE && (len == 4 || len == 8))
+         || (MIPS_FPU_TYPE == MIPS_FPU_SINGLE && len == 4)))
+    {
+      if (!FP_REGISTER_DOUBLE && len == 8)
+       {
+         /* We need to break a 64bit float in two 32 bit halves and
+             spread them across a floating-point register pair. */
+         lo->buf_offset = TARGET_BYTE_ORDER == BIG_ENDIAN ? 4 : 0;
+         hi->buf_offset = TARGET_BYTE_ORDER == BIG_ENDIAN ? 0 : 4;
+         lo->reg_offset = ((TARGET_BYTE_ORDER == BIG_ENDIAN
+                            && REGISTER_RAW_SIZE (FP0_REGNUM) == 8)
+                           ? 4 : 0);
+         hi->reg_offset = lo->reg_offset;
+         lo->reg = FP0_REGNUM + 0;
+         hi->reg = FP0_REGNUM + 1;
+         lo->len = 4;
+         hi->len = 4;
+       }
+      else
+       {
+         /* The floating point value fits in a single floating-point
+             register. */
+         lo->reg_offset = ((TARGET_BYTE_ORDER == BIG_ENDIAN
+                            && REGISTER_RAW_SIZE (FP0_REGNUM) == 8
+                            && len == 4)
+                           ? 4 : 0);
+         lo->reg = FP0_REGNUM;
+         lo->len = len;
+         lo->buf_offset = 0;
+         hi->len = 0;
+         hi->reg_offset = 0;
+         hi->buf_offset = 0;
+         hi->reg = 0;
+       }
+    }
+  else
+    {
+      /* Locate a result possibly spread across two registers. */
+      int regnum = 2;
+      lo->reg = regnum + 0;
+      hi->reg = regnum + 1;
+      if (TARGET_BYTE_ORDER == BIG_ENDIAN
+         && len < MIPS_SAVED_REGSIZE)
+       {
+         /* "un-left-justify" the value in the low register */
+         lo->reg_offset = MIPS_SAVED_REGSIZE - len;
+         lo->len = len;
+         hi->reg_offset = 0;
+         hi->len = 0;
+       }
+      else if (TARGET_BYTE_ORDER == BIG_ENDIAN
+              && len > MIPS_SAVED_REGSIZE      /* odd-size structs */
+              && len < MIPS_SAVED_REGSIZE * 2
+              && (TYPE_CODE (valtype) == TYPE_CODE_STRUCT ||
+                  TYPE_CODE (valtype) == TYPE_CODE_UNION))
+       {
+         /* "un-left-justify" the value spread across two registers. */
+         lo->reg_offset = 2 * MIPS_SAVED_REGSIZE - len;
+         lo->len = MIPS_SAVED_REGSIZE - lo->reg_offset;
+         hi->reg_offset = 0;
+         hi->len = len - lo->len;
+       }
+      else
+       {
+         /* Only perform a partial copy of the second register. */
+         lo->reg_offset = 0;
+         hi->reg_offset = 0;
+         if (len > MIPS_SAVED_REGSIZE)
+           {
+             lo->len = MIPS_SAVED_REGSIZE;
+             hi->len = len - MIPS_SAVED_REGSIZE;
+           }
+         else
+           {
+             lo->len = len;
+             hi->len = 0;
+           }
+       }
+      if (TARGET_BYTE_ORDER == BIG_ENDIAN
+         && REGISTER_RAW_SIZE (regnum) == 8
+         && MIPS_SAVED_REGSIZE == 4)
+       {
+         /* Account for the fact that only the least-signficant part
+             of the register is being used */
+         lo->reg_offset += 4;
+         hi->reg_offset += 4;
+       }
+      lo->buf_offset = 0;
+      hi->buf_offset = lo->len;
+    }
+}
+
+/* Given a return value in `regbuf' with a type `valtype', extract and
+   copy its value into `valbuf'. */
+
 void
 mips_extract_return_value (valtype, regbuf, valbuf)
     struct type *valtype;
     char regbuf[REGISTER_BYTES];
     char *valbuf;
 {
+  struct return_value_word lo;
+  struct return_value_word hi;
+  return_value_location (valtype, &lo, &hi);
+
+  memcpy (valbuf + lo.buf_offset,
+         regbuf + REGISTER_BYTE (lo.reg) + lo.reg_offset,
+         lo.len);
+
+  if (hi.len > 0)
+    memcpy (valbuf + hi.buf_offset,
+           regbuf + REGISTER_BYTE (hi.reg) + hi.reg_offset,
+           hi.len);
+
+#if 0
   int regnum;
   int offset = 0;
   int len = TYPE_LENGTH (valtype);
@@ -2645,15 +2798,38 @@ mips_extract_return_value (valtype, regbuf, valbuf)
     }
   memcpy (valbuf, regbuf + REGISTER_BYTE (regnum) + offset, len);
   REGISTER_CONVERT_TO_TYPE (regnum, valtype, valbuf);
+#endif
 }
 
-/* Given a return value in `regbuf' with a type `valtype', 
-   write it's value into the appropriate register.  */
+/* Given a return value in `valbuf' with a type `valtype', write it's
+   value into the appropriate register. */
+
 void
 mips_store_return_value (valtype, valbuf)
     struct type *valtype;
     char *valbuf;
 {
+  char raw_buffer[MAX_REGISTER_RAW_SIZE];
+  struct return_value_word lo;
+  struct return_value_word hi;
+  return_value_location (valtype, &lo, &hi);
+
+  memset (raw_buffer, 0, sizeof (raw_buffer));
+  memcpy (raw_buffer + lo.reg_offset, valbuf + lo.buf_offset, lo.len);
+  write_register_bytes (REGISTER_BYTE (lo.reg),
+                       raw_buffer,
+                       REGISTER_RAW_SIZE (lo.reg));
+  
+  if (hi.len > 0)
+    {
+      memset (raw_buffer, 0, sizeof (raw_buffer));
+      memcpy (raw_buffer + hi.reg_offset, valbuf + hi.buf_offset, hi.len);
+      write_register_bytes (REGISTER_BYTE (hi.reg),
+                           raw_buffer,
+                           REGISTER_RAW_SIZE (hi.reg));
+    }
+
+#if 0
   int regnum;
   int offset = 0;
   int len = TYPE_LENGTH (valtype);
@@ -2681,6 +2857,7 @@ mips_store_return_value (valtype, valbuf)
   write_register_bytes(REGISTER_BYTE (regnum), raw_buffer, 
                       len > REGISTER_RAW_SIZE (regnum) ? 
                       len : REGISTER_RAW_SIZE (regnum));
+#endif
 }
 
 /* Exported procedure: Is PC in the signal trampoline code */
index cb7ead093137aa6ded68f6d7d8b0f7db23b42ad5..bdc3e94447d3af1f8fe09e08f6ad7f242b9bf3a9 100644 (file)
@@ -870,19 +870,6 @@ mn10200_frame_saved_pc (fi)
   return (read_memory_integer (fi->frame, REGISTER_SIZE) & 0xffffff);
 }
 
-void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
-     char *raw_buffer;
-     int *optimized;
-     CORE_ADDR *addrp;
-     struct frame_info *frame;
-     int regnum;
-     enum lval_type *lval;
-{
-  generic_get_saved_register (raw_buffer, optimized, addrp, 
-                             frame, regnum, lval);
-}
-
 /* Function: init_extra_frame_info
    Setup the frame's frame pointer, pc, and frame addresses for saved
    registers.  Most of the work is done in mn10200_analyze_prologue().
index 6c43176193b80dee2174484f1677037608659953..795e68586b69c07ef5d5397eacb19c5885769d75 100644 (file)
@@ -693,19 +693,6 @@ mn10300_frame_saved_pc (fi)
   return (read_memory_integer (fi->frame + adjust, REGISTER_SIZE));
 }
 
-void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
-     char *raw_buffer;
-     int *optimized;
-     CORE_ADDR *addrp;
-     struct frame_info *frame;
-     int regnum;
-     enum lval_type *lval;
-{
-  generic_get_saved_register (raw_buffer, optimized, addrp, 
-                             frame, regnum, lval);
-}
-
 /* Function: mn10300_init_extra_frame_info
    Setup the frame's frame pointer, pc, and frame addresses for saved
    registers.  Most of the work is done in mn10300_analyze_prologue().
index dc47d8c02f3fb11ccdb8e6b776e162235099b4d4..44dc82509126d04681a9f4407fe0120ca31b0d1d 100644 (file)
@@ -492,7 +492,7 @@ readchar (timeout)
     return c;
 
   if (c == SERIAL_TIMEOUT)
-#if 0 /* MAINTENANCE_CMDS */
+#if 0
     /* I fail to see how detaching here can be useful */
     if (in_monitor_wait)       /* Watchdog went off */
       {
@@ -1055,7 +1055,7 @@ monitor_wait (pid, status)
   old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
   RDEBUG(("MON wait\n"))
 
-#if 0 /* MAINTENANCE_CMDS */
+#if 0
     /* This is somthing other than a maintenance command */
   in_monitor_wait = 1;
   timeout = watchdog > 0 ? watchdog : -1;
@@ -1133,10 +1133,11 @@ monitor_fetch_register (regno)
   int i;
 
   name = current_monitor->regnames[regno];
-  RDEBUG(("MON fetchreg %d '%s'\n",regno,name)) 
+  RDEBUG(("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)")) 
 
   if (!name || (*name == '\0'))
-    { RDEBUG(("No register known for %d\n",regno))
+    {
+      RDEBUG (("No register known for %d\n", regno))
       supply_register (regno, zerobuf);
       return;
     }
@@ -1155,8 +1156,8 @@ monitor_fetch_register (regno)
       monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
       /* Handle case of first 32 registers listed in pairs.  */
       if (current_monitor->flags & MO_32_REGS_PAIRED
-         && regno & 1 == 1 && regno < 32)
-       { RDEBUG(("EXP getreg.resp_delim\n")) ;
+         && (regno & 1) != 0 && regno < 32)
+       { RDEBUG(("EXP getreg.resp_delim\n")) ;
          monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
        }
     }
@@ -1538,14 +1539,19 @@ static char * longlong_hexchars(unsigned long long value,
       }
       longlongendswap(disbuf) ; /* FIXME: ONly on big endian hosts */
       while (scan < limit)
-       { c = *scan++ ; /* a byte of our long long value */
+       {
+         c = *scan++; /* a byte of our long long value */
          if (leadzero)
-           if (c == 0) continue ;
-           else leadzero = 0 ; /* henceforth we print even zeroes */
-         nib = c >> 4 ;        /* high nibble bits */
-         *outbuff++ = hexlate[nib] ;
-         nib = c & 0x0f ;      /* low nibble bits */
-         *outbuff++ = hexlate[nib] ;
+           {
+             if (c == 0)
+               continue;
+             else
+               leadzero = 0; /* henceforth we print even zeroes */
+           }
+         nib = c >> 4;        /* high nibble bits */
+         *outbuff++ = hexlate[nib];
+         nib = c & 0x0f;      /* low nibble bits */
+         *outbuff++ = hexlate[nib];
        }
       return outbuff ;
     }
@@ -1808,7 +1814,7 @@ monitor_read_memory (memaddr, myaddr, len)
   /* send the memory examine command */
 
   if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
-    monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len - 1);
+    monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
   else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
     monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
   else
index 971a7d4de499a90e16bae0a96989154e808e2926..91f4aa472f95b70f8e83e14bca4fb59eafcba957 100644 (file)
@@ -35,6 +35,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "obstack.h"
 #include "gdb_string.h"
 
+#include "breakpoint.h"
+
 /* Prototypes for local functions */
 
 #if defined(USE_MMALLOC) && defined(HAVE_MMAP)
index 2a5df06160f5b9b9200e3055517d48d91d4566d6..31bd124d0a67d536a6bcb434b5fbf5908c8b3c7c 100644 (file)
@@ -176,14 +176,11 @@ typedef struct {
 } ExportEntry;
 
 
-
 /* The "objstats" structure provides a place for gdb to record some
    interesting information about its internal state at runtime, on a
    per objfile basis, such as information about the number of symbols
    read, size of string table (if any), etc. */
 
-#if MAINTENANCE_CMDS
-
 struct objstats {
   int n_minsyms;       /* Number of minimal symbols read */
   int n_psyms;         /* Number of partial symbols read */
@@ -198,13 +195,6 @@ struct objstats {
 extern void print_objfile_statistics PARAMS ((void));
 extern void print_symbol_bcache_statistics PARAMS ((void));
 
-#else
-
-#define OBJSTAT(objfile, expr) /* Nothing */
-#define OBJSTATS               /* Nothing */
-
-#endif /* MAINTENANCE_CMDS */
-
 /* Master structure for keeping track of each file from which
    gdb reads symbols.  There are several ways these get allocated: 1.
    The main symbol file, symfile_objfile, set by the symbol-file command,
index af68fbfbcd243b16e659195d565f590f64147a03..76ed1b6f32459417f16bcc7e1d956e43ab1aa2c2 100644 (file)
@@ -41,6 +41,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "parser-defs.h"
 #include "gdbcmd.h"
 #include "symfile.h"   /* for overlay functions */
+#include <ctype.h>
 \f
 /* Global variables declared in parser-defs.h (and commented there).  */
 struct expression *expout;
@@ -56,9 +57,7 @@ char *namecopy;
 int paren_depth;
 int comma_terminates;
 \f
-#ifdef MAINTENANCE_CMDS
 static int expressiondebug = 0;
-#endif
 
 extern int hp_som_som_object_present;
 
@@ -1196,19 +1195,15 @@ parse_exp_1 (stringptr, block, comma)
   /* Convert expression from postfix form as generated by yacc
      parser, to a prefix form. */
 
-#ifdef MAINTENANCE_CMDS
   if (expressiondebug)
     dump_prefix_expression (expout, gdb_stdout,
                            "before conversion to prefix form");
-#endif /* MAINTENANCE_CMDS */
 
   prefixify_expression (expout);
 
-#ifdef MAINTENANCE_CMDS
   if (expressiondebug)
     dump_postfix_expression (expout, gdb_stdout,
                             "after conversion to prefix form");
-#endif /* MAINTENANCE_CMDS */
 
   *stringptr = lexptr;
   return expout;
@@ -1339,7 +1334,6 @@ _initialize_parse ()
               "<variable (not text or data), no debug info>",
               NULL);
 
-#ifdef MAINTENANCE_CMDS
   add_show_from_set (
      add_set_cmd ("expressiondebug", class_maintenance, var_zinteger,
                  (char *)&expressiondebug,
@@ -1347,5 +1341,4 @@ _initialize_parse ()
 When non-zero, the internal representation of expressions will be printed.",
                  &setlist),
      &showlist);
-#endif
 }
index 0f0b8abd202d46e5c54cb2c3932217c9eaf68412..306fa7449eb73ab03462fdcf848a29436730ae5f 100644 (file)
@@ -860,7 +860,6 @@ print_command_1 (exp, inspect, voidprint)
 
   if (exp && *exp)
     {
-      extern int objectprint;
       struct type *type;
       expr = parse_expression (exp);
       old_chain = make_cleanup ((make_cleanup_func) free_current_contents, 
@@ -1897,10 +1896,9 @@ print_frame_args (func, fi, num, stream)
 
       if (val)
        {
-#ifdef GDB_TARGET_IS_D10V
-         if (SYMBOL_CLASS(sym) == LOC_REGPARM && TYPE_CODE(VALUE_TYPE(val)) == TYPE_CODE_PTR)
+         if (GDB_TARGET_IS_D10V
+             && SYMBOL_CLASS(sym) == LOC_REGPARM && TYPE_CODE(VALUE_TYPE(val)) == TYPE_CODE_PTR)
            TYPE_LENGTH(VALUE_TYPE(val)) = 2;
-#endif
          val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
                     VALUE_ADDRESS (val),
                    stream, 0, 0, 2, Val_no_prettyprint);
index ff20240e0a5b92a98efebdc3732f8b9d070eabbd..6822f422a63e1f119ea441260968aae884daee22 100644 (file)
@@ -582,6 +582,10 @@ static int open_proc_file PARAMS ((int, struct procinfo *, int, int));
 
 static void close_proc_file PARAMS ((struct procinfo *));
 
+static void close_proc_file_cleanup PARAMS ((void*));
+
+static struct cleanup *make_cleanup_close_proc_file PARAMS ((struct procinfo *));
+
 static void unconditionally_kill_inferior PARAMS ((struct procinfo *));
 
 static NORETURN void proc_init_failed PARAMS ((struct procinfo *, char *, int)) ATTR_NORETURN;
@@ -4024,6 +4028,20 @@ close_proc_file (pip)
     }
 }
 
+static void
+close_proc_file_cleanup (pip)
+     void *pip;
+{
+  close_proc_file ((struct procinfo *) pip);
+}
+
+static struct cleanup *
+make_cleanup_close_proc_file (pip)
+     struct procinfo *pip;
+{
+  return make_cleanup (close_proc_file_cleanup, pip);
+}
+
 /*
 
 LOCAL FUNCTION
@@ -4760,7 +4778,7 @@ info_proc (args, from_tty)
        {
          nomem (0);
        }
-      make_cleanup (freeargv, (char *) argv);
+      make_cleanup_freeargv (argv);
 
       while (*argv != NULL)
        {
@@ -4822,7 +4840,7 @@ info_proc (args, from_tty)
                  /* NOTREACHED */
                }
              pid = pip->pid;
-             make_cleanup (close_proc_file, pip);
+             make_cleanup_close_proc_file (pip);
            }
          else if (**argv != '\000')
            {
@@ -4874,7 +4892,7 @@ No process.  Start debugging a program or specify an explicit process ID.");
          if (!open_proc_file ((*lwps << 16) | pid, pip, O_RDONLY, 0))
            continue;
 
-         make_cleanup (close_proc_file, pip);
+         make_cleanup_close_proc_file (pip);
 
          if (!procfs_read_status (pip))
            {
index 564b79917284368af6feda120d2fdabbccf25271..ef83ccc955e77028ec1873f7d91d0da431008b03 100644 (file)
@@ -51,7 +51,6 @@ fill_gregset (gregsetp, regno)
      int regno;
 {
   int regi;
-  extern char registers[];
 
   for (regi = 0 ; regi < NUM_REGS ; regi++)
     {
@@ -89,7 +88,6 @@ fill_fpregset (fpregsetp, regno)
   int regi;
   char *to;
   char *from;
-  extern char registers[];
 
   /* FIXME: see m68k-tdep.c for an example, for the m68k. */
 }
index dd6d9a92400e531626bcbb76a1473ca1f7d1a76a..5c95bd638a4597683690ad81a95d4a4c0c3eaa0e 100644 (file)
@@ -200,7 +200,6 @@ core_file_command (filename, from_tty)
      int from_tty;
 {
   int val;
-  extern char registers[];
 
   /* Discard all vestiges of any previous core file
      and mark data and stack spaces as empty.  */
index 92e69b349816cb9954c1861df332e37e40fbf2b4..9343d53bad153ec9f1b01fe0a20b3b11f14695b2 100644 (file)
@@ -927,6 +927,7 @@ e7000_fetch_registers ()
       {
       case bfd_mach_sh3:
       case bfd_mach_sh3e:
+      case bfd_mach_sh4:
        wanted = want_sh3;
       }
 #else
@@ -2079,6 +2080,7 @@ e7000_wait (pid, status)
       {
       case bfd_mach_sh3:
       case bfd_mach_sh3e:
+      case bfd_mach_sh4:
        wanted_nopc = want_sh3_nopc;
       }
 #else
index c92f8b706c94d7654d5145eef283a4df33f242a7..5e5a1c53cee540b7c1806bca7e405ae88723b78d 100644 (file)
@@ -672,7 +672,6 @@ mips_readchar (timeout)
   static int state = 0;
   int mips_monitor_prompt_len = strlen (mips_monitor_prompt);
 
-#ifdef MAINTENANCE_CMDS
   {
     int i;
 
@@ -680,18 +679,17 @@ mips_readchar (timeout)
     if (i == -1 && watchdog > 0)
      i = watchdog;
   }
-#endif
 
   if (state == mips_monitor_prompt_len)
     timeout = 1;
   ch = SERIAL_READCHAR (mips_desc, timeout);
-#ifdef MAINTENANCE_CMDS
+
   if (ch == SERIAL_TIMEOUT && timeout == -1) /* Watchdog went off */
     {
       target_mourn_inferior ();
       error ("Watchdog has expired.  Target detached.\n");
     }
-#endif
+
   if (ch == SERIAL_EOF)
     mips_error ("End of file from remote");
   if (ch == SERIAL_ERROR)
@@ -1561,7 +1559,7 @@ device is attached to the target board (e.g., /dev/ttya).\n"
      optional local TFTP name.  */
   if ((argv = buildargv (name)) == NULL)
     nomem(0);
-  make_cleanup ((make_cleanup_func) freeargv, argv);
+  make_cleanup_freeargv (argv);
 
   serial_port_name = strsave (argv[0]);
   if (argv[1])                         /* remote TFTP name specified? */
index 3ab5f44bbef67707ce0a538fb582c0d83c650eef..74a8680608151c5ef9364b8f7480fc2abecab6a1 100644 (file)
@@ -471,8 +471,8 @@ sds_wait (pid, status)
          retlen = sds_send (buf, 1);
          if (remote_debug)
            {
-             fprintf_unfiltered (gdb_stderr, "Signals: %04x %02x %02x\n",
-                                 ((int) buf[0]) << 8 + buf[1],
+             fprintf_unfiltered (gdb_stderr, "Signals: %02x%02x %02x %02x\n",
+                                 buf[0], buf[1],
                                  buf[2], buf[3]);
            }
          message_pending = 0;
@@ -925,11 +925,7 @@ getmessage (buf, forever)
 
   if (forever)
     {
-#ifdef MAINTENANCE_CMDS
       timeout = watchdog > 0 ? watchdog : -1;
-#else
-      timeout = -1;
-#endif
     }
 
   else
@@ -953,13 +949,11 @@ getmessage (buf, forever)
 
          if (c == SERIAL_TIMEOUT)
            {
-#ifdef MAINTENANCE_CMDS
              if (forever)      /* Watchdog went off.  Kill the target. */
                {
                  target_mourn_inferior ();
                  error ("Watchdog has expired.  Target detached.\n");
                }
-#endif
              if (remote_debug)
                puts_filtered ("Timed out.\n");
              goto retry;
index e10fcedd6b760ebfbb53768baac7624f5d5d43a7..cf41b40ae7accfe5bd9d51cb04ad350730d9ab23 100644 (file)
@@ -39,6 +39,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 /* Prototypes */
 
+extern int (*ui_loop_hook) PARAMS ((int signo));
+
 static void dump_mem PARAMS ((char *buf, int len));
 
 static void init_callbacks PARAMS ((void));
@@ -478,7 +480,7 @@ gdbsim_create_inferior (exec_file, args, env)
       strcat (arg_buf, " ");
       strcat (arg_buf, args);
       argv = buildargv (arg_buf);
-      make_cleanup ((make_cleanup_func) freeargv, argv);
+      make_cleanup_freeargv (argv);
     }
   else
     argv = NULL;
@@ -559,7 +561,7 @@ gdbsim_open (args, from_tty)
   argv = buildargv (arg_buf);
   if (argv == NULL)
     error ("Insufficient memory available to allocate simulator arg list.");
-  make_cleanup ((make_cleanup_func) freeargv, argv);
+  make_cleanup_freeargv (argv);
 
   init_callbacks ();
   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
@@ -668,6 +670,9 @@ static int
 gdb_os_poll_quit (p)
      host_callback *p;
 {
+  if (ui_loop_hook != NULL)
+    ui_loop_hook (0);
+
   notice_quit ();
   if (quit_flag) /* gdb's idea of quit */
     {
index f5b6f7ca14bf707cc90cd9e27ad4ca1b0dd2a472..9f84f5df82b6bddec2d9825a0a33097aab7adfa1 100644 (file)
@@ -203,6 +203,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "dcache.h"
 
+#include <ctype.h>
 #ifdef USG
 #include <sys/types.h>
 #endif
@@ -268,6 +269,8 @@ static void remote_detach PARAMS ((char *args, int from_tty));
 
 static void remote_interrupt PARAMS ((int signo));
 
+static void remote_interrupt_twice PARAMS ((int signo));
+
 static void interrupt_query PARAMS ((void));
 
 static void set_thread PARAMS ((int, int));
@@ -430,11 +433,6 @@ extern int remote_timeout;
 
 static int remote_break;
 
-/* Has the user attempted to interrupt the target? If so, then offer
-   the user the opportunity to bail out completely if he interrupts
-   again. */
-static int interrupted_already = 0;
-
 /* Descriptor for I/O to remote machine.  Initialize it to NULL so that
    remote_open knows that we don't have a file open when the program
    starts.  */
@@ -1613,37 +1611,49 @@ remote_resume (pid, step, siggnal)
 
 static void (*ofunc) PARAMS ((int));
 
+/* The command line interface's stop routine. This function is installed
+   as a signal handler for SIGINT. The first time a user requests a
+   stop, we call remote_stop to send a break or ^C. If there is no
+   response from the target (it didn't stop when the user requested it),
+   we ask the user if he'd like to detach from the target. */
 static void
 remote_interrupt (signo)
      int signo;
 {
-  remote_stop ();
+  /* If this doesn't work, try more severe steps. */
+  signal (signo, remote_interrupt_twice);
+
+  if (remote_debug)
+    printf_unfiltered ("remote_interrupt called\n");
+
+  target_stop ();
+}
+
+/* The user typed ^C twice.  */
+
+static void
+remote_interrupt_twice (signo)
+     int signo;
+{
+  signal (signo, ofunc);
+  interrupt_query ();
   signal (signo, remote_interrupt);
 }
-  
+
+/* This is the generic stop called via the target vector. When a target
+   interrupt is requested, either by the command line or the GUI, we
+   will eventually end up here. */
 static void
 remote_stop ()
 {
-  if (!interrupted_already)
-    {
-      /* Send a break or a ^C, depending on user preference.  */
-      interrupted_already = 1;
-
-      if (remote_debug)
-        printf_unfiltered ("remote_stop called\n");
+  /* Send a break or a ^C, depending on user preference.  */
+  if (remote_debug)
+    printf_unfiltered ("remote_stop called\n");
 
-      if (remote_break)
-        SERIAL_SEND_BREAK (remote_desc);
-      else
-        SERIAL_WRITE (remote_desc, "\003", 1);
-    }
+  if (remote_break)
+    SERIAL_SEND_BREAK (remote_desc);
   else
-    {
-      signal (SIGINT, ofunc);
-      interrupt_query ();
-      signal (SIGINT, remote_interrupt);
-      interrupted_already = 0;
-    }
+    SERIAL_WRITE (remote_desc, "\003", 1);
 }
 
 /* Ask the user what to do when an interrupt is received.  */
@@ -1705,7 +1715,6 @@ remote_wait (pid, status)
     {
       unsigned char *p;
 
-      interrupted_already = 0;
       ofunc = signal (SIGINT, remote_interrupt);
       getpkt ((char *) buf, 1);
       signal (SIGINT, ofunc);
@@ -2093,7 +2102,10 @@ remote_address_masked (addr)
    This is accomplished by sending a no-op memory write of zero length
    to the target at the specified address. It does not suffice to send
    the whole packet, since many stubs strip the eighth bit and subsequently
-   compute a wrong checksum, which causes real havoc with remote_write_bytes. */
+   compute a wrong checksum, which causes real havoc with remote_write_bytes.
+
+   NOTE: This can still lose if the serial line is not eight-bit clean. In
+   cases like this, the user should clear "remotebinarydownload". */
 static void
 check_binary_download (addr)
      CORE_ADDR addr;
@@ -2153,7 +2165,7 @@ remote_write_bytes (memaddr, myaddr, len)
   if (remote_register_buf_size != 0)
     max_buf_size = min (max_buf_size, remote_register_buf_size);
 
-  /* Subtract header overhead from max payload size - $M<memaddr>,<len>:#nn */
+  /* Subtract header overhead from max payload size -  $M<memaddr>,<len>:#nn */
   max_buf_size -= 2 + hexnumlen (memaddr + len - 1) + 1 + hexnumlen (len) + 4;
 
   origlen = len;
@@ -2182,7 +2194,7 @@ remote_write_bytes (memaddr, myaddr, len)
       p += hexnumstr (p, (ULONGEST) memaddr);
       *p++ = ',';
 
-      plen = p;                /* remember where len field goes */
+      plen = p;                        /* remember where len field goes */
       p += hexnumstr (p, (ULONGEST) todo);
       *p++ = ':';
       *p = '\0';
@@ -2192,10 +2204,10 @@ remote_write_bytes (memaddr, myaddr, len)
         binary character).  */
       if (remote_binary_download)
        {
-          int escaped = 0;
-          for (i = 0; 
+         int escaped = 0;
+          for (i = 0;
               (i < todo) && (i + escaped) < (max_buf_size - 2);
-              i++) 
+              i++)
             {
               switch (myaddr[i] & 0xff)
                 {
@@ -2213,18 +2225,18 @@ remote_write_bytes (memaddr, myaddr, len)
                 }
             }
 
-         if (i < todo)
-           {
-             /* Escape chars have filled up the buffer prematurely, 
-                and we have actually sent fewer bytes than planned.
-                Fix-up the length field of the packet.  */
+          if (i < todo)
+            {
+              /* Escape chars have filled up the buffer prematurely, 
+                 and we have actually sent fewer bytes than planned.
+                 Fix-up the length field of the packet.  */
 
              /* FIXME: will fail if new len is a shorter string than 
                 old len.  */
 
-             plen += hexnumstr (plen, (ULONGEST) i);
-             *plen++ = ':';
-           }
+              plen += hexnumstr (plen, (ULONGEST) i);
+              *plen++ = ':';
+            }
        }
       else
        {
@@ -2731,11 +2743,7 @@ getpkt (buf, forever)
 
   if (forever)
     {
-#ifdef MAINTENANCE_CMDS
       timeout = watchdog > 0 ? watchdog : -1;
-#else
-      timeout = -1;
-#endif
     }
 
   else
@@ -2759,13 +2767,11 @@ getpkt (buf, forever)
 
          if (c == SERIAL_TIMEOUT)
            {
-#ifdef MAINTENANCE_CMDS
              if (forever)      /* Watchdog went off.  Kill the target. */
                {
                  target_mourn_inferior ();
                  error ("Watchdog has expired.  Target detached.\n");
                }
-#endif
              if (remote_debug)
                puts_filtered ("Timed out.\n");
              goto retry;
@@ -2810,7 +2816,7 @@ remote_kill ()
 
   /* Use catch_errors so the user can quit from gdb even when we aren't on
      speaking terms with the remote system.  */
-  catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
+  catch_errors ((catch_errors_ftype*) putpkt, "k", "", RETURN_MASK_ERROR);
 
   /* Don't wait for it to die.  I'm not really sure it matters whether
      we do or not.  For the existing stubs, kill is a noop.  */
index 310a40cbb9b4c74a89586a797b471eaf955f3850..b41f50823f05b01461c98e3178259d0b74669368 100644 (file)
@@ -16,7 +16,7 @@
 #
 #   You should have received a copy of the GNU General Public License
 #   along with this program; if not, write to the Free Software
-#   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 #
 # This awk script hacks the output of mig-generated reply server code
 # so that it allows replies with just the error-code in them (as this is
index 831d299652a57809110429ba7c6dd8e3deb49b63..4fe6bad79d995a984cb81087f01a2a2e5dfb0f75 100644 (file)
@@ -96,7 +96,7 @@ static char *rom68k_inits[] = {".\r\r", NULL}; /* Exits pm/pr & download cmds */
 static struct monitor_ops rom68k_cmds ;
 
 static void 
-init_rom68k_cmds(void)
+init_rom68k_cmds (void)
 {
   rom68k_cmds.flags =   0;
   rom68k_cmds.init =   rom68k_inits; /* monitor init string */
@@ -108,41 +108,41 @@ init_rom68k_cmds(void)
   rom68k_cmds.clr_all_break =   "cb *\r";
   rom68k_cmds.fill =   "fm %x %x %x\r";
   rom68k_cmds.setmem.cmdb =     "pm %x %x\r";
-  rom68k_cmds.setmem.cmdw =     "pm;w %x %x\r";
-  rom68k_cmds.setmem.cmdl =     "pm;l %x %x\r";
+  rom68k_cmds.setmem.cmdw =     "pm.w %x %x\r";
+  rom68k_cmds.setmem.cmdl =     "pm.l %x %x\r";
   rom68k_cmds.setmem.cmdll =     NULL;
   rom68k_cmds.setmem.resp_delim =     NULL;
   rom68k_cmds.setmem.term =     NULL;
   rom68k_cmds.setmem.term_cmd =     NULL;
   rom68k_cmds.getmem.cmdb =     "dm %x %x\r";
-  rom68k_cmds.getmem.cmdw =     "dm;w %x %x\r";
-  rom68k_cmds.getmem.cmdl =     "dm;l %x %x\r";
+  rom68k_cmds.getmem.cmdw =     "dm.w %x %x\r";
+  rom68k_cmds.getmem.cmdl =     "dm.l %x %x\r";
   rom68k_cmds.getmem.cmdll =     NULL;
   rom68k_cmds.getmem.resp_delim =     "  ";
   rom68k_cmds.getmem.term =     NULL;
-    rom68k_cmds.getmem.term_cmd =     NULL;
+  rom68k_cmds.getmem.term_cmd =     NULL;
   rom68k_cmds.setreg.cmd =     "pr %s %x\r";
   rom68k_cmds.setreg.resp_delim =     NULL;
   rom68k_cmds.setreg.term =     NULL;
-  rom68k_cmds.setreg.term_cmd =     NULL ;
-  rom68k_cmds.getreg.cmd =     "pr %s\r" ;
-  rom68k_cmds.getreg.resp_delim =     ":  " ;
-  rom68k_cmds.getreg.term =     "= " ;
-  rom68k_cmds.getreg.term_cmd =     ";\r" ;
-  rom68k_cmds.dump_registers =   "dr\r" ;
+  rom68k_cmds.setreg.term_cmd =     NULL;
+  rom68k_cmds.getreg.cmd =     "pr %s\r";
+  rom68k_cmds.getreg.resp_delim =     ":  ";
+  rom68k_cmds.getreg.term =     "= ";
+  rom68k_cmds.getreg.term_cmd =     ".\r";
+  rom68k_cmds.dump_registers =   "dr\r";
   rom68k_cmds.register_pattern =
-    "\\(\\w+\\)=\\([0-9a-fA-F]+\\( +[0-9a-fA-F]+\\b\\)*\\)" ;
+    "\\(\\w+\\)=\\([0-9a-fA-F]+\\( +[0-9a-fA-F]+\\b\\)*\\)";
   rom68k_cmds.supply_register =   rom68k_supply_register;
   rom68k_cmds.load_routine =   NULL;
   rom68k_cmds.load =   "dc\r";
-  rom68k_cmds.loadresp =   "Waiting for S-records from host;.. ";
+  rom68k_cmds.loadresp =   "Waiting for S-records from host... ";
   rom68k_cmds.prompt =   "ROM68K :-> ";
   rom68k_cmds.line_term =   "\r";
-  rom68k_cmds.cmd_end =   ";\r";
+  rom68k_cmds.cmd_end =   ".\r";
   rom68k_cmds.target =   &rom68k_ops;
   rom68k_cmds.stopbits =   SERIAL_1_STOPBITS;
   rom68k_cmds.regnames =   rom68k_regnames;
-  rom68k_cmds.magic =   MONITOR_OPS_MAGIC ;
+  rom68k_cmds.magic =   MONITOR_OPS_MAGIC;
 } /* init_rom68k_cmds */
 
 static void
index c74a36f1f974ad2026041bc708bf06dc24f046f8..78f5a6beb47d90f79e7de81d2e5a781df54ffc82 100644 (file)
@@ -92,7 +92,6 @@ fetch_inferior_registers (regno)
   int regno;
 {
   int ii;
-  extern char registers[];
 
   if (regno < 0) {                     /* for all registers */
 
@@ -152,7 +151,6 @@ void
 store_inferior_registers (regno)
      int regno;
 {
-  extern char registers[];
 
   errno = 0;
 
index 57f1df100de9020c1b6c2fc7b110b45b12de4868..b45f62eec1f149e227e9fb248b85b4e6b329f689 100644 (file)
@@ -80,7 +80,7 @@ rs6000_init_extra_frame_info (fromleaf, fi)
   fi->extra_info->initial_sp = 0;
   if (fi->next != (CORE_ADDR) 0
       && fi->pc < TEXT_SEGMENT_BASE)
-    /* We're in get_prev_frame_info */
+    /* We're in get_prev_frame */
     /* and this is a special signal frame.  */
     /* (fi->pc will be some low address in the kernel, */
     /*  to which the signal handler returns).  */
@@ -684,15 +684,18 @@ pop_frame ()
 
   if (stop_stack_dummy)
     {
-#ifdef USE_GENERIC_DUMMY_FRAMES
-      generic_pop_dummy_frame ();
-      flush_cached_frames ();
-      return;
-#else
-      if (dummy_frame_count) 
-       pop_dummy_frame ();
-      return;
-#endif
+      if (USE_GENERIC_DUMMY_FRAMES)
+       {
+         generic_pop_dummy_frame ();
+         flush_cached_frames ();
+         return;
+       }
+      else
+       {
+         if (dummy_frame_count) 
+           pop_dummy_frame ();
+         return;
+       }
     }
 
   /* Make sure that all registers are valid.  */
@@ -818,10 +821,11 @@ push_arguments (nargs, args, sp, struct_return, struct_addr)
 
   CORE_ADDR saved_sp;
 
-#ifndef USE_GENERIC_DUMMY_FRAMES
-  if ( dummy_frame_count <= 0)
-    printf_unfiltered ("FATAL ERROR -push_arguments()! frame not found!!\n");
-#endif /* GENERIC_DUMMY_FRAMES */
+  if (!USE_GENERIC_DUMMY_FRAMES)
+    {
+      if (dummy_frame_count <= 0)
+       printf_unfiltered ("FATAL ERROR -push_arguments()! frame not found!!\n");
+    }
 
   /* The first eight words of ther arguments are passed in registers. Copy
      them appropriately.
@@ -899,15 +903,19 @@ both:
 
 ran_out_of_registers_for_arguments:
 
-#ifdef USE_GENERIC_DUMMY_FRAMES
-  saved_sp = read_sp ();
-#else
-  /* location for 8 parameters are always reserved. */
-  sp -= 4 * 8;
+  if (USE_GENERIC_DUMMY_FRAMES)
+    {
+      saved_sp = read_sp ();
+    }
+  else
+    {
+      /* location for 8 parameters are always reserved. */
+      sp -= 4 * 8;
+
+      /* another six words for back chain, TOC register, link register, etc. */
+      sp -= 24;
+    }
 
-  /* another six words for back chain, TOC register, link register, etc. */
-  sp -= 24;
-#endif /* GENERIC_DUMMY_FRAMES */
   /* if there are more arguments, allocate space for them in 
      the stack, then push them starting from the ninth one. */
 
@@ -977,14 +985,15 @@ ran_out_of_registers_for_arguments:
     /* Secure stack areas first, before doing anything else. */
     write_register (SP_REGNUM, sp);
 
-#ifndef USE_GENERIC_DUMMY_FRAMES
-/* we want to copy 24 bytes of target's frame to dummy's frame,
-   then set back chain to point to new frame. */
-
-  saved_sp = dummy_frame_addr [dummy_frame_count - 1];
-  read_memory (saved_sp, tmp_buffer, 24);
-  write_memory (sp, tmp_buffer, 24);
-#endif /* GENERIC_DUMMY_FRAMES */
+  if (!USE_GENERIC_DUMMY_FRAMES)
+    {
+      /* we want to copy 24 bytes of target's frame to dummy's frame,
+        then set back chain to point to new frame. */
+      
+      saved_sp = dummy_frame_addr [dummy_frame_count - 1];
+      read_memory (saved_sp, tmp_buffer, 24);
+      write_memory (sp, tmp_buffer, 24);
+    }
 
   /* set back chain properly */
   store_address (tmp_buffer, 4, saved_sp);
@@ -1146,10 +1155,11 @@ frame_saved_pc (fi)
   if (fi->signal_handler_caller)
     return read_memory_integer (fi->frame + SIG_FRAME_PC_OFFSET, 4);
 
-#ifdef USE_GENERIC_DUMMY_FRAMES
-  if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
-    return generic_read_register_dummy(fi->pc, fi->frame, PC_REGNUM);
-#endif /* GENERIC_DUMMY_FRAMES */
+  if (USE_GENERIC_DUMMY_FRAMES)
+    {
+      if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+       return generic_read_register_dummy(fi->pc, fi->frame, PC_REGNUM);
+    }
 
   func_start = get_pc_function_start (fi->pc);
 
@@ -1328,10 +1338,11 @@ rs6000_frame_chain (thisframe)
 {
   CORE_ADDR fp;
 
-#ifdef USE_GENERIC_DUMMY_FRAMES
-  if (PC_IN_CALL_DUMMY (thisframe->pc, thisframe->frame, thisframe->frame))
-    return thisframe->frame;   /* dummy frame same as caller's frame */
-#endif /* GENERIC_DUMMY_FRAMES */
+  if (USE_GENERIC_DUMMY_FRAMES)
+    {
+      if (PC_IN_CALL_DUMMY (thisframe->pc, thisframe->frame, thisframe->frame))
+       return thisframe->frame;        /* dummy frame same as caller's frame */
+    }
 
   if (inside_entry_file (thisframe->pc) || 
       thisframe->pc == entry_point_address ())
@@ -1348,17 +1359,17 @@ rs6000_frame_chain (thisframe)
   else
     fp = read_memory_integer ((thisframe)->frame, 4);
 
-#ifdef USE_GENERIC_DUMMY_FRAMES
-  {
-    CORE_ADDR fpp, lr;
+  if (USE_GENERIC_DUMMY_FRAMES)
+    {
+      CORE_ADDR fpp, lr;
+
+      lr = read_register (LR_REGNUM);
+      if (lr == entry_point_address ())
+       if (fp != 0 && (fpp = read_memory_integer (fp, 4)) != 0)
+         if (PC_IN_CALL_DUMMY (lr, fpp, fpp))
+           return fpp;
+    }
 
-    lr = read_register (LR_REGNUM);
-    if (lr == entry_point_address ())
-      if (fp != 0 && (fpp = read_memory_integer (fp, 4)) != 0)
-       if (PC_IN_CALL_DUMMY (lr, fpp, fpp))
-         return fpp;
-  }
-#endif /* GENERIC_DUMMY_FRAMES */
   return fp;
 }
 \f
@@ -1391,25 +1402,6 @@ gdb_print_insn_powerpc (memaddr, info)
 }
 #endif
 
-/* Function: get_saved_register
-   Just call the generic_get_saved_register function.  */
-
-#ifdef USE_GENERIC_DUMMY_FRAMES
-void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
-     char *raw_buffer;
-     int *optimized;
-     CORE_ADDR *addrp;
-     struct frame_info *frame;
-     int regnum;
-     enum lval_type *lval;
-{
-  generic_get_saved_register (raw_buffer, optimized, addrp, 
-                             frame, regnum, lval);
-}
-#endif
-
-
 \f
 /* Handling the various PowerPC/RS6000 variants.  */
 
index 8be5db9b691d8846ce628c9b47ce01a6ad11602d..fae08594c0660250055dfc9122214af5fcc4013f 100644 (file)
@@ -300,7 +300,7 @@ dosasync_write (fd, buf, len)
   ((short *)dummy)[3] = 0;
   for (i = 0; i < len ; i++) 
     {
-      dummy[8 + i ^ 1] = buf[i];
+      dummy[(8 + i) ^ 1] = buf[i];
     }
 
   /* Wait for the card to get ready */
index c55133760faddb8850d0bac6feb45ebdd6966906..e6443a08f5c82cc795f5c892ab3df3a279c5a053 100644 (file)
@@ -25,6 +25,9 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include <arpa/inet.h>
 #include <netdb.h>
 #include <sys/socket.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
 
 #ifndef __CYGWIN32__
 #include <netinet/tcp.h>
@@ -33,6 +36,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "signals.h"
 #include "gdb_string.h"
 
+extern int (*ui_loop_hook) PARAMS ((int));
+
 struct tcp_ttystate
 {
   int bogus;
@@ -234,11 +239,54 @@ tcp_readchar (scb, timeout)
      int timeout;
 {
   int status;
+  int delta;
 
   if (scb->bufcnt-- > 0)
     return *scb->bufp++;
 
-  status = wait_for(scb, timeout);
+  /* We have to be able to keep the GUI alive here, so we break the original
+     timeout into steps of 1 second, running the "keep the GUI alive" hook 
+     each time through the loop.
+
+     Also, timeout = 0 means to poll, so we just set the delta to 0, so we
+     will only go through the loop once. */
+   
+  delta = (timeout == 0 ? 0 : 1);
+  while (1)
+    {
+
+      /* N.B. The UI may destroy our world (for instance by calling
+        remote_stop,) in which case we want to get out of here as
+        quickly as possible.  It is not safe to touch scb, since
+        someone else might have freed it.  The ui_loop_hook signals that 
+        we should exit by returning 1. */
+
+      if (ui_loop_hook)
+       {
+         if (ui_loop_hook (0))
+           return SERIAL_TIMEOUT;
+       }
+
+      status = wait_for (scb, delta);
+      timeout -= delta;
+
+      /* If we got a character or an error back from wait_for, then we can 
+         break from the loop before the timeout is completed. */
+      
+      if (status != SERIAL_TIMEOUT)
+       {
+         break;
+       }
+
+      /* If we have exhausted the original timeout, then generate
+        a SERIAL_TIMEOUT, and pass it out of the loop. */
+      
+      else if (timeout == 0)
+       {
+         status == SERIAL_TIMEOUT;
+         break;
+       }
+    }
 
   if (status < 0)
     return status;
index f279c94cfdb9308133e4a195cbd1b0b4e834b48e..dc5236fbe662330acde9f9b80359176fc06bdf11 100644 (file)
@@ -85,9 +85,7 @@ static int hardwire_setstopbits PARAMS ((serial_t, int));
 
 void _initialize_ser_hardwire PARAMS ((void));
 
-#ifdef __CYGWIN32__
-extern void (*ui_loop_hook) PARAMS ((int));
-#endif
+extern int (*ui_loop_hook) PARAMS ((int));
 
 /* Open up a real live device for serial I/O */
 
@@ -434,10 +432,6 @@ wait_for(scb, timeout)
      serial_t scb;
      int timeout;
 {
-#ifndef __CYGWIN32__
-  scb->timeout_remaining = 0;
-#endif
-
 #ifdef HAVE_SGTTY
   {
     struct timeval tv;
@@ -550,32 +544,40 @@ hardwire_readchar (scb, timeout)
      serial_t scb;
      int timeout;
 {
-  int status;
-#ifdef __CYGWIN32__
-  int t;
-#endif
+  int status, delta;
+  int detach = 0;
 
   if (scb->bufcnt-- > 0)
     return *scb->bufp++;
 
-#ifdef __CYGWIN32__
   if (timeout > 0)
     timeout++;
-#endif
 
+  /* We have to be able to keep the GUI alive here, so we break the original
+     timeout into steps of 1 second, running the "keep the GUI alive" hook 
+     each time through the loop.
+     Also, timeout = 0 means to poll, so we just set the delta to 0, so we
+     will only go through the loop once. */
+   
+  delta = (timeout == 0 ? 0 : 1);
   while (1)
     {
-#ifdef __CYGWIN32__
-      t = timeout == 0 ? 0 : 1;
-      scb->timeout_remaining = timeout < 0 ? timeout : timeout - t;
-      status = wait_for (scb, t);
 
-      /* -2 means disable timer */
+      /* N.B. The UI may destroy our world (for instance by calling
+         remote_stop,) in which case we want to get out of here as
+         quickly as possible.  It is not safe to touch scb, since
+         someone else might have freed it.  The ui_loop_hook signals that 
+         we should exit by returning 1. */
+
       if (ui_loop_hook)
-        ui_loop_hook (-2);
-#else
-      status = wait_for (scb, timeout);
-#endif
+        detach = ui_loop_hook (0);
+
+      if (detach)
+       return SERIAL_TIMEOUT;
+
+      scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
+      status = wait_for (scb, delta);
+
       if (status < 0)
        return status;
 
@@ -592,10 +594,8 @@ hardwire_readchar (scb, timeout)
                  timeout = scb->timeout_remaining;
                  continue;
                }
-#ifdef __CYGWIN32__
           else if (scb->timeout_remaining < 0)
             continue;
-#endif
              else
                return SERIAL_TIMEOUT;
            }
index dd94506ab44075eba12653d0a94adcc713ffdfef..2b25f0d505e7c68b9758553694e944c46dac1093 100644 (file)
@@ -96,6 +96,7 @@ struct {
   { sh_reg_names, bfd_mach_sh },
   { sh3_reg_names, bfd_mach_sh3 },
   { sh3e_reg_names, bfd_mach_sh3e },
+  { sh3e_reg_names, bfd_mach_sh4 },
   { NULL, 0 }
 };
 
@@ -578,22 +579,6 @@ sh_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
 }
 #endif
 
-/* Function: get_saved_register
-   Just call the generic_get_saved_register function.  */
-
-void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
-     char *raw_buffer;
-     int *optimized;
-     CORE_ADDR *addrp;
-     struct frame_info *frame;
-     int regnum;
-     enum lval_type *lval;
-{
-  generic_get_saved_register (raw_buffer, optimized, addrp, 
-                             frame, regnum, lval);
-}
-
 
 /* Modify the actual processor type. */
 
@@ -631,6 +616,10 @@ sh_show_regs (args, from_tty)
   else
     cpu = 0;
 
+  /* FIXME: sh4 has more registers */
+  if (cpu == bfd_mach_sh4)
+    cpu = bfd_mach_sh3;
+
   printf_filtered ("PC=%08x SR=%08x PR=%08x MACH=%08x MACHL=%08x\n",
                   read_register (PC_REGNUM),
                   read_register (SR_REGNUM),
index ab4aa692427e540164894810f15d23cce33f3205..a4675a607d290f1d460489a05fc4bced8fd7d812 100644 (file)
@@ -65,10 +65,12 @@ sh3_supply_register (regname, regnamelen, val, vallen)
        case 'G':
        case 'V':
          if (regname[1] == 'B' && regname[2] == 'R')
-           if (regname[0] == 'G')
-             regno = VBR_REGNUM;
-           else
-             regno = GBR_REGNUM;
+           {
+             if (regname[0] == 'G')
+               regno = VBR_REGNUM;
+             else
+               regno = GBR_REGNUM;
+           }
          break;
        case 'S':
          if (regname[1] == 'S' && regname[2] == 'R')
@@ -84,10 +86,12 @@ sh3_supply_register (regname, regnamelen, val, vallen)
        {
        case 'M':
          if (regname[1] == 'A' && regname[2] == 'C')
-           if (regname[3] == 'H')
-             regno = MACH_REGNUM;
-           else if (regname[3] == 'L')
-             regno = MACL_REGNUM;
+           {
+             if (regname[3] == 'H')
+               regno = MACH_REGNUM;
+             else if (regname[3] == 'L')
+               regno = MACL_REGNUM;
+           }
          break;
        case 'R':
          if (regname[1] == '0' && regname[2] == '-' && regname[3] == '7')
index 3fe6268bf31638bd4d1bf48009f473839a57f2ef..e76f831d7e7130d615f8a8ac7ccded494ad26973 100644 (file)
@@ -106,7 +106,7 @@ static td_thragent_t *main_ta;
 static int sol_thread_active = 0;
 
 static struct cleanup * save_inferior_pid PARAMS ((void));
-static void restore_inferior_pid PARAMS ((int pid));
+static void restore_inferior_pid PARAMS ((void *pid));
 static char *td_err_string PARAMS ((td_err_e errcode));
 static char *td_state_string PARAMS ((td_thr_state_e statecode));
 static int  thread_to_lwp PARAMS ((int thread_id, int default_lwp));
@@ -428,14 +428,14 @@ NOTES
 static struct cleanup *
 save_inferior_pid ()
 {
-  return make_cleanup (restore_inferior_pid, inferior_pid);
+  return make_cleanup (restore_inferior_pid, (void*) inferior_pid);
 }
 
 static void
 restore_inferior_pid (pid)
-     int pid;
+     void *pid;
 {
-  inferior_pid = pid;
+  inferior_pid = (int) pid;
 }
 \f
 
@@ -1436,7 +1436,6 @@ sol_core_files_info (t)
   orig_core_ops.to_files_info (t);
 }
 
-#ifdef MAINTENANCE_CMDS
 /* Worker bee for info sol-thread command.  This is a callback function that
    gets called once for each Solaris thread (ie. not kernel thread) in the 
    inferior.  Print anything interesting that we can think of.  */
@@ -1501,7 +1500,6 @@ info_solthreads (args, from_tty)
                    TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
                    TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 }
-#endif /* MAINTENANCE_CMDS */
 
 static int
 ignore (addr, contents)
@@ -1648,10 +1646,8 @@ _initialize_sol_thread ()
 
   procfs_suppress_run = 1;
 
-#ifdef MAINTENANCE_CMDS
   add_cmd ("sol-threads", class_maintenance, info_solthreads, 
            "Show info on Solaris user threads.\n", &maintenanceinfolist);
-#endif /* MAINTENANCE_CMDS */
 
   memcpy(&orig_core_ops, &core_ops, sizeof (struct target_ops));
   memcpy(&core_ops, &sol_core_ops, sizeof (struct target_ops));
index 6d6fd4a3a84ebc942c90be25591977eb190605ea..aa2dd46ab13462a913397991f5c0ddc222b59804 100644 (file)
@@ -1310,7 +1310,7 @@ clear_solib()
 {
   struct so_list *next;
   char *bfd_filename;
-  
+
   while (so_list_head)
     {
       if (so_list_head -> sections)
index 9fe97425aa4daf2ed4c9882e0fadc6fb6070ad1a..8b330dee13154a73a886cbd16173a54bd27a4dab 100644 (file)
@@ -976,10 +976,12 @@ identify_source_line (s, line, mid_statement, pc)
 /* Print source lines from the file of symtab S,
    starting with line number LINE and stopping before line number STOPLINE. */
 
+static void print_source_lines_base PARAMS ((struct symtab *s, int line, int stopline, int noerror));
 static void
 print_source_lines_base (s, line, stopline, noerror)
      struct symtab *s;
-     int line, stopline;
+     int line;
+     int stopline;
      int noerror;
 {
   register int c;
@@ -1284,19 +1286,21 @@ list_command (arg, from_tty)
   else if (sal.symtab == 0)
     error ("No default source file yet.  Do \"help list\".");
   else if (no_end)
-    if (lines_to_list % 2 == 0) 
-      print_source_lines (sal.symtab,
-                         max (sal.line - (lines_to_list / 2), 1),
-                         sal.line + (lines_to_list / 2), 0);
-    else
-      /* If lines_to_list is odd, then we round down in
-       * one of the lines_to_list/2 computations, round up in
-       * the other, so the total window size around the specified
-       * line comes out right.
-       */
-      print_source_lines (sal.symtab,
-                       max (sal.line - (lines_to_list / 2), 1),
-                       sal.line + ((1+lines_to_list) / 2), 0);
+    {
+      if (lines_to_list % 2 == 0) 
+       print_source_lines (sal.symtab,
+                           max (sal.line - (lines_to_list / 2), 1),
+                           sal.line + (lines_to_list / 2), 0);
+      else
+       /* If lines_to_list is odd, then we round down in
+        * one of the lines_to_list/2 computations, round up in
+        * the other, so the total window size around the specified
+        * line comes out right.
+        */
+       print_source_lines (sal.symtab,
+                           max (sal.line - (lines_to_list / 2), 1),
+                           sal.line + ((1+lines_to_list) / 2), 0);
+    }
   else
     print_source_lines (sal.symtab, sal.line,
                        (dummy_end
index 113b32cd7ccfaed6f95bcc65d24dcfe55d734754..f5b948ec4b88f1ab599f7689904f03fae29dbf5d 100644 (file)
@@ -673,7 +673,7 @@ isbranch (instruction, addr, target)
    The argument RAW_BUFFER must point to aligned memory.  */
 
 void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
+sparc_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
      char *raw_buffer;
      int *optimized;
      CORE_ADDR *addrp;
index c5d31e190af341c1ebd96c35dd9a61433ea6ac37..a143dba42d5c74b121754d4a1405a04cc1892312 100644 (file)
@@ -196,9 +196,12 @@ static const char vb_name[] =   { '_','v','b',CPLUS_MARKER,'\0' };
    address of the corresponding int, which is not the same on a
    big-endian machine.  */
 
-#ifndef BELIEVE_PCC_PROMOTION
+#if !defined (BELIEVE_PCC_PROMOTION)
 #define BELIEVE_PCC_PROMOTION 0
 #endif
+#if !defined (BELIEVE_PCC_PROMOTION_TYPE)
+#define BELIEVE_PCC_PROMOTION_TYPE 0
+#endif
 
 static struct complaint invalid_cpp_abbrev_complaint =
   {"invalid C++ abbreviation `%s'", 0, 0};
@@ -1732,80 +1735,80 @@ define_symbol (valu, string, desc, type, objfile)
       if (processing_gcc_compilation || BELIEVE_PCC_PROMOTION)
        break;
 
-#if !BELIEVE_PCC_PROMOTION
-      {
-       /* This is the signed type which arguments get promoted to.  */
-       static struct type *pcc_promotion_type;
-       /* This is the unsigned type which arguments get promoted to.  */
-       static struct type *pcc_unsigned_promotion_type;
-
-       /* Call it "int" because this is mainly C lossage.  */
-       if (pcc_promotion_type == NULL)
-         pcc_promotion_type =
-           init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
-                      0, "int", NULL);
-
-       if (pcc_unsigned_promotion_type == NULL)
-         pcc_unsigned_promotion_type =
-           init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
-                      TYPE_FLAG_UNSIGNED, "unsigned int", NULL);
-
-#if defined(BELIEVE_PCC_PROMOTION_TYPE)
-       /* This macro is defined on machines (e.g. sparc) where
-          we should believe the type of a PCC 'short' argument,
-          but shouldn't believe the address (the address is
-          the address of the corresponding int).
-          
-          My guess is that this correction, as opposed to changing
-          the parameter to an 'int' (as done below, for PCC
-          on most machines), is the right thing to do
-          on all machines, but I don't want to risk breaking
-          something that already works.  On most PCC machines,
-          the sparc problem doesn't come up because the calling
-          function has to zero the top bytes (not knowing whether
-          the called function wants an int or a short), so there
-          is little practical difference between an int and a short
-          (except perhaps what happens when the GDB user types
-          "print short_arg = 0x10000;"). 
-          
-          Hacked for SunOS 4.1 by gnu@cygnus.com.  In 4.1, the compiler
-          actually produces the correct address (we don't need to fix it
-          up).  I made this code adapt so that it will offset the symbol
-          if it was pointing at an int-aligned location and not
-          otherwise.  This way you can use the same gdb for 4.0.x and
-          4.1 systems.
-          
-          If the parameter is shorter than an int, and is integral
-          (e.g. char, short, or unsigned equivalent), and is claimed to
-          be passed on an integer boundary, don't believe it!  Offset the
-          parameter's address to the tail-end of that integer.  */
-       
-       if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (pcc_promotion_type)
-           && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
-           && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (pcc_promotion_type))
-         {
-           SYMBOL_VALUE (sym) += TYPE_LENGTH (pcc_promotion_type)
-             - TYPE_LENGTH (SYMBOL_TYPE (sym));
-         }
-       break;
-       
-#else /* no BELIEVE_PCC_PROMOTION_TYPE.  */
-
-       /* If PCC says a parameter is a short or a char,
-          it is really an int.  */
-       if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (pcc_promotion_type)
-           && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
-         {
-           SYMBOL_TYPE (sym) =
-             TYPE_UNSIGNED (SYMBOL_TYPE (sym))
-               ? pcc_unsigned_promotion_type
-               : pcc_promotion_type;
-         }
-       break;
-
-#endif /* no BELIEVE_PCC_PROMOTION_TYPE.  */
-      }
-#endif /* !BELIEVE_PCC_PROMOTION.  */
+      if (!BELIEVE_PCC_PROMOTION)
+       {
+         /* This is the signed type which arguments get promoted to.  */
+         static struct type *pcc_promotion_type;
+         /* This is the unsigned type which arguments get promoted to.  */
+         static struct type *pcc_unsigned_promotion_type;
+         
+         /* Call it "int" because this is mainly C lossage.  */
+         if (pcc_promotion_type == NULL)
+           pcc_promotion_type =
+             init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+                        0, "int", NULL);
+         
+         if (pcc_unsigned_promotion_type == NULL)
+           pcc_unsigned_promotion_type =
+             init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
+                        TYPE_FLAG_UNSIGNED, "unsigned int", NULL);
+         
+         if (BELIEVE_PCC_PROMOTION_TYPE)
+           {
+             /* This is defined on machines (e.g. sparc) where we
+                should believe the type of a PCC 'short' argument,
+                but shouldn't believe the address (the address is the
+                address of the corresponding int).
+                
+                My guess is that this correction, as opposed to
+                changing the parameter to an 'int' (as done below,
+                for PCC on most machines), is the right thing to do
+                on all machines, but I don't want to risk breaking
+                something that already works.  On most PCC machines,
+                the sparc problem doesn't come up because the calling
+                function has to zero the top bytes (not knowing
+                whether the called function wants an int or a short),
+                so there is little practical difference between an
+                int and a short (except perhaps what happens when the
+                GDB user types "print short_arg = 0x10000;").
+                
+                Hacked for SunOS 4.1 by gnu@cygnus.com.  In 4.1, the
+                compiler actually produces the correct address (we
+                don't need to fix it up).  I made this code adapt so
+                that it will offset the symbol if it was pointing at
+                an int-aligned location and not otherwise.  This way
+                you can use the same gdb for 4.0.x and 4.1 systems.
+                
+                If the parameter is shorter than an int, and is
+                integral (e.g. char, short, or unsigned equivalent),
+                and is claimed to be passed on an integer boundary,
+                don't believe it!  Offset the parameter's address to
+                the tail-end of that integer.  */
+             
+             if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (pcc_promotion_type)
+                 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT
+                 && 0 == SYMBOL_VALUE (sym) % TYPE_LENGTH (pcc_promotion_type))
+               {
+                 SYMBOL_VALUE (sym) += TYPE_LENGTH (pcc_promotion_type)
+                   - TYPE_LENGTH (SYMBOL_TYPE (sym));
+               }
+             break;
+           }
+         else
+           {
+             /* If PCC says a parameter is a short or a char,
+                it is really an int.  */
+             if (TYPE_LENGTH (SYMBOL_TYPE (sym)) < TYPE_LENGTH (pcc_promotion_type)
+                 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
+               {
+                 SYMBOL_TYPE (sym) =
+                   TYPE_UNSIGNED (SYMBOL_TYPE (sym))
+                   ? pcc_unsigned_promotion_type
+                   : pcc_promotion_type;
+               }
+             break;
+           }
+       }
 
     case 'P':
       /* acc seems to use P to declare the prototypes of functions that
@@ -2147,7 +2150,7 @@ define_symbol (valu, string, desc, type, objfile)
   while (*p && *p == ';')
     {
       p++;
-      if (*p && *p == 'l')
+      if (*p && p[0] == 'l' && p[1] == '(')
         {
           /* GNU extensions for live range splitting may be appended to 
              the end of the stab string.  eg. "l(#1,#2);l(#3,#5)" */
index e36316e322919df024bc65c89a0d7f85cb9b2062..20a6124da5f650eabf9406c9e578b45ad7060fbd 100644 (file)
@@ -65,6 +65,8 @@ static void up_silently_command PARAMS ((char *, int));
 
 void frame_command PARAMS ((char *, int));
 
+static void current_frame_command PARAMS ((char *, int));
+
 static void select_frame_command PARAMS ((char *, int));
 
 static void print_frame_arg_vars PARAMS ((struct frame_info *, GDB_FILE *));
@@ -134,9 +136,10 @@ static int print_stack_frame_base_stub PARAMS ((char *));
 
 /* Show and print the frame arguments.
    Pass the args the way catch_errors wants them.  */
+static int show_and_print_stack_frame_stub PARAMS ((void *args));
 static int
 show_and_print_stack_frame_stub (args)
-     char *args;
+     void *args;
 {
   struct print_stack_frame_args *p = (struct print_stack_frame_args *)args;
 
@@ -152,9 +155,10 @@ show_and_print_stack_frame_stub (args)
 
 /* Show or print the frame arguments.
    Pass the args the way catch_errors wants them.  */
+static int print_stack_frame_stub PARAMS ((void *args));
 static int
 print_stack_frame_stub (args)
-     char *args;
+     void *args;
 {
   struct print_stack_frame_args *p = (struct print_stack_frame_args *)args;
 
@@ -182,9 +186,10 @@ print_stack_frame_base_stub (args)
 
 /* print the frame arguments to the terminal.  
    Pass the args the way catch_errors wants them.  */
+static int print_only_stack_frame_stub PARAMS ((void *));
 static int
 print_only_stack_frame_stub (args)
-     char *args;
+     void *args;
 {
   struct print_stack_frame_args *p = (struct print_stack_frame_args *)args;
 
@@ -215,7 +220,7 @@ print_stack_frame_base (fi, level, source)
   args.source = source;
   args.args = 1;
 
-  catch_errors (print_stack_frame_stub, (char *)&args, "", RETURN_MASK_ALL);
+  catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ALL);
 }
 
 /* Show and print a stack frame briefly.  FRAME_INFI should be the frame info
@@ -241,7 +246,7 @@ show_and_print_stack_frame (fi, level, source)
   args.source = source;
   args.args = 1;
 
-  catch_errors (show_and_print_stack_frame_stub, (char *)&args, "", RETURN_MASK_ALL);
+  catch_errors (show_and_print_stack_frame_stub, &args, "", RETURN_MASK_ALL);
 }
 
 
@@ -294,8 +299,7 @@ print_only_stack_frame (fi, level, source)
   args.source = source;
   args.args = 1;
 
-  catch_errors (print_only_stack_frame_stub, 
-                (char *)&args, "", RETURN_MASK_ALL);
+  catch_errors (print_only_stack_frame_stub, &args, "", RETURN_MASK_ALL);
 }
 
 struct print_args_args {
@@ -574,6 +578,7 @@ print_frame_info_base (fi, level, source, args)
 }
 \f
 
+#if 0
 void
 stack_publish_stopped_with_no_frame()
 {
@@ -581,6 +586,7 @@ stack_publish_stopped_with_no_frame()
 
   return;
 }
+#endif
 
 /* Show or print the frame info.  If this is the tui, it will be shown in 
    the source display */
@@ -971,6 +977,7 @@ backtrace_limit_info (arg, from_tty)
 
 /* Print briefly all stack frames or just the innermost COUNT frames.  */
 
+static void backtrace_command_1 PARAMS ((char *count_exp, int show_locals, int from_tty));
 static void
 backtrace_command_1 (count_exp, show_locals, from_tty)
      char *count_exp;
@@ -1080,7 +1087,7 @@ backtrace_command (arg, from_tty)
       int i;
 
       argv = buildargv(arg);
-      old_chain = make_cleanup ((make_cleanup_func) freeargv, (char *)argv);
+      old_chain = make_cleanup_freeargv (argv);
       argc = 0;
       for (i = 0; (argv[i] != (char *)NULL); i++)
         {
@@ -1089,7 +1096,7 @@ backtrace_command (arg, from_tty)
           for (j = 0; (j < strlen(argv[i])); j++)
             argv[i][j] = tolower(argv[i][j]);
 
-          if (argIndicatingFullTrace < 0 && subsetCompare(argv[i], "full"))
+          if (argIndicatingFullTrace < 0 && subset_compare (argv[i], "full"))
             argIndicatingFullTrace = argc;
           else
             {
@@ -1132,6 +1139,7 @@ backtrace_command (arg, from_tty)
     do_cleanups(old_chain);
 }
 
+static void backtrace_full_command PARAMS ((char *arg, int from_tty));
 static void
 backtrace_full_command (arg, from_tty)
      char *arg;
@@ -1522,6 +1530,7 @@ select_and_print_frame(fi, level)
 \f
 /* Select frame FI, noting that its stack level is LEVEL.  Be silent if
    not the TUI */
+#if 0
 void
 select_and_maybe_print_frame (fi, level)
      struct frame_info *fi;
@@ -1532,6 +1541,7 @@ select_and_maybe_print_frame (fi, level)
   else
     select_and_print_frame(fi, level);
 }
+#endif
 
 
 /* Store the selected frame and its level into *FRAMEP and *LEVELP.
@@ -1652,15 +1662,15 @@ frame_command (level_exp, from_tty)
 
 /* The XDB Compatibility command to print the current frame. */
 
-void
+static void
 current_frame_command (level_exp, from_tty)
      char *level_exp;
      int from_tty;
 {
   if (target_has_stack == 0 || selected_frame == 0)
     error ("No stack."); 
- print_only_stack_frame (selected_frame, selected_frame_level, 1);
-  }
 print_only_stack_frame (selected_frame, selected_frame_level, 1);
+}
 
 /* Select the frame up one or COUNT stack levels
    from the previously selected frame, and print it briefly.  */
@@ -1846,6 +1856,7 @@ struct function_bounds
   CORE_ADDR low, high;
 };
 
+static void func_command PARAMS ((char *arg, int from_tty));
 static void
 func_command (arg, from_tty)
      char *arg;
index 30f4a44e139a526fafd72adebe878fb283b547ee..032b9efdd0387a659e8a2335fab4eec0c688ede7 100644 (file)
@@ -35,7 +35,6 @@ fetch_inferior_registers (regno)
 #ifdef FP0_REGNUM
   struct fp_status inferior_fp_registers;
 #endif
-  extern char registers[];
 
   registers_fetched ();
   
@@ -72,7 +71,6 @@ store_inferior_registers (regno)
 #ifdef FP0_REGNUM
   struct fp_status inferior_fp_registers;
 #endif
-  extern char registers[];
 
   memcpy (&inferior_registers, registers, 16 * 4);
 #ifdef FP0_REGNUM
@@ -107,7 +105,6 @@ fetch_core_registers (core_reg_sect, core_reg_size, which, reg_addr)
      int which;
      CORE_ADDR reg_addr;       /* Unused in this version */
 {
-  extern char registers[];
   struct regs *regs = (struct regs *) core_reg_sect;
 
   if (which == 0) {
index 1abb4bb1df05a8ca1384dfd4a155ea0b315cbd71..b62b6fd8f85d8e2dc9f7c5f4b2185f02366dba43 100644 (file)
@@ -49,7 +49,6 @@ core_file_command (filename, from_tty)
      int from_tty;
 {
   int val;
-  extern char registers[];
 
   /* Discard all vestiges of any previous core file
      and mark data and stack spaces as empty.  */
@@ -189,7 +188,6 @@ fetch_inferior_registers (regno)
 {
   struct regs inferior_registers;
   struct fp_state inferior_fp_registers;
-  extern char registers[];
 
   registers_fetched ();
 
@@ -217,7 +215,6 @@ store_inferior_registers (regno)
 {
   struct regs inferior_registers;
   struct fp_state inferior_fp_registers;
-  extern char registers[];
 
   memcpy (&inferior_registers, registers, 20 * 4);
 
index ee60c9392e4ececb3c10f51160d8cd2615d3986d..5082f39e4abdda595816a6d9c03238a12978d3f8 100644 (file)
@@ -839,7 +839,7 @@ symbol_file_command (args, from_tty)
        {
          nomem (0);
        }
-      cleanups = make_cleanup ((make_cleanup_func) freeargv, (char *) argv);
+      cleanups = make_cleanup_freeargv (argv);
       while (*argv != NULL)
        {
          if (STREQ (*argv, "-mapped"))
index 04610660cd58c57288ccad4ca4e6db16cc7324e3..56e1c674dc4be24ffa5f1c654d5eb44936987a4b 100644 (file)
@@ -57,7 +57,6 @@ int regno;
 {
   struct pt_regset regs;
   int i;
-  extern char registers[];
 
   /* FIXME: Fetching the registers is a kludge to initialize all elements
      in the fpu and fpa status. This works for normal debugging, but
@@ -98,7 +97,6 @@ fetch_inferior_registers (regno)
 {
   int i;
   struct pt_regset regs;
-  extern char registers[];
 
   registers_fetched ();
 
index 97d2f6e83cd58740ef95451523172f85a00a8af3..c615bfcdea27d89f65917f17eacf8b1449f203fa 100644 (file)
@@ -154,8 +154,6 @@ free_symtab (s)
   mfree (s -> objfile -> md, (PTR) s);
 }
 
-#if MAINTENANCE_CMDS
-
 void
 print_symbol_bcache_statistics ()
 {
@@ -525,7 +523,7 @@ Arguments missing: an output file name and an optional symbol file name");
     {
       nomem (0);
     }
-  cleanups = make_cleanup ((make_cleanup_func) freeargv, (char *) argv);
+  cleanups = make_cleanup_freeargv (argv);
 
   if (argv[0] != NULL)
     {
@@ -762,7 +760,7 @@ maintenance_print_psymbols (args, from_tty)
     {
       nomem (0);
     }
-  cleanups = make_cleanup ((make_cleanup_func) freeargv, (char *) argv);
+  cleanups = make_cleanup_freeargv (argv);
 
   if (argv[0] != NULL)
     {
@@ -910,7 +908,7 @@ maintenance_print_msymbols (args, from_tty)
     {
       nomem (0);
     }
-  cleanups = make_cleanup ((make_cleanup_func) freeargv, argv);
+  cleanups = make_cleanup_freeargv (argv);
 
   if (argv[0] != NULL)
     {
@@ -1055,8 +1053,6 @@ block_depth (block)
   return i;
 }
 
-#endif /* MAINTENANCE_CMDS */
-
 \f
 /* Increase the space allocated for LISTP, which is probably
    global_psymbols or static_psymbols. This space will eventually
index fb3c8f77ba29017db17633df84a32351c7443164..5c4af5346fdb2843c317d8500d102103d2477fa8 100644 (file)
@@ -2852,6 +2852,14 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
       while (*p == ' ' || *p == '\t') p++;
       *argptr = p;
     }
+#if 0
+  /* No one really seems to know why this was added. It certainly
+     breaks the command line, though, whenever the passed
+     name is of the form ClassName::Method. This bit of code
+     singles out the class name, and if funfirstline is set (for
+     example, you are setting a breakpoint at this function),
+     you get an error. This did not occur with earlier
+     verions, so I am ifdef'ing this out. 3/29/99 */
   else {
     /* Check if what we have till now is a symbol name */
 
@@ -2880,6 +2888,7 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
     /* Otherwise fall out from here and go to file/line spec
        processing, etc. */ 
   }
+#endif
 
   /* S is specified file's symtab, or 0 if no file specified.
      arg no longer contains the file name.  */
@@ -4374,6 +4383,16 @@ make_symbol_overload_list (fsym)
   sym_return_val = (struct symbol **) xmalloc ((sym_return_val_size + 1) * sizeof (struct symbol *));
   sym_return_val[0] = NULL;
 
+  /* Comment and #if 0 from Rajiv Mirani <mirani@cup.hp.com>.
+     However, leaving #if 0's around is uncool.  We need to figure out
+     what this is really trying to do, decide whether we want that,
+     and either fix it or delete it.  --- Jim Blandy, Mar 1999 */
+
+  /* ??? RM: What in hell is this? overload_list_add_symbol expects a symbol,
+   * not a partial_symbol or a minimal_symbol. And it looks at the type field
+   * of the symbol, and we don't know the type of minimal and partial symbols
+   */
+#if 0
   /* Look through the partial symtabs for all symbols which begin
      by matching OLOAD_NAME.  Add each one that you find to the list.  */
 
@@ -4413,6 +4432,7 @@ make_symbol_overload_list (fsym)
       QUIT;
       overload_list_add_symbol (msymbol, oload_name);
     }
+#endif
 
   /* Search upwards from currently selected frame (so that we can
      complete on local vars.  */
index 67e6bedb25ac41b1637ad8806e67f40a114f6cb0..4c06d83f61cfb2c96f3d2bfeee8389c6a382b4d0 100644 (file)
@@ -1357,8 +1357,6 @@ decode_line_spec_1 PARAMS ((char *, int));
 extern struct symtabs_and_lines
 decode_line_1 PARAMS ((char **, int, struct symtab *, int, char ***));
 
-#if MAINTENANCE_CMDS
-
 /* Symmisc.c */
 
 void
@@ -1381,8 +1379,6 @@ maintenance_check_symtabs PARAMS ((char *, int));
 void
 maintenance_print_statistics PARAMS ((char *, int));
 
-#endif
-
 extern void
 free_symtab PARAMS ((struct symtab *));
 
index 808eb8fc16d2012dbfcbc1eaf340b2b425e1b437..bf9dc3b97f9a3d5c4e9d9d278077c947ca2dd000 100644 (file)
@@ -208,15 +208,12 @@ static struct cmd_list_element *targetlist = NULL;
 
 int attach_flag;
 
-#ifdef MAINTENANCE_CMDS
 /* Non-zero if we want to see trace of target level stuff.  */
 
 static int targetdebug = 0;
 
 static void setup_target_debug PARAMS ((void));
 
-#endif
-
 /* The user just typed 'target' without the name of a target.  */
 
 /* ARGSUSED */
@@ -608,10 +605,8 @@ push_target (t)
 
   cleanup_target (&current_target); /* Fill in the gaps */
 
-#ifdef MAINTENANCE_CMDS
   if (targetdebug)
     setup_target_debug ();
-#endif
 
   return prev != 0;
 }
@@ -1105,6 +1100,30 @@ return_one ()
   return 1;
 }
 
+/* Find a single runnable target in the stack and return it.  If for
+   some reason there is more than one, return NULL.  */
+
+struct target_ops *
+find_run_target ()
+{
+  struct target_ops **t;
+  struct target_ops *runable = NULL;
+  int count;
+  
+  count = 0;
+  
+  for (t = target_structs; t < target_structs + target_struct_size; ++t)
+    {
+      if ((*t)->to_can_run && target_can_run(*t))
+       {
+         runable = *t;
+         ++count;
+       }
+    }
+  
+  return (count == 1 ? runable : NULL);
+}
+
 struct target_ops *
 find_core_target ()
 {
@@ -1248,6 +1267,8 @@ static struct {
   {"EXC_SOFTWARE", "Software generated exception"},
   {"EXC_BREAKPOINT", "Breakpoint"},
 #endif
+  {"SIGINFO", "Information request"},
+
   {NULL, "Unknown signal"},
   {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
 
@@ -1260,7 +1281,10 @@ char *
 target_signal_to_string (sig)
      enum target_signal sig;
 {
-  return signals[sig].string;
+  if ((sig >= TARGET_SIGNAL_FIRST) && (sig <= TARGET_SIGNAL_LAST))
+    return signals[sig].string;
+  else
+    return signals[TARGET_SIGNAL_UNKNOWN].string;
 }
 
 /* Return the name for a signal.  */
@@ -1466,6 +1490,10 @@ target_signal_from_host (hostsig)
   if (hostsig == _NSIG + EXC_BREAKPOINT) return TARGET_EXC_BREAKPOINT;
 #endif
 
+#if defined (SIGINFO)
+  if (hostsig == SIGINFO) return TARGET_SIGNAL_INFO;
+#endif
+
 #if defined (REALTIME_LO)
   if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
     return (enum target_signal)
@@ -1640,6 +1668,10 @@ target_signal_to_host (oursig)
     case TARGET_EXC_BREAKPOINT: return _NSIG + EXC_BREAKPOINT;
 #endif
 
+#if defined (SIGINFO)
+    case TARGET_SIGNAL_INFO: return SIGINFO;
+#endif
+
     default:
 #if defined (REALTIME_LO)
       if (oursig >= TARGET_SIGNAL_REALTIME_33
@@ -1768,7 +1800,6 @@ init_dummy_target ()
 }
 
 \f
-#ifdef MAINTENANCE_CMDS
 static struct target_ops debug_target;
 
 static void
@@ -2308,7 +2339,8 @@ debug_to_has_execd (pid, execd_pathname)
   has_execd = debug_target.to_has_execd (pid, execd_pathname);
 
   fprintf_unfiltered (gdb_stderr, "target_has_execd (%d, %s) = %d\n",
-                      pid, *execd_pathname, has_execd);
+                      pid, (*execd_pathname ? *execd_pathname : "<NULL>"),
+                     has_execd);
 
   return has_execd;
 }
@@ -2447,19 +2479,21 @@ debug_to_enable_exception_callback (kind, enable)
   enum exception_event_kind kind;
   int enable;
 {
-  debug_target.to_enable_exception_callback (kind, enable);
-
+  struct symtab_and_line *result;
+  result = debug_target.to_enable_exception_callback (kind, enable);
   fprintf_unfiltered (gdb_stderr,
                      "target get_exception_callback_sal (%d, %d)\n",
                      kind, enable);
+  return result;
 }
 
 static struct exception_event_record *
 debug_to_get_current_exception_event ()
 {
-  debug_target.to_get_current_exception_event();
-
+  struct exception_event_record *result;
+  result = debug_target.to_get_current_exception_event();
   fprintf_unfiltered (gdb_stderr, "target get_current_exception_event ()\n");
+  return result;
 }
 
 static char *
@@ -2551,7 +2585,7 @@ setup_target_debug ()
   current_target.to_core_file_to_sym_file = debug_to_core_file_to_sym_file;
 
 }
-#endif /* MAINTENANCE_CMDS */
+
 \f
 static char targ_desc[] = 
     "Names of targets and files being debugged.\n\
@@ -2567,14 +2601,12 @@ initialize_targets ()
   add_info ("target", target_info, targ_desc);
   add_info ("files", target_info, targ_desc);
 
-#ifdef MAINTENANCE_CMDS
   add_show_from_set (
      add_set_cmd ("targetdebug", class_maintenance, var_zinteger,
                  (char *)&targetdebug,
                 "Set target debugging.\n\
 When non-zero, target debugging is enabled.", &setlist),
                     &showlist);
-#endif
 
   if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))
     abort ();
index 21c3babddba51906ff1410b79d3fb0d1f004f8ac..c8c9bb52b4fbd040e74d42d178d36ccd1d0d66d9 100644 (file)
@@ -207,13 +207,15 @@ enum target_signal {
   TARGET_SIGNAL_REALTIME_63 = 75,
 #if defined(MACH) || defined(__MACH__)
   /* Mach exceptions */
-  TARGET_EXC_BAD_ACCESS = 76,
-  TARGET_EXC_BAD_INSTRUCTION = 77,
-  TARGET_EXC_ARITHMETIC = 78,
-  TARGET_EXC_EMULATION = 79,
-  TARGET_EXC_SOFTWARE = 80,
-  TARGET_EXC_BREAKPOINT = 81,
+  TARGET_EXC_BAD_ACCESS,
+  TARGET_EXC_BAD_INSTRUCTION,
+  TARGET_EXC_ARITHMETIC,
+  TARGET_EXC_EMULATION,
+  TARGET_EXC_SOFTWARE,
+  TARGET_EXC_BREAKPOINT,
 #endif
+  TARGET_SIGNAL_INFO,
+
   /* Some signal we don't know about.  */
   TARGET_SIGNAL_UNKNOWN,
 
@@ -1212,6 +1214,8 @@ find_default_create_inferior PARAMS ((char *, char *, char **));
 void
 find_default_clone_and_follow_inferior PARAMS ((int, int *));
 
+extern struct target_ops *find_run_target PARAMS ((void));
+
 extern struct target_ops *
 find_core_target PARAMS ((void));
 \f
index 77a96b0f9613e1a7db3f0fb2db2391325eac2259..331c2afe40f6c571cd54512684927c91f23980d2 100644 (file)
+1999-04-20  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * gdb.c++/demangle.exp (test_gnu_style_demangling): Add tests for
+       Marcus Daniel's and Dale Hawkins's demangler crashes.
+
+       * gdb.c++/demangle.exp (test_gnu_style_demangling,
+       test_lucid_style_demangling, test_arm_style_demangling,
+       test_hp_style_demangling): Try Tom Tromey's core-dumping
+       identifier under each demangling style.
+
+1999-04-07  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * gdb.c++/demangle.exp: Include the current demangling style
+       in all test names.
+       (current_demangling_style): New global variable.
+       (set_demangling_style, test_demangling_core, test_demangling,
+       test_demangling_exact): New functions.
+       (test_gnu_style_demangling, test_lucid_style_demangling,
+       test_arm_style_demangling, test_hp_style_demangling): Use those,
+       instead of calling gdb_test and gdb_test_exact directly.
+       (catch_demangling_errors): New function, which reports errors
+       signalled by the demangling test functions in an orderly way.
+       (do_tests): Use catch_demangling_errors.
+
+1999-04-06  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * gdb.base/signals.exp (test_handle_all_print): Use () for
+       grouping in expressions, not {}.
+
+       * gdb.base/smoke.exp: Test value of x, not y.  The latter isn't
+       initialized yet.
+
+1999-04-01  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * gdb.c++/derivation.exp: Pass ptype tests if synthesized methods
+       are listed.
+
+1999-03-26  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * gdb.stabs/weird.exp: Test for CC being defined before
+       looking at its value.
+
+1999-03-25  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * gdb.base/call-ar-st.exp: Remove stray '#'.
+       * gdb.base/miscexprs.exp: Allow "short" and "long" as well as
+       "short int" and "long int".
+       * gdb.c++/overload.cc: Cast the string added in the previous
+       change, to mollify finicky HP compiler.
+       * gdb.hp/reg-test.exp (testfile): Fix file name.
+       * gdb.stabs/weird.exp: Don't try to run if HP compiler in use.
+       
+       * gdb.c++/misc.cc (main): Initialize obj_with_enum.
+       * gdb.c++/classes.exp: Fix test of obj_with_enum values, allow
+       alternate form of enum ptype.
+
 1999-03-23  Stan Shebs  <shebs@andros.cygnus.com>
 
+       * lib/gdb.exp (skip_hp_tests): Remove gcc_used argument.
+       * gdb.hp/*.exp: Change all to run compiler probe only after
+       passing skip_hp_tests, so as not to waste time on guaranteed
+       failure.
+
        * gdb.c++/overload.cc: Pass string instead of char addr, always
        init ccpfoo.
        * gdb.c++/templates.cc: Fix syntax error.
 
-1999-03-09  Jim Blandy  <jimb@zwingli.cygnus.com>
+Tue Mar 23 14:56:36 1999  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+       * gdb.base/commands.exp: Add test for correct position of '>'
+       when issuing the 'commands' command after a 'while' or 'if' 
+       command.
+
+1999-03-18  James Ingham  <jingham@cygnus.com>
+
+       * gdb.c++/ovldbreak.exp: Use gdb_continue_to_end
+
+       * gdb.c++/method.exp: It was testing an uninitialized int on the
+       stack and assuming it was positive.
+
+       * gdb.base/watchpoint.exp: Use gdb_continue_to_end.
+
+       * gdb.base/step-test.exp: Catch a case where finish is broken and
+       keep it from killing the rest of the tests. 
+       Use gdb_continue_to_end.
+
+       * gdb.base/sigall.exp: use gdb_continue_to_end.
+
+       * gdb.base/ena-dis-br.exp: use gdb_continue_to_end.
+
+       * gdb.base/display.exp: use runto_main, not run.
+
+       * gdb.base/default.exp: Check for the current error message in the 
+       r abbreviation test.  
+       Add strongarm to the targets that know info float.
+
+       * gdb.base/condbreak.exp: Use the gdb_run command rather than just 
+       run which doesn't work with monitors.
+
+       * gdb.base/call-ar-st.exp: fixed bogus regexp in continuing to 1034 test.
+
+       * gdb.base/break.exp: use the gdb_continue_to_end proc.
+
+       * lib/gdb.exp: I had added gdb_continue_to_end used to run to the end of a
+       program.  Traps the case (in Cygmon) when the program never really 
+       exits.  Same as Mark's continue_to_exit, but I had put it in a lot 
+       more places, so I used my name.  Sorry Mark...
+
+       * config/monitor.exp (gdb_target_monitor): added another
+       target_info parameter: remotebinarydownload.  This will set the
+       remotebinarydownload flag if this is causing some boards trouble.
+
+1999-03-18  Mark Salter  <msalter@cygnus.com>
+
+       * lib/gdb.exp (continue_to_exit): New function.
+
+       * gdb.base/ena-dis-br.exp: Clean up for remote targets.
+       * gdb.base/ending-run.exp: Ditto.
+       * gdb.base/step-test.exp: Ditto.
+
+1999-03-16  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * gdb.base/miscexprs.c: Clean up file, clear cbig.c[0] explicitly
+       (suggested by Art Haas <ahaas@neosoft.com>).
+
+1999-03-16  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * gdb.base/signals.exp: Filter out *-*-linux* before matching *-*-gnu*.
+
+Fri Mar 12 18:06:21 1999  Stan Shebs  <shebs@andros.cygnus.com>
+
+       * gdb.c++/ref-types.exp, ref-types2.exp: Allow alternate
+       descriptions of types (short unsigned int vs unsigned short, etc).
+
+1999-03-12  Jim Blandy  <jimb@zwingli.cygnus.com>
+
+       * gdb.base/call-strs.exp: Don't assume that `step' will step over
+       a call to strlen; sometimes we do have sources.
+
+1999-03-08  Jim Blandy  <jimb@zwingli.cygnus.com>
 
        * gdb.base/call-ar-st.c (main): Terminate char_array with a null
        character, so GDB won't print garbage after its end.
        * gdb.base/step-test.exp: Rewrite `stepi' and `nexti' tests to be
        more portable.
 
+1999-03-08  Jim Blandy  <jimb@zwingli.cygnus.com>
+
        * lib/gdb.exp: Doc fixes.
 
+1999-03-05  Nick Clifton  <nickc@cygnus.com>
+
+       * gdb.base/a2-run.exp: Add expected fails for strongarm-coff. 
+
+1999-03-04  Jim Blandy  <jimb@zwingli.cygnus.com>
+
        * gdb.base/display.exp: Don't exercise the "detach" and "kill"
        commands.  They're not germane to this test, and they don't work
        that way on remote targets.
 
+1999-02-25  Felix Lee  <flee@cygnus.com>
+
+       * lib/gdb.exp (debug_format): initialize
+
 1999-02-25  Jason Molenda  (jsm@bugshack.cygnus.com)
 
        * gdb.base/call-ar-st.c: Include string.h, not strings.h.
        * gdb.base/call-rt-st.c: Ditto.
 
-1999-02-23  Jim Blandy  <jimb@zwingli.cygnus.com>
-
-       * configure.in: Formatting fix.
-       * configure: Regenerated.
-
 1999-02-13  Jim Blandy  <jimb@zwingli.cygnus.com>
 
        * gdb.threads/pthreads.exp (horiz): New variable.
@@ -263,6 +403,7 @@ Wed Jan  6 18:41:15 1999  David Taylor  <taylor@texas.cygnus.com>
        * gdb.base/varargs.exp: new file.
        * gdb.base/volatile.exp: new file.
        * gdb.base/whatis-exp.exp: new file.
+       * gdb.base/display.exp: new file.
        * gdb.c++/derivation.exp: new file.
        * gdb.c++/local.exp: new file.
        * gdb.c++/member-ptr.exp: new file.
@@ -549,6 +690,7 @@ Thurs Jul 9 11:08:31 1998  Dawn Perchik  <dawn@cygnus.com>
        * gdb.base/commands.exp: Break up infrun_breakpoint_command_test 
        into two parts to get around a synchronization problem in expect.
 
+
 Fri Jun 26 14:52:47 1998  Peter Schauer  <pes@regent.e-technik.tu-muenchen.de>
 
        * gdb.fortran/types.exp:  Escape brackets in expect patterns
index 0d381a22cfa3b24e84d88659c829c6600f86c07d..727ef5386b5f20e824ba9d9069587016577ccf5d 100644 (file)
@@ -16,7 +16,7 @@
 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
 
 load_lib gdb.exp
-
+puts "***** DID USE MONITOR ******"
 #
 # gdb_target_monitor
 # Set gdb to target the monitor
@@ -35,6 +35,9 @@ proc gdb_target_monitor { exec_file } {
     if [target_info exists baud] {
        gdb_test "set remotebaud [target_info baud]" "" ""
     }
+    if [target_info exists binarydownload] {
+       gdb_test "set remotebinarydownload [target_info binarydownload]" "" ""
+    }
     if [target_info exists gdb_serial] {
        set serialport "[target_info gdb_serial]";
     } elseif [target_info exists netport] {
index bf663a29943185a3ad6f22b17b1470aaec5c6e20..2796fe73f678ad5e833c2962b4630f209891726f 100755 (executable)
@@ -13,6 +13,8 @@ ac_default_prefix=/usr/local
 # Any additions from configure.in:
 ac_help="$ac_help
   --enable-shared         use shared libraries"
+ac_help="$ac_help
+  --enable-gdbtk "
 
 # Initialize some variables set by options.
 # The variables have the same names as the options, with
@@ -573,7 +575,7 @@ else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 fi
 
 echo $ac_n "checking host system type""... $ac_c" 1>&6
-echo "configure:577: checking host system type" >&5
+echo "configure:579: checking host system type" >&5
 
 host_alias=$host
 case "$host_alias" in
@@ -594,7 +596,7 @@ host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$host" 1>&6
 
 echo $ac_n "checking target system type""... $ac_c" 1>&6
-echo "configure:598: checking target system type" >&5
+echo "configure:600: checking target system type" >&5
 
 target_alias=$target
 case "$target_alias" in
@@ -612,7 +614,7 @@ target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$target" 1>&6
 
 echo $ac_n "checking build system type""... $ac_c" 1>&6
-echo "configure:616: checking build system type" >&5
+echo "configure:618: checking build system type" >&5
 
 build_alias=$build
 case "$build_alias" in
index 87a0edf293dacb33636b59cf5912086f1136c884..4341d27de254153786099f1329b1478b740d8070 100644 (file)
@@ -109,7 +109,7 @@ if [istarget "*-*-vxworks*"] then {
     verbose "Timeout is now $timeout seconds" 2
     gdb_expect -re "$gdb_prompt $" {}
 } else {
-       setup_xfail "mips-idt-*" "arm-*-coff"
+       setup_xfail "mips-idt-*" "arm-*-coff strongarm-*-coff"
        gdb_run_cmd 5
        gdb_expect {
            -re ".*120.*$gdb_prompt $"\
@@ -137,7 +137,7 @@ if [istarget "*-*-vxworks*"] then {
     verbose "Timeout is now $timeout seconds" 2
     gdb_expect -re "$gdb_prompt $" {}
 } else {
-    setup_xfail "arm-*-coff"
+    setup_xfail "arm-*-coff strongarm-*-coff"
     gdb_expect {
            -re ".*120.*$gdb_prompt $"\
                                { pass "run \"$testfile\" again with same args" }
@@ -215,7 +215,7 @@ if [istarget "*-*-vxworks*"] then {
     verbose "Timeout is now $timeout seconds" 2
     gdb_expect -re "$gdb_prompt $" {}
 } else {
-    setup_xfail "arm-*-coff"
+    setup_xfail "arm-*-coff strongarm-*-coff"
     gdb_expect {
            -re ".*720.*$gdb_prompt $" {
                pass "run \"$testfile\" again after setting args"
index b8f1d7f8fcb91fb216f320386ed1de60503bc0ef..300a4e630ae64d19ed738125966c6218d330007d 100644 (file)
@@ -574,12 +574,18 @@ gdb_expect {
 }
 
 # Verify that GDB responds gracefully to a request to "finish" from
-# the outermost frame.
+# the outermost frame.  On a stub that never exits, this will just
+# run to the stubs routine, so we don't get this error...  Thus the 
+# second condition.
 #
+
 send_gdb "finish\n"
 gdb_expect {
   -re "\"finish\" not meaningful in the outermost frame.\r\n$gdb_prompt $"\
           {pass "finish from outermost frame disallowed"}
+  -re "Run till exit from.*" {
+     pass "finish from outermost frame disallowed"
+  }
   -re "$gdb_prompt $"\
           {fail "finish from outermost frame disallowed"}
   timeout {fail "(timeout) finish from outermost frame disallowed"}
@@ -743,18 +749,8 @@ proc test_next_with_recursion {} {
     if { $result != 0 } { gdb_suppress_tests }
 
     if [target_info exists gdb,noresults] { gdb_suppress_tests }
-    if [target_info exists use_gdb_stub] {
-       gdb_breakpoint "exit"
-       gdb_test "continue" "Continuing..*Breakpoint .*exit \[(\].*=0\[)\].*" "continue until exit in recursive next test"
-    } else {
-    # Continue until we exit.  Should not stop again.
-    # Don't bother to check the output of the program, that may be
-    # extremely tough for some remote systems.
-       gdb_test "continue"\
-               "Continuing.\[\r\n0-9\]+Program exited normally\\..*"\
-               "continue until exit in recursive next test"
-    }
-    gdb_stop_suppressing_tests;
+  gdb_continue_to_end "recursive next test"
+   gdb_stop_suppressing_tests;
 }
 
 test_clear_command
index c61977afb8e5edf28e2e679e4c5dce374a4c8c47..bb30e507d596f553a689fac1f0460f0c8356d554 100644 (file)
@@ -994,7 +994,7 @@ int main ()  {
   for (index = 0; index < 120; index++) {
       if ((index%2) == 0) char_array[index] = 'Z';
         else char_array[index] = 'a';
-  } /* call-ar-st.exp uses line numbers everywhere */ char_array[120] = '\0';
+  } char_array[120] = '\0'; /* call-ar-st.exp uses line numbers everywhere */
 
   for (index = 0; index < 100; index++) {
       double_array[index] = index*23.4567;
index d8ed4fef7dd9ad54801dbf9064168f12ff385962..d408cf1f7f5d5af0ba810637355724481af570ec 100644 (file)
@@ -123,6 +123,7 @@ gdb_expect {
 
 
 #call print_char_array(char_array)
+
 send_gdb "print print_char_array(char_array)\n"
 gdb_expect {
     -re "array_c :\[ \t\r\n\]+=========\[ \t\r\n\]+\[ \t\r\n\]+Z\[ \t\r\n\]+aZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZ\[ \t\r\n\]+aZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZaZ\[ \t\r\n\]+aZaZaZaZaZaZaZaZaZa\[ \t\r\n\]+\[ \t\r\n\]+.*\[ \t\r\n\]+.*$gdb_prompt $" {
@@ -222,7 +223,7 @@ gdb_expect {
 #step -over
     send_gdb "next\n"
     gdb_expect {
-        -re "BYE BYE FOR NOW\[ \t\r\n\]+1035\[ \t\r\n\]+printf\\(.VERY GREEN GRASS.n.\\);\[ \t\r\n\]+.*$gdb_prompt $" { pass "next to 1035"}
+        -re "BYE BYE FOR NOW\[ \t\r\n\]main.*+1035\[ \t\r\n\]+printf\\(.VERY GREEN GRASS.n.\\);\[ \t\r\n\]+.*$gdb_prompt $" { pass "next to 1035"}
         -re ".*$gdb_prompt $" { fail "next to 1035" }
         timeout { fail "next to 1035(timeout)" }
     }
@@ -235,7 +236,7 @@ gdb_expect {
         pass "print print_array_rep(*list1, *list2, *list3)"
       }
     -re ".*$gdb_prompt $" { fail "print print_array_rep(*list1, *list2, *list3)" }
-    timeout           { fail "(timeout) print print_array_rep(*list1, *list2, *list3)"# }
+    timeout           { fail "(timeout) print print_array_rep(*list1, *list2, *list3)" }
   }
 
 
index 20f358a3b63a02288908f01637349f20caad443a..1d4cc4a98abac3f09715f4be0a04bff013fb50e2 100644 (file)
@@ -107,11 +107,11 @@ gdb_expect {
 
 
 #step
-send_gdb "step\n"
+send_gdb "next\n"
 gdb_expect {
-        -re ".*str_func\\(\"abcd\", \"efgh\", \"ijkl\", \"mnop\", \"qrst\", \"uvwx\", \"yz12\"\\);.*$gdb_prompt $" {pass "step after strcpy"}
-        -re ".*$gdb_prompt $" { fail "step after strcpy" }
-        timeout { fail "step after strcpy (timeout)" }
+        -re ".*str_func\\(\"abcd\", \"efgh\", \"ijkl\", \"mnop\", \"qrst\", \"uvwx\", \"yz12\"\\);.*$gdb_prompt $" {pass "next over strcpy"}
+        -re ".*$gdb_prompt $" { fail "next over strcpy" }
+        timeout { fail "next over strcpy (timeout)" }
     }
 
 #print buf
index f70ac6b01d5c8a335534b1952b77a02d7378eafd..72356ec53c2ade7f5ca08d173f334c64540c5eb2 100644 (file)
@@ -236,6 +236,55 @@ proc user_defined_command_test {} {
    gdb_test "show user mycommand" "while.*set.*if.*p/x.*else.*p/x.*end.*" "display user command in user_defined_command_test"
 }
 
+
+
+proc test_command_prompt_position {} {
+    global gdb_prompt
+
+    if [target_info exists noargs] { 
+        verbose "Skipping test_command_prompt_position because of noargs."
+        return
+    }
+
+    if { ![runto factorial] } then { gdb_suppress_tests; }
+    # Don't depend upon argument passing, since most simulators don't currently
+    # support it.  Bash value variable to be what we want.
+    delete_breakpoints
+    gdb_test "break factorial" "Breakpoint.*at.*" "break factorial #2"
+    gdb_test "p value=5" "" "set value to 5 in test_command_prompt_position"
+    # All this test should do is print 0xdeadbeef once.
+    gdb_test "if value == 1\np/x 0xfeedface\nelse\np/x 0xdeadbeef\nend" "\\\$\[0-9\]* = 0xdeadbeef" "if test in test_command_prompt_position"
+
+# Now let's test for the correct position of the '>' in gdb's prompt for commands.
+# It should be at the beginning of the line, and not after one space.
+
+    send_gdb "commands\n"
+    gdb_expect {
+           -re "Type commands.*End with.*\[\r\n\]>$" \
+                { send_gdb "printf \"Now the value is %d\\n\", value\n"
+                 gdb_expect {
+                          -re "^printf.*value\r\n>$" \
+                              { send_gdb "end\n"
+                                 gdb_expect {
+                                      -re "^end\r\n$gdb_prompt $" { pass "> OK in test_command_prompt_position" }
+                                      -re ".*$gdb_prompt $" { fail "some other message in test_command_prompt_position" }
+                                      timeout  { fail "(timeout) 1 in test_command_prompt_position" }
+                                }
+                              }
+                          -re "^ >$" { fail "> not OK in test_command_prompt_position" }
+                          -re ".*$gdb_prompt $"   { fail "wrong message in test_command_prompt_position" }
+                          timeout    { fail "(timeout) 2 in test_command_prompt_position " }
+                      }
+                }
+                -re "Type commands.*End with.*\[\r\n\] >$" { fail "prompt not OK in test_command_prompt_position" }
+          -re ".*$gdb_prompt $" { fail "commands in test_command_prompt_position" }
+          timeout { fail "(timeout) 3 commands in test_command_prompt_position" }
+       }
+
+    gdb_stop_suppressing_tests;
+}
+
+
 gdbvar_simple_if_test
 gdbvar_simple_while_test
 gdbvar_complex_if_while_test
@@ -246,3 +295,8 @@ if_while_breakpoint_command_test
 infrun_breakpoint_command_test
 breakpoint_command_test
 user_defined_command_test
+test_command_prompt_position
+
+
+
+
index 76f752181eccfbcc5039daaae9faa238b501f2b1..cf9deba9c6f78f037da49973b25351a47783362e 100644 (file)
@@ -118,11 +118,11 @@ gdb_test "info break" \
 
 
 #
-# run until the breakpoint at main is hit. For non-stubs-using targets.
+# run until the breakpoint at main is hit.
 #
-gdb_test "run" \
-    "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:60.*60\[\t \]+if .argc.* \{.*" \
-"run until function breakpoint"
+
+
+gdb_run_cmd
 
 #
 # run until the breakpoint at a line number
index 8e1506aeb02a0129007cd8a5a23dffe9ca1ecca4..2a342aa5abc99dff6b86782d2e58d7508c3e05b3 100644 (file)
@@ -40,6 +40,8 @@ gdb_expect {
                        { pass "attach" }
     -re "You can't do that when your target is `None'.*$gdb_prompt $"\
                        { pass "attach" }
+    -re "You can't do that without a process to debug.*$gdb_prompt $"\
+                       { pass "attach" }
     -re "Don't know how to attach.  Try \"help target\"..*$gdb_prompt $"\
                        { pass "attach" }
     -re "Kill it. .y or n." {
@@ -295,6 +297,8 @@ if [istarget "arm-*-*"] then {
     gdb_test "info float" "Software FPU type.*mask:.*flags:.*" "info float"
 } elseif [istarget "thumb-*-*"] then {
     gdb_test "info float" "Software FPU type.*mask:.*flags:.*" "info float"
+} elseif [istarget "strongarm-*-*"] then {
+    gdb_test "info float" "Software FPU type.*mask:.*flags:.*" "info float"
 } else {
     gdb_test "info float" "No floating point info available for this processor." "info float"
 }
index f5c2641226d2af3d70bd786ceb00a5d5d53940ea..638072c2baaf9d865dcc20e26a52269c1b69b9c1 100644 (file)
@@ -49,8 +49,10 @@ gdb_load ${binfile}
 
 # Ok, on to real life
 #
-gdb_test "b main"     ".*Breakpoint 1.*" "break main"
-gdb_test "r"          ".*Breakpoint 1, main.*" "get to main"
+
+if {![runto main]} {
+  fail "Could not run to main - other tests will fail."
+}
 gdb_test "b 14" ".*Breakpoint 2.*" "break do_loops"
 gdb_test "c"          ".*Breakpoint 2, do_loops.*" "get to do_loops"
 
index 6593d824294d28a38d82832d81411bd4c45105e0..f5656d849a2ca095a990a8d512fd011bd2f1d4c5 100644 (file)
@@ -1,4 +1,4 @@
-#   Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+#   Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
 
 
 # This program is free software; you can redistribute it and/or modify
@@ -38,6 +38,30 @@ if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {deb
      gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
 }
 
+proc rerun_to_main {} {
+  global gdb_prompt
+
+  if [target_info exists use_gdb_stub] {
+    gdb_run_cmd
+    gdb_expect {
+      -re ".*Breakpoint .*main .*$gdb_prompt $"\
+             {pass "rerun to main" ; return 0}
+      -re "$gdb_prompt $"\
+             {fail "rerun to main" ; return 0}
+      timeout {fail "(timeout) rerun to main" ; return 0}
+    }
+  } else {
+    send_gdb "run\n"
+    gdb_expect {
+      -re "Starting program.*$gdb_prompt $"\
+             {pass "rerun to main" ; return 0}
+      -re "$gdb_prompt $"\
+             {fail "rerun to main" ; return 0}
+      timeout {fail "(timeout) rerun to main" ; return 0}
+    }
+  }
+}
+
 gdb_exit
 gdb_start
 gdb_reinitialize_dir $srcdir/$subdir
@@ -137,32 +161,9 @@ gdb_expect {
 
 # Verify that we don't stop at a disabled breakpoint.
 #
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*Program exited normally.*$gdb_prompt $"\
-          {pass "no stop"}
-  -re "$gdb_prompt $"\
-          {fail "no stop"}
-  timeout {fail "(timeout) no stop"}
-}
-
-send_gdb "run\n"
-gdb_expect {
-  -re "Starting program.*$gdb_prompt $"\
-          {pass "rerun to main"}
-  -re "$gdb_prompt $"\
-          {fail "rerun to main"}
-  timeout {fail "(timeout) rerun to main"}
-}
-
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*Program exited normally.*$gdb_prompt $"\
-          {pass "no stop at auto-disabled break marker2"}
-  -re "$gdb_prompt $"\
-          {fail "no stop at auto-disabled break marker2"}
-  timeout {fail "(timeout) no stop at auto-disabled break marker2"}
-}
+gdb_continue_to_end "no stop"
+rerun_to_main
+gdb_continue_to_end "no stop at auto-disabled break marker2"
 
 # Verify that we can set a breakpoint to be self-deleting after
 # the first time it triggers.
@@ -321,23 +322,8 @@ gdb_expect {
   timeout {fail "(timeout) info ignored break marker1"}
 }
 
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*Program exited normally.*$gdb_prompt $"\
-          {pass "no stop at ignored break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "no stop at ignored break marker1"}
-  timeout {fail "(timeout) no stop at ignored break marker1"}
-}
-
-send_gdb "run\n"
-gdb_expect {
-  -re "Starting program.*$gdb_prompt $"\
-          {pass "rerun to main"}
-  -re "$gdb_prompt $"\
-          {fail "rerun to main"}
-  timeout {fail "(timeout) rerun to main"}
-}
+gdb_continue_to_end "no stop at ignored break marker1"
+rerun_to_main
 
 send_gdb "continue\n"
 gdb_expect {
@@ -386,23 +372,8 @@ gdb_expect {
   timeout {fail "(timeout) info break marker2"}
 }
 
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*Program exited normally.*$gdb_prompt $"\
-          {pass "no stop at ignored & auto-deleted break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "no stop at ignored & auto-deleted break marker1"}
-  timeout {fail "(timeout) no stop at ignored & auto-deleted break marker1"}
-}
-
-send_gdb "run\n"
-gdb_expect {
-  -re "Starting program.*$gdb_prompt $"\
-          {pass "rerun to main"}
-  -re "$gdb_prompt $"\
-          {fail "rerun to main"}
-  timeout {fail "(timeout) rerun to main"}
-}
+gdb_continue_to_end "no stop at ignored & auto-deleted break marker1"
+rerun_to_main
 
 send_gdb "continue\n"
 gdb_expect {
@@ -445,23 +416,8 @@ gdb_expect {
   timeout {fail "(timeout) disable break marker1"}
 }
 
-send_gdb "continue\n"
-gdb_expect {
-  -re ".*Program exited normally.*$gdb_prompt $"\
-          {pass "no stop at ignored & disabled break marker1"}
-  -re "$gdb_prompt $"\
-          {fail "no stop at ignored & disabled break marker1"}
-  timeout {fail "(timeout) no stop at ignored & disabled break marker1"}
-}
-
-send_gdb "run\n"
-gdb_expect {
-  -re "Starting program.*$gdb_prompt $"\
-          {pass "rerun to main"}
-  -re "$gdb_prompt $"\
-          {fail "rerun to main"}
-  timeout {fail "(timeout) rerun to main"}
-}
+gdb_continue_to_end "no stop at ignored & disabled break marker1"
+rerun_to_main
 
 send_gdb "info break $expect_out(1,string)\n"
 gdb_expect {
index 61b42c7571285e5ff46aa318da3c2852a2cc0c65..da78e3be98e0ab238c3039c05c792dea7509ba74 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+# Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -61,7 +61,11 @@ gdb_test "b 26" ".*Breakpoint.*3.*" ""
 # Expect to hit the bp at line "1", but symbolize this
 # as line "8".  Then try to clear it--this should work.
 #
-gdb_test "r" ".*Breakpoint.*1.*callee.*8.*" ""
+if [target_info exists use_gdb_stub] {
+  gdb_test "continue" ".*Breakpoint.*1.*callee.*8.*" ""
+} else {
+  gdb_test "r" ".*Breakpoint.*1.*callee.*8.*" ""
+}
 gdb_test "cle" ".*Deleted breakpoints 2 1.*" "clear worked"
 send_gdb "i b\n"
 gdb_expect {
@@ -147,24 +151,30 @@ gdb_expect {
     -re ".*in.*start.*$gdb_prompt $" { 
         pass "step out of main"
     }
+  -re ".*Program received signal SIGTRAP.*$gdb_prompt $" {
+        pass "Cygmon stopped in ending trap."
+  }
     timeout { fail "hang or timeout on step at end 1" }
 }
 
-gdb_test "n" ".*Single.*Program exited.*" "step to end of run"
-set timeout $old_timeout
-
-gdb_test "n" ".*The program is not being run.*" "don't step after run"
-
-set exec_output [remote_exec host "ls core"]
-
-if [ regexp "core not found" $exec_output]  {
+if {![target_info exists use_cygmon] || ![target_info use_cygmon]} {
+  gdb_test "n" ".*Single.*Program exited.*" "step to end of run"
+  set timeout $old_timeout
+  
+  gdb_test "n" ".*The program is not being run.*" "don't step after run"
+  
+  set exec_output [remote_exec host "ls core"]
+  
+  
+  if [ regexp "core not found" $exec_output]  {
     pass "No core dumped on quit"
-} else {
-  if [ regexp "No such file or directory" $exec_output] {
-      pass "ls: core: No core dumped on quit"
   } else {
+    if [ regexp "No such file or directory" $exec_output] {
+      pass "ls: core: No core dumped on quit"
+    } else {
       remote_exec build "rm -f core"
       fail "Core dumped on quit"
+    }
   }
 }
 
index cae23d8cf33f647067f4916edb8eb8a8b7cab1ab..41bd29f6485f6db0ee3f645d7ac26ff3ff073f6d 100644 (file)
-void marker1 ()
+void
+marker1 ()
 {
-    
+   
 }
-/*
-static struct {
-    char c[100];
-} cbig;
-
-
-static struct {
-    int i[800];
-} ibig;
-
-
-static struct {
-    long l[900];
-} lbig;
-
-static struct {
-    float f[200];
-} fbig;
-
-static struct {
-    double d[300];
-} dbig;
-
-static struct {
-    short s[400];
-} sbig;*/
 
-/*struct {
-    long l[900];
-} lbig;*/
-
-int main()
+int
+main ()
 {
-
-struct {
+  struct {
     char c[100];
-} cbig;
-
+  } cbig;
 
-struct {
+  struct {
     int i[800];
-} ibig;
+  } ibig;
 
-
-struct {
+  struct {
     long l[900];
-} lbig;
+  } lbig;
 
-struct {
+  struct {
     float f[200];
-} fbig;
+  } fbig;
 
-struct {
+  struct {
     double d[300];
-} dbig;
+  } dbig;
 
-struct {
+  struct {
     short s[400];
-} sbig; 
-    ibig.i[100] = 5;
-    cbig.c[100] = 'A';
-    fbig.f[100] = 11.99999;
-    dbig.d[202] = 9.99999999;
-    sbig.s[90] = 255;
-    lbig.l[333] = 999999999;
+  } sbig;
+
+  ibig.i[100] = 5;
+  cbig.c[0] = '\0';
+  cbig.c[100] = 'A';
+  fbig.f[100] = 11.99999;
+  dbig.d[202] = 9.99999999;
+  sbig.s[90] = 255;
+  lbig.l[333] = 999999999;
     
-    #ifdef usestubs
-       set_debug_traps();
-       breakpoint();
-    #endif
-    marker1();
-    return 0;
+#ifdef usestubs
+  set_debug_traps ();
+  breakpoint ();
+#endif
 
+  marker1 ();
+  return 0;
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
index 9ea278a570fc8d69b8d57f27a2fa5d5bbf535ba7..d42e5abbfbb02e2fe0bab5e6bc82bf5d12570d2d 100644 (file)
@@ -114,18 +114,24 @@ gdb_expect {
 
 send_gdb "print &sbig.s\[0\]\n"
 gdb_expect {
+    -re ".\[0-9\]* = \\(short \\*\\) $hex.*$gdb_prompt $" {
+        pass "print value of &sbig.s\[0\]"
+    }
     -re ".\[0-9\]* = \\(short int \\*\\) $hex.*$gdb_prompt $" {
         pass "print value of &sbig.s\[0\]"
-      }
+    }
     -re ".*$gdb_prompt $" { fail "print value of &sbig.s\[0\]" }
     timeout           { fail "(timeout) print value of &sbig.s\[0\]" }
   }
 
 send_gdb "print &lbig.l\[0\]\n"
 gdb_expect {
+    -re ".\[0-9\]* = \\(long \\*\\) $hex.*$gdb_prompt $" {
+        pass "print value of &lbig.l\[0\]"
+    }
     -re ".\[0-9\]* = \\(long int \\*\\) $hex.*$gdb_prompt $" {
         pass "print value of &lbig.l\[0\]"
-      }
+    }
     -re ".*$gdb_prompt $" { fail "print value of &lbig.l\[0\]" }
     timeout           { fail "(timeout) print value of &lbig.l\[0\]" }
   }
index 765e0ee5df91b6b7851da74aee84778cd0ca81f6..75599789c7857c80ceb0e1e798914913787d5567 100644 (file)
@@ -205,6 +205,6 @@ gdb_test "continue" \
     "Continuing.*Program received signal SIGTERM.*" \
     "get signal TERM"
 gdb_test "continue" "Breakpoint.*handle_TERM.*" "send signal TERM"
-gdb_test "continue" "Program exited normally\\." "continue to sigall exit"
+gdb_continue_to_end "continue to sigall exit"
 
 return 0
index 49bf49081b042abb30ca5537cee13fbb8cc8df79..16528f731d3626923ecfa415de9af3f624a7b0da 100644 (file)
@@ -336,7 +336,9 @@ proc test_handle_all_print {} {
     set oldtimeout $timeout
     set timeout [expr "$timeout + 360"]
     verbose "Timeout is now $timeout seconds" 2
-    if { [istarget "*-*-gnu*"] || [istarget "*-*-mach*"] } {
+    if { ![istarget "*-*-linux*"]
+         && ( [istarget "*-*-gnu*"]
+              || [istarget "*-*-mach*"] ) } {
        gdb_test "handle all print" "Signal\[   \]+Stop\[       \]+Print\[      \]+Pass to program\[    \]+Description\r\nSIGHUP\[      \]+Yes\[        \]+Yes\[        \]+Yes\[        \]+Hangup.*SIG63\[      \]+Yes\[        \]+Yes\[        \]+Yes\[        \]+Real-time event 63.*EXC_BREAKPOINT\[         \]+Yes\[        \]+Yes\[        \]+Yes\[        \]+Breakpoint"
     } else {
        gdb_test "handle all print" "Signal\[   \]+Stop\[       \]+Print\[      \]+Pass to program\[    \]+Description\r\nSIGHUP\[      \]+Yes\[        \]+Yes\[        \]+Yes\[        \]+Hangup.*SIG63\[      \]+Yes\[        \]+Yes\[        \]+Yes\[        \]+Real-time event 63"
index 42de7c891f15f0c7ed7e1797af170e2a895c9fa9..af107e05abd08f539754e446fc15077e2872088d 100644 (file)
@@ -58,7 +58,7 @@ gdb_test "r" ".*Starting program.*main.*15.*"   "hit bp"
 gdb_test "hel r" ".*Start debugged program.*without arguments.*" "help"
 gdb_test "n" ".*x = 1;.*" "next"
 gdb_test "s" ".*y = 2;.*" "step"
-gdb_test "p/t y" ".* = 1.*" "print y in binary"
+gdb_test "p/t x" ".* = 1.*" "print x in binary"
 gdb_test "p 1+2*3+4" ".* = 11.*" "calculate"
 gdb_test "p/t 1+2*3+4" ".* = 1011.*" "binary"
 
index 415714d81e408237533bab8954729e0fa58511b0..85744d73865be7733c3a7acee5dfcf1055c67310 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+# Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -46,6 +46,9 @@ if ![runto_main] then {
    return 0
 }
 
+# Set a breakpoint at line 45, if stepi then finish fails, we would
+# run to the end of the program, which would mess up the rest of the tests.
+  
 # Vanilla step/next
 #
 gdb_test "next" ".*${decimal}.*x = 1;.*" "next 1"
@@ -127,8 +130,41 @@ test_i "stepi to next line" "stepi" \
        ".*${decimal}.*callee.*STEPI"
 test_i "stepi into function" "stepi" \
        ".*${decimal}.*callee.*STEPI" \
-       ".*callee \\(\\) at .*step-test\\.c"
-gdb_test "finish"  ".*${decimal}.*callee.*NEXTI.*" "stepi: finish call"
+       ".*callee \\(\\) at .*step-test\\.c" 
+# Have to be careful here, if the finish does not work, 
+# then we may run to the end of the program, which
+# will cause erroneous failures in the rest of the tests
+
+send_gdb "finish\n"
+gdb_expect {
+  -re ".*(Program received|Program exited).*$gdb_prompt $" {
+    puts "*** Matched Program recieved"
+    # Oops... We ran to the end of the program...  Better reset     
+    if {![runto_main]} then {
+      fail "Can't run to main"
+      return 0
+    }
+    if {![runto step-test.c:45]} {
+      fail "Can't run to line 45"
+      return 0
+    }
+    fail "stepi: finish call"
+  }
+  -re ".*${decimal}.*callee.*NEXTI.*$gdb_prompt $" {
+    puts "*** Matched success..."
+    pass "stepi: finish call"
+  }
+  -re "$gdb_prompt $" {
+    # We got something else.  Fail.
+    fail "stepi: finish call"
+    return
+  }
+  timeout {
+    fail "stepi: finish call"
+    return
+  }
+}
+
 test_i "nexti over function" "nexti" \
        ".*${decimal}.*callee.*NEXTI" \
        ".*${decimal}.*y = w \\+ z;"
@@ -148,6 +184,6 @@ gdb_test "step" \
          ".*step-test.exp: arrive here 1.*" \
          "large struct by value"
 
-gdb_test "continue" ".*Program exited normally.*" "run to finish"
+gdb_continue_to_end "step-test.exp"
 
 return 0
index a2954452cd123a556f3cfd674f2742a2a01cdc8a..53f2e8b03a07a92c2ec4a9474b8473e85873c188 100644 (file)
@@ -209,8 +209,7 @@ Continuing.*\[Ww\]atchpoint.*ival3.*Old value = -1.*New value = 0.*ival3 = count
 
     if [target_info exists gdb,noresults] { return }
 
-    gdb_test "cont" "Continuing.*Program exited normally.*" \
-       "continue to exit in test_simple_watchpoint"
+    gdb_continue_to_end "continue to exit in test_simple_watchpoint"
 }
 
 # Test disabling watchpoints.
@@ -280,8 +279,7 @@ proc test_disabling_watchpoints {} {
     
     if [target_info exists gdb,noresults] { return }
 
-    gdb_test "cont" "Continuing.*Program exited normally.*" \
-       "continue to exit in test_disabling_watchpoints"
+    gdb_continue_to_end "continue to exit in test_disabling_watchpoints"
 }
 
 # Test stepping and other mundane operations with watchpoints enabled
@@ -475,8 +473,7 @@ proc test_watchpoint_triggered_in_syscall {} {
 
        if [target_info exists gdb,noresults] { return }
 
-       gdb_test "cont" "Continuing.*Program exited normally.*" \
-           "continue to exit in test_watchpoint_triggered_in_syscall"
+       gdb_continue_to_end "continue to exit in test_watchpoint_triggered_in_syscall"
     }
 }
 
@@ -504,8 +501,7 @@ proc test_complex_watchpoint {} {
        if [target_info exists gdb,noresults] { return }
 
 
-       gdb_test "cont" "Continuing.*Program exited normally.*" \
-           "continue to exit in test_complex_watchpoint"
+        gdb_continue_to_end "continue to exit in test_complex_watchpoint"
     }
 }
 
index 5e97cb4eb4caa95c6a5931bc257e96b4165410e1..05a6cde088f262bf6e937f0c26739bb717ac9ca4 100644 (file)
@@ -774,15 +774,15 @@ do_tests
 
 
 # set a breakpoint and go there
-send_gdb "break 498\n"   
+send_gdb "break 503\n"   
 gdb_expect {   
-   -re "Breakpoint \[0-9\] at.*$gdb_prompt $" { pass "set break 498" }
-   -re "$gdb_prompt $"                     { fail "set break 498" }
-   timeout                             { fail "(timeout) set break 498" }
+   -re "Breakpoint \[0-9\] at.*$gdb_prompt $" { pass "set break 503" }
+   -re "$gdb_prompt $"                     { fail "set break 503" }
+   timeout                             { fail "(timeout) set break 503" }
 }
 send_gdb "continue\n"   
 gdb_expect {   
-   -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, main....at.*misc\\.cc:498\r\n498.*\r\n$gdb_prompt $" { pass "continue" }
+   -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, main....at.*misc\\.cc:503\r\n503.*\r\n$gdb_prompt $" { pass "continue" }
    -re "$gdb_prompt $"                     { fail "continue" }
    timeout                             { fail "(timeout) continue" }
 }
@@ -818,9 +818,12 @@ gdb_expect {
 }
 
 # ptype on the enum member
+# The second success case is a little dubious, but it's not clear what
+# ought to be required of a ptype on a private enum... -sts 19990324
 send_gdb "ptype obj_with_enum.priv_enum\n"   
 gdb_expect {   
    -re "type = enum ClassWithEnum::PrivEnum \\{red, green, blue, yellow = 42\\}.*$gdb_prompt $" { pass "ptype obj_with_enum.priv_enum" }
+   -re "type = enum \\{red, green, blue, yellow = 42\\}.*$gdb_prompt $" { pass "ptype obj_with_enum.priv_enum" }
    -re "$gdb_prompt $"                     { fail "ptype obj_with_enum.priv_enum" }
    timeout                             { fail "(timeout) ptype obj_with_enum.priv_enum" }
 }
index fd1d344adcdedaa7428af3c916918afa3d591dea..7f9f17464982d479f9ca53bc78a48c48219ad16d 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (C) 1992, 1997 Free Software Foundation, Inc.
+# Copyright (C) 1992, 1997, 1999 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # This file was written by Fred Fish. (fnf@cygnus.com)
 
 if $tracelevel then {
-       strace $tracelevel
+    strace $tracelevel
 }
 
-#
-#  Test gnu style name demangling
-#
+### The demangling style we last sent to GDB.
+set current_demangling_style none
 
-proc test_gnu_style_demangling {} {
+### Set GDB's current demangling style to STYLE.  Subsequent calls to
+### test_demangle will include STYLE in the test name when reporting
+### passes and failures.
+proc set_demangling_style {style} {
     global gdb_prompt
+    global current_demangling_style
 
-    # Set the demangling style to "gnu" and then check to make sure
-    # it really got set.  Return if the style failed to get set for
-    # some reason.
-
-    send_gdb "set demangle-style gnu\n"
+    send_gdb "set demangle-style $style\n"
     gdb_expect {
-       -re "set demangle-style gnu\[\r\n\]+$gdb_prompt $" {}
-       -re ".*$gdb_prompt $" { fail "set demangle-style gnu failed" ; return }
-       timeout { fail "set demangle-style gnu failed (timeout)" ; return }
+       -re "set demangle-style $style\[\r\n\]+$gdb_prompt $" {
+           pass "$style: set demangle-style"
+       }
+       -re ".*$gdb_prompt $" {
+           fail "$style: set demangle-style"
+           error "set_demangling_style: set style"
+       }
+       timeout { 
+           fail "$style: set demangle-style (timeout)"
+           error "set_demangling_style: set style"
+       }
     }
 
     send_gdb "show demangle-style\n"
     gdb_expect {
-       -re "The current C\[+\]+ demangling style is \"gnu\".\r\n$gdb_prompt $" {}
-       -re ".*$gdb_prompt $" { fail "demangling style not set to gnu" }
-       timeout { fail "show demangle-style timed out" }
+       -re "The current C\[+\]+ demangling style is \"$style\".\r\n$gdb_prompt $" { 
+           pass "$style: check demangling style"
+       }
+       -re ".*$gdb_prompt $" {
+           fail "gnu: check demangling style"
+           error "set_demangling_style: check style"
+       }
+       timeout { 
+           fail "gnu: check demangling style (timeout)" 
+           error "set_demangling_style: check style"
+       }
     }
 
-    gdb_test "maint dem Abort__FP6EditoriPCc" \
+    set current_demangling_style $style
+}
+
+
+### Utility function for test_demangling and test_demangling_exact.
+proc test_demangling_core {tester test result} {
+    global current_demangling_style
+
+    if {! [regexp {^([^ ]+): (.+)$} $test dummy style name]} {
+      error "bad test name passed to test_demangling"
+    }
+
+    if {[string compare $style $current_demangling_style]} {
+       set_demangling_style $style
+    }
+
+    $tester "maintenance demangle $name" $result $test
+}
+
+### Demangle an identifier, and check that the result matches a pattern.
+###
+### TEST should be of the form "STYLE: NAME", where STYLE is the name
+### of a demangling style (like "gnu" or "arm"), and NAME is a mangled
+### identifier to demangle.  Pass when the result matches the regular
+### expression RESULT.  Report passes and fails using TEST as the name
+### of the test.
+###
+### Why don't we just pass the STYLE and NAME as two separate
+### arguments, or let the style be a global variable?  That would be
+### cleaner.  However, doing it this way means that:
+### 
+### 1) the name of the test, as recorded in the summary and log,
+### appears verbatim in the script, and
+### 
+### 2) that test names are unique, even though we try to demangle the same
+### identifiers using several different mangling styles.
+### 
+### This makes it a lot easier for people tracking down failures to
+### find the one they care about.
+
+proc test_demangling {test result} {
+    test_demangling_core gdb_test $test $result
+}
+
+### Like test_demangling, above, except that RESULT is not a regexp,
+### but a string that must match exactly.
+
+proc test_demangling_exact {test result} {
+    test_demangling_core gdb_test_exact $test $result
+}
+
+
+
+#
+#  Test gnu style name demangling
+#
+
+proc test_gnu_style_demangling {} {
+    test_demangling "gnu: Abort__FP6EditoriPCc" \
        "Abort\[(\]+Editor \[*\]+, int, (const char|char const) \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle AddAlignment__9ivTSolverUiP12ivInteractorP7ivTGlue" "ivTSolver::AddAlignment(unsigned int, ivInteractor *, ivTGlue *)"
-    gdb_test "maint dem Append__15NameChooserViewPCc" \
+    test_demangling_exact "gnu: AddAlignment__9ivTSolverUiP12ivInteractorP7ivTGlue" "ivTSolver::AddAlignment(unsigned int, ivInteractor *, ivTGlue *)"
+    test_demangling "gnu: Append__15NameChooserViewPCc" \
        "NameChooserView::Append\[(\]+(const char|char const) \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle ArrowheadIntersects__9ArrowLineP9ArrowheadR6BoxObjP7Graphic" "ArrowLine::ArrowheadIntersects(Arrowhead *, BoxObj &, Graphic *)"
-    gdb_test_exact "maint demangle AtEnd__13ivRubberGroup" "ivRubberGroup::AtEnd(void)"
-    gdb_test_exact "maint demangle BgFilter__9ivTSolverP12ivInteractor" "ivTSolver::BgFilter(ivInteractor *)"
-    gdb_test "maint dem BitPatterntoa__FRC10BitPatternccc" \
+    test_demangling_exact "gnu: ArrowheadIntersects__9ArrowLineP9ArrowheadR6BoxObjP7Graphic" "ArrowLine::ArrowheadIntersects(Arrowhead *, BoxObj &, Graphic *)"
+    test_demangling_exact "gnu: AtEnd__13ivRubberGroup" "ivRubberGroup::AtEnd(void)"
+    test_demangling_exact "gnu: BgFilter__9ivTSolverP12ivInteractor" "ivTSolver::BgFilter(ivInteractor *)"
+    test_demangling "gnu: BitPatterntoa__FRC10BitPatternccc" \
        "BitPatterntoa\[(\]+(const BitPattern|BitPattern const) &, char, char, char\[)\]+"
-    gdb_test_exact "maint demangle Check__6UArrayi" "UArray::Check(int)"
-    gdb_test_exact "maint demangle CoreConstDecls__8TextCodeR7ostream" "TextCode::CoreConstDecls(ostream &)"
-    gdb_test_exact "maint demangle Detach__8StateVarP12StateVarView" "StateVar::Detach(StateVarView *)"
-    gdb_test_exact "maint demangle Done__9ComponentG8Iterator" "Component::Done(Iterator)"
-    gdb_test "maint dem DrawDestinationTransformedImage__FP7_XImageiiT0iiUlUiiiUiUlUlP4_XGCRC13ivTransformeriiii" \
+    test_demangling_exact "gnu: Check__6UArrayi" "UArray::Check(int)"
+    test_demangling_exact "gnu: CoreConstDecls__8TextCodeR7ostream" "TextCode::CoreConstDecls(ostream &)"
+    test_demangling_exact "gnu: Detach__8StateVarP12StateVarView" "StateVar::Detach(StateVarView *)"
+    test_demangling_exact "gnu: Done__9ComponentG8Iterator" "Component::Done(Iterator)"
+    test_demangling "gnu: DrawDestinationTransformedImage__FP7_XImageiiT0iiUlUiiiUiUlUlP4_XGCRC13ivTransformeriiii" \
        "DrawDestinationTransformedImage\[(\]+_XImage \[*\]+, int, int, _XImage \[*\]+, int, int, unsigned long, unsigned int, int, int, unsigned int, unsigned long, unsigned long, _XGC \[*\]+, (const ivTransformer|ivTransformer const) &, int, int, int, int\[)\]+"
 
-    gdb_test "maint dem Edit__12StringEditorPCcii" \
+    test_demangling "gnu: Edit__12StringEditorPCcii" \
        "StringEditor::Edit\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-    gdb_test_exact "maint demangle Effect__11RelateManipR7ivEvent" "RelateManip::Effect(ivEvent &)"
-    gdb_test "maint dem FilterName__FPCc" \
+    test_demangling_exact "gnu: Effect__11RelateManipR7ivEvent" "RelateManip::Effect(ivEvent &)"
+    test_demangling "gnu: FilterName__FPCc" \
        "FilterName\[(\]+(const char|char const) \[*\]+\[)\]+"
-    gdb_test "maint dem Filter__6PSTextPCci" \
+    test_demangling "gnu: Filter__6PSTextPCci" \
        "PSText::Filter\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-    gdb_test "maint dem FindColor__7CatalogPCciii" \
+    test_demangling "gnu: FindColor__7CatalogPCciii" \
        "Catalog::FindColor\[(\]+(const char|char const) \[*\]+, int, int, int\[)\]+"
-    gdb_test_exact "maint demangle FindFixed__FRP4CNetP4CNet" "FindFixed(CNet *&, CNet *)"
-    gdb_test "maint dem FindFont__7CatalogPCcN21" \
+    test_demangling_exact "gnu: FindFixed__FRP4CNetP4CNet" "FindFixed(CNet *&, CNet *)"
+    test_demangling "gnu: FindFont__7CatalogPCcN21" \
        "Catalog::FindFont\[(\]+(const char|char const) \[*\]+, (const char|char const) \[*\]+, (const char|char const) \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle Fix48_abort__FR8twolongs" "Fix48_abort(twolongs &)"
-    gdb_test_exact "maint demangle GetBarInfo__15iv2_6_VScrollerP13ivPerspectiveRiT2" "iv2_6_VScroller::GetBarInfo(ivPerspective *, int &, int &)"
-    gdb_test_exact "maint demangle GetBgColor__C9ivPainter" "ivPainter::GetBgColor(void) const"
+    test_demangling_exact "gnu: Fix48_abort__FR8twolongs" "Fix48_abort(twolongs &)"
+    test_demangling_exact "gnu: GetBarInfo__15iv2_6_VScrollerP13ivPerspectiveRiT2" "iv2_6_VScroller::GetBarInfo(ivPerspective *, int &, int &)"
+    test_demangling_exact "gnu: GetBgColor__C9ivPainter" "ivPainter::GetBgColor(void) const"
 
-    gdb_test "maint dem Iisdouble__FPC6IntRep" \
+    test_demangling "gnu: Iisdouble__FPC6IntRep" \
        "Iisdouble\[(\]+(const IntRep|IntRep const) \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle InsertBody__15H_PullrightMenuii" "H_PullrightMenu::InsertBody(int, int)"
-    gdb_test_exact "maint demangle InsertCharacter__9TextManipc" "TextManip::InsertCharacter(char)"
+    test_demangling_exact "gnu: InsertBody__15H_PullrightMenuii" "H_PullrightMenu::InsertBody(int, int)"
+    test_demangling_exact "gnu: InsertCharacter__9TextManipc" "TextManip::InsertCharacter(char)"
 
-    gdb_test_exact "maint demangle InsertToplevel__7ivWorldP12ivInteractorT1" "ivWorld::InsertToplevel(ivInteractor *, ivInteractor *)"
-    gdb_test_exact "maint demangle InsertToplevel__7ivWorldP12ivInteractorT1iiUi" "ivWorld::InsertToplevel(ivInteractor *, ivInteractor *, int, int, unsigned int)"
-    gdb_test "maint dem IsADirectory__FPCcR4stat" \
+    test_demangling_exact "gnu: InsertToplevel__7ivWorldP12ivInteractorT1" "ivWorld::InsertToplevel(ivInteractor *, ivInteractor *)"
+    test_demangling_exact "gnu: InsertToplevel__7ivWorldP12ivInteractorT1iiUi" "ivWorld::InsertToplevel(ivInteractor *, ivInteractor *, int, int, unsigned int)"
+    test_demangling "gnu: IsADirectory__FPCcR4stat" \
        "IsADirectory\[(\]+(const char|char const) \[*\]+, stat &\[)\]+"
-    gdb_test_exact "maint demangle IsAGroup__FP11GraphicViewP11GraphicComp" "IsAGroup(GraphicView *, GraphicComp *)"
-    gdb_test_exact "maint demangle IsA__10ButtonCodeUl" "ButtonCode::IsA(unsigned long)"
-
-    gdb_test_exact "maint demangle ReadName__FR7istreamPc" "ReadName(istream &, char *)"
-    gdb_test_exact "maint demangle Redraw__13StringBrowseriiii" "StringBrowser::Redraw(int, int, int, int)"
-    gdb_test_exact "maint demangle Rotate__13ivTransformerf" "ivTransformer::Rotate(float)"
-    gdb_test_exact "maint demangle Rotated__C13ivTransformerf" "ivTransformer::Rotated(float) const"
-    gdb_test_exact "maint demangle Round__Ff" "Round(float)"
-
-    gdb_test_exact "maint demangle SetExport__16MemberSharedNameUi" "MemberSharedName::SetExport(unsigned int)"
-    gdb_test_exact "maint demangle Set__14ivControlState13ControlStatusUi" "ivControlState::Set(ControlStatus, unsigned int)"
-    gdb_test_exact "maint demangle Set__5DFacePcii" "DFace::Set(char *, int, int)"
-
-    gdb_test_exact "maint demangle VConvert__9ivTSolverP12ivInteractorRP8TElementT2" "ivTSolver::VConvert(ivInteractor *, TElement *&, TElement *&)"
-    gdb_test_exact "maint demangle VConvert__9ivTSolverP7ivTGlueRP8TElement" "ivTSolver::VConvert(ivTGlue *, TElement *&)"
-    gdb_test_exact "maint demangle VOrder__9ivTSolverUiRP12ivInteractorT2" "ivTSolver::VOrder(unsigned int, ivInteractor *&, ivInteractor *&)"
-    gdb_test "maint dem Valid__7CatalogPCcRP4Tool" \
+    test_demangling_exact "gnu: IsAGroup__FP11GraphicViewP11GraphicComp" "IsAGroup(GraphicView *, GraphicComp *)"
+    test_demangling_exact "gnu: IsA__10ButtonCodeUl" "ButtonCode::IsA(unsigned long)"
+
+    test_demangling_exact "gnu: ReadName__FR7istreamPc" "ReadName(istream &, char *)"
+    test_demangling_exact "gnu: Redraw__13StringBrowseriiii" "StringBrowser::Redraw(int, int, int, int)"
+    test_demangling_exact "gnu: Rotate__13ivTransformerf" "ivTransformer::Rotate(float)"
+    test_demangling_exact "gnu: Rotated__C13ivTransformerf" "ivTransformer::Rotated(float) const"
+    test_demangling_exact "gnu: Round__Ff" "Round(float)"
+
+    test_demangling_exact "gnu: SetExport__16MemberSharedNameUi" "MemberSharedName::SetExport(unsigned int)"
+    test_demangling_exact "gnu: Set__14ivControlState13ControlStatusUi" "ivControlState::Set(ControlStatus, unsigned int)"
+    test_demangling_exact "gnu: Set__5DFacePcii" "DFace::Set(char *, int, int)"
+
+    test_demangling_exact "gnu: VConvert__9ivTSolverP12ivInteractorRP8TElementT2" "ivTSolver::VConvert(ivInteractor *, TElement *&, TElement *&)"
+    test_demangling_exact "gnu: VConvert__9ivTSolverP7ivTGlueRP8TElement" "ivTSolver::VConvert(ivTGlue *, TElement *&)"
+    test_demangling_exact "gnu: VOrder__9ivTSolverUiRP12ivInteractorT2" "ivTSolver::VOrder(unsigned int, ivInteractor *&, ivInteractor *&)"
+    test_demangling "gnu: Valid__7CatalogPCcRP4Tool" \
        "Catalog::Valid\[(\]+(const char|char const) \[*\]+, Tool \[*\]+&\[)\]+"
-    gdb_test_exact "maint demangle _10PageButton\$__both" "PageButton::__both"
-    gdb_test_exact "maint demangle _3RNG\$singleMantissa" "RNG::singleMantissa"
-    gdb_test_exact "maint demangle _5IComp\$_release" "IComp::_release"
-    gdb_test_exact "maint demangle _\$_10BitmapComp" "BitmapComp::~BitmapComp(void)"
-
-    gdb_test_exact "maint demangle _\$_9__io_defs" "__io_defs::~__io_defs(void)"
-    gdb_test_exact "maint demangle _\$_Q23foo3bar" "foo::bar::~bar(void)"
-    gdb_test_exact "maint demangle _\$_Q33foo3bar4bell" "foo::bar::bell::~bell(void)"
-    gdb_test_exact "maint demangle __10ivTelltaleiP7ivGlyph" "ivTelltale::ivTelltale(int, ivGlyph *)"
-    gdb_test_exact "maint demangle __10ivViewportiP12ivInteractorUi" "ivViewport::ivViewport(int, ivInteractor *, unsigned int)"
-    gdb_test_exact "maint demangle __10ostrstream" "ostrstream::ostrstream(void)"
-    gdb_test_exact "maint demangle __10ostrstreamPcii" "ostrstream::ostrstream(char *, int, int)"
-    gdb_test "maint dem __11BasicDialogiPCcP13ivButtonStateN22Ui" \
+    test_demangling_exact "gnu: _10PageButton\$__both" "PageButton::__both"
+    test_demangling_exact "gnu: _3RNG\$singleMantissa" "RNG::singleMantissa"
+    test_demangling_exact "gnu: _5IComp\$_release" "IComp::_release"
+    test_demangling_exact "gnu: _\$_10BitmapComp" "BitmapComp::~BitmapComp(void)"
+
+    test_demangling_exact "gnu: _\$_9__io_defs" "__io_defs::~__io_defs(void)"
+    test_demangling_exact "gnu: _\$_Q23foo3bar" "foo::bar::~bar(void)"
+    test_demangling_exact "gnu: _\$_Q33foo3bar4bell" "foo::bar::bell::~bell(void)"
+    test_demangling_exact "gnu: __10ivTelltaleiP7ivGlyph" "ivTelltale::ivTelltale(int, ivGlyph *)"
+    test_demangling_exact "gnu: __10ivViewportiP12ivInteractorUi" "ivViewport::ivViewport(int, ivInteractor *, unsigned int)"
+    test_demangling_exact "gnu: __10ostrstream" "ostrstream::ostrstream(void)"
+    test_demangling_exact "gnu: __10ostrstreamPcii" "ostrstream::ostrstream(char *, int, int)"
+    test_demangling "gnu: __11BasicDialogiPCcP13ivButtonStateN22Ui" \
        "BasicDialog::BasicDialog\[(\]+int, (const char|char const) \[*\]+, ivButtonState \[*\]+, (const char|char const) \[*\]+, (const char|char const) \[*\]+, unsigned int\[)\]+"
-    gdb_test_exact "maint demangle __11BitmapTablei" "BitmapTable::BitmapTable(int)"
-    gdb_test_exact "maint demangle __12ViewportCodeP12ViewportComp" "ViewportCode::ViewportCode(ViewportComp *)"
-    gdb_test "maint dem __12iv2_6_BorderiPCci" \
+    test_demangling_exact "gnu: __11BitmapTablei" "BitmapTable::BitmapTable(int)"
+    test_demangling_exact "gnu: __12ViewportCodeP12ViewportComp" "ViewportCode::ViewportCode(ViewportComp *)"
+    test_demangling "gnu: __12iv2_6_BorderiPCci" \
        "iv2_6_Border::iv2_6_Border\[(\]+int, (const char|char const) \[*\]+, int\[)\]+"
-    gdb_test_exact "maint demangle __12iv2_6_Borderii" "iv2_6_Border::iv2_6_Border(int, int)"
-    gdb_test "maint dem __12ivBackgroundiP7ivGlyphPC7ivColor" \
+    test_demangling_exact "gnu: __12iv2_6_Borderii" "iv2_6_Border::iv2_6_Border(int, int)"
+    test_demangling "gnu: __12ivBackgroundiP7ivGlyphPC7ivColor" \
        "ivBackground::ivBackground\[(\]+int, ivGlyph \[*\]+, (const ivColor|ivColor const) \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle __12ivBreak_Listl" "ivBreak_List::ivBreak_List(long)"
-    gdb_test "maint dem __14TextInteractoriPCcUi" \
+    test_demangling_exact "gnu: __12ivBreak_Listl" "ivBreak_List::ivBreak_List(long)"
+    test_demangling "gnu: __14TextInteractoriPCcUi" \
        "TextInteractor::TextInteractor\[(\]+int, (const char|char const) \[*\]+, unsigned int\[)\]+"
-    gdb_test_exact "maint demangle __14iv2_6_MenuItemiP12ivInteractor" "iv2_6_MenuItem::iv2_6_MenuItem(int, ivInteractor *)"
-    gdb_test "maint dem __14iv2_6_MenuItemiPCcP12ivInteractor" \
+    test_demangling_exact "gnu: __14iv2_6_MenuItemiP12ivInteractor" "iv2_6_MenuItem::iv2_6_MenuItem(int, ivInteractor *)"
+    test_demangling "gnu: __14iv2_6_MenuItemiPCcP12ivInteractor" \
        "iv2_6_MenuItem::iv2_6_MenuItem\[(\]+int, (const char|char const) \[*\]+, ivInteractor \[*\]+\[)\]+"
 
-    gdb_test_exact "maint demangle __20DisplayList_IteratorR11DisplayList" "DisplayList_Iterator::DisplayList_Iterator(DisplayList &)"
-    gdb_test_exact "maint demangle __3fooRT0" "foo::foo(foo &)"
-    gdb_test_exact "maint demangle __3fooiN31" "foo::foo(int, int, int, int)"
-    gdb_test "maint dem __3fooiPCc" \
+    test_demangling_exact "gnu: __20DisplayList_IteratorR11DisplayList" "DisplayList_Iterator::DisplayList_Iterator(DisplayList &)"
+    test_demangling_exact "gnu: __3fooRT0" "foo::foo(foo &)"
+    test_demangling_exact "gnu: __3fooiN31" "foo::foo(int, int, int, int)"
+    test_demangling "gnu: __3fooiPCc" \
        "foo::foo\[(\]+int, (const char|char const) \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle __3fooiRT0iT2iT2" "foo::foo(int, foo &, int, foo &, int, foo &)"
-    gdb_test "maint dem __6GetOptiPPcPCc" \
+    test_demangling_exact "gnu: __3fooiRT0iT2iT2" "foo::foo(int, foo &, int, foo &, int, foo &)"
+    test_demangling "gnu: __6GetOptiPPcPCc" \
        "GetOpt::GetOpt\[(\]+int, char \[*\]+\[*\]+, (const char|char const) \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle __6KeyMapPT0" "KeyMap::KeyMap(KeyMap *)"
-    gdb_test "maint dem __7ivWorldPCcRiPPcPC12ivOptionDescPC14ivPropertyData" \
+    test_demangling_exact "gnu: __6KeyMapPT0" "KeyMap::KeyMap(KeyMap *)"
+    test_demangling "gnu: __7ivWorldPCcRiPPcPC12ivOptionDescPC14ivPropertyData" \
        "ivWorld::ivWorld\[(\]+(const char|char const) \[*\]+, int &, char \[*\]+\[*\]+, (const ivOptionDesc|ivOptionDesc const) \[*\]+, (const ivPropertyData|ivPropertyData const) \[*\]+\[)\]+"
-    gdb_test "maint dem __7procbufPCci" \
+    test_demangling "gnu: __7procbufPCci" \
        "procbuf::procbuf\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-    gdb_test_exact "maint demangle __8ArrowCmdP6EditorUiUi" "ArrowCmd::ArrowCmd(Editor *, unsigned int, unsigned int)"
-
-    gdb_test_exact "maint demangle __9F_EllipseiiiiP7Graphic" "F_Ellipse::F_Ellipse(int, int, int, int, Graphic *)"
-    gdb_test_exact "maint demangle __9FrameDataP9FrameCompi" "FrameData::FrameData(FrameComp *, int)"
-    gdb_test_exact "maint demangle __9HVGraphicP9CanvasVarP7Graphic" "HVGraphic::HVGraphic(CanvasVar *, Graphic *)"
-    gdb_test_exact "maint demangle __Q23foo3bar" "foo::bar::bar(void)"
-    gdb_test_exact "maint demangle __Q33foo3bar4bell" "foo::bar::bell::bell(void)"
-    gdb_test_exact "maint demangle __aa__3fooRT0" "foo::operator&&(foo &)"
-    gdb_test_exact "maint demangle __aad__3fooRT0" "foo::operator&=(foo &)"
-    gdb_test_exact "maint demangle __ad__3fooRT0" "foo::operator&(foo &)"
-    gdb_test_exact "maint demangle __adv__3fooRT0" "foo::operator/=(foo &)"
-    gdb_test_exact "maint demangle __aer__3fooRT0" "foo::operator^=(foo &)"
-    gdb_test_exact "maint demangle __als__3fooRT0" "foo::operator<<=(foo &)"
-    gdb_test_exact "maint demangle __amd__3fooRT0" "foo::operator%=(foo &)"
-    gdb_test_exact "maint demangle __ami__3fooRT0" "foo::operator-=(foo &)"
-    gdb_test_exact "maint demangle __aml__3FixRT0" "Fix::operator*=(Fix &)"
-    gdb_test_exact "maint demangle __aml__5Fix16i" "Fix16::operator*=(int)"
-    gdb_test_exact "maint demangle __aml__5Fix32RT0" "Fix32::operator*=(Fix32 &)"
-    gdb_test_exact "maint demangle __aor__3fooRT0" "foo::operator|=(foo &)"
-    gdb_test_exact "maint demangle __apl__3fooRT0" "foo::operator+=(foo &)"
-    gdb_test_exact "maint demangle __ars__3fooRT0" "foo::operator>>=(foo &)"
-
-    gdb_test_exact "maint demangle __as__3fooRT0" "foo::operator=(foo &)"
-    gdb_test_exact "maint demangle __cl__3fooRT0" "foo::operator()(foo &)"
-    gdb_test_exact "maint demangle __cl__6Normal" "Normal::operator()(void)"
-    gdb_test_exact "maint demangle __cl__6Stringii" "String::operator()(int, int)"
-    gdb_test_exact "maint demangle __cm__3fooRT0" "foo::operator, (foo &)"
-    gdb_test_exact "maint demangle __co__3foo" "foo::operator~(void)"
-    gdb_test_exact "maint demangle __dl__3fooPv" "foo::operator delete(void *)"
-    gdb_test_exact "maint demangle __dv__3fooRT0" "foo::operator/(foo &)"
-    gdb_test_exact "maint demangle __eq__3fooRT0" "foo::operator==(foo &)"
-    gdb_test_exact "maint demangle __er__3fooRT0" "foo::operator^(foo &)"
-    gdb_test_exact "maint demangle __ge__3fooRT0" "foo::operator>=(foo &)"
-    gdb_test_exact "maint demangle __gt__3fooRT0" "foo::operator>(foo &)"
-    gdb_test_exact "maint demangle __le__3fooRT0" "foo::operator<=(foo &)"
-    gdb_test_exact "maint demangle __ls__3fooRT0" "foo::operator<<(foo &)"
-    gdb_test_exact "maint demangle __ls__FR7ostreamPFR3ios_R3ios" "operator<<(ostream &, ios &(*)(ios &))"
-    gdb_test_exact "maint demangle __ls__FR7ostreamR3Fix" "operator<<(ostream &, Fix &)"
-    gdb_test_exact "maint demangle __lt__3fooRT0" "foo::operator<(foo &)"
-    gdb_test_exact "maint demangle __md__3fooRT0" "foo::operator%(foo &)"
-    gdb_test_exact "maint demangle __mi__3fooRT0" "foo::operator-(foo &)"
-    gdb_test_exact "maint demangle __ml__3fooRT0" "foo::operator*(foo &)"
-    gdb_test_exact "maint demangle __mm__3fooi" "foo::operator--(int)"
-
-    gdb_test_exact "maint demangle __ne__3fooRT0" "foo::operator!=(foo &)"
-    gdb_test "maint dem __ne__FRC7ComplexT0" \
+    test_demangling_exact "gnu: __8ArrowCmdP6EditorUiUi" "ArrowCmd::ArrowCmd(Editor *, unsigned int, unsigned int)"
+
+    test_demangling_exact "gnu: __9F_EllipseiiiiP7Graphic" "F_Ellipse::F_Ellipse(int, int, int, int, Graphic *)"
+    test_demangling_exact "gnu: __9FrameDataP9FrameCompi" "FrameData::FrameData(FrameComp *, int)"
+    test_demangling_exact "gnu: __9HVGraphicP9CanvasVarP7Graphic" "HVGraphic::HVGraphic(CanvasVar *, Graphic *)"
+    test_demangling_exact "gnu: __Q23foo3bar" "foo::bar::bar(void)"
+    test_demangling_exact "gnu: __Q33foo3bar4bell" "foo::bar::bell::bell(void)"
+    test_demangling_exact "gnu: __aa__3fooRT0" "foo::operator&&(foo &)"
+    test_demangling_exact "gnu: __aad__3fooRT0" "foo::operator&=(foo &)"
+    test_demangling_exact "gnu: __ad__3fooRT0" "foo::operator&(foo &)"
+    test_demangling_exact "gnu: __adv__3fooRT0" "foo::operator/=(foo &)"
+    test_demangling_exact "gnu: __aer__3fooRT0" "foo::operator^=(foo &)"
+    test_demangling_exact "gnu: __als__3fooRT0" "foo::operator<<=(foo &)"
+    test_demangling_exact "gnu: __amd__3fooRT0" "foo::operator%=(foo &)"
+    test_demangling_exact "gnu: __ami__3fooRT0" "foo::operator-=(foo &)"
+    test_demangling_exact "gnu: __aml__3FixRT0" "Fix::operator*=(Fix &)"
+    test_demangling_exact "gnu: __aml__5Fix16i" "Fix16::operator*=(int)"
+    test_demangling_exact "gnu: __aml__5Fix32RT0" "Fix32::operator*=(Fix32 &)"
+    test_demangling_exact "gnu: __aor__3fooRT0" "foo::operator|=(foo &)"
+    test_demangling_exact "gnu: __apl__3fooRT0" "foo::operator+=(foo &)"
+    test_demangling_exact "gnu: __ars__3fooRT0" "foo::operator>>=(foo &)"
+
+    test_demangling_exact "gnu: __as__3fooRT0" "foo::operator=(foo &)"
+    test_demangling_exact "gnu: __cl__3fooRT0" "foo::operator()(foo &)"
+    test_demangling_exact "gnu: __cl__6Normal" "Normal::operator()(void)"
+    test_demangling_exact "gnu: __cl__6Stringii" "String::operator()(int, int)"
+    test_demangling_exact "gnu: __cm__3fooRT0" "foo::operator, (foo &)"
+    test_demangling_exact "gnu: __co__3foo" "foo::operator~(void)"
+    test_demangling_exact "gnu: __dl__3fooPv" "foo::operator delete(void *)"
+    test_demangling_exact "gnu: __dv__3fooRT0" "foo::operator/(foo &)"
+    test_demangling_exact "gnu: __eq__3fooRT0" "foo::operator==(foo &)"
+    test_demangling_exact "gnu: __er__3fooRT0" "foo::operator^(foo &)"
+    test_demangling_exact "gnu: __ge__3fooRT0" "foo::operator>=(foo &)"
+    test_demangling_exact "gnu: __gt__3fooRT0" "foo::operator>(foo &)"
+    test_demangling_exact "gnu: __le__3fooRT0" "foo::operator<=(foo &)"
+    test_demangling_exact "gnu: __ls__3fooRT0" "foo::operator<<(foo &)"
+    test_demangling_exact "gnu: __ls__FR7ostreamPFR3ios_R3ios" "operator<<(ostream &, ios &(*)(ios &))"
+    test_demangling_exact "gnu: __ls__FR7ostreamR3Fix" "operator<<(ostream &, Fix &)"
+    test_demangling_exact "gnu: __lt__3fooRT0" "foo::operator<(foo &)"
+    test_demangling_exact "gnu: __md__3fooRT0" "foo::operator%(foo &)"
+    test_demangling_exact "gnu: __mi__3fooRT0" "foo::operator-(foo &)"
+    test_demangling_exact "gnu: __ml__3fooRT0" "foo::operator*(foo &)"
+    test_demangling_exact "gnu: __mm__3fooi" "foo::operator--(int)"
+
+    test_demangling_exact "gnu: __ne__3fooRT0" "foo::operator!=(foo &)"
+    test_demangling "gnu: __ne__FRC7ComplexT0" \
        "operator!=\[(\]+(const Complex|Complex const) &, (const Complex|Complex const) &\[)\]+"
-    gdb_test "maint dem __ne__FRC7Complexd" \
+    test_demangling "gnu: __ne__FRC7Complexd" \
        "operator!=\[(\]+(const Complex|Complex const) &, double\[)\]+"
-    gdb_test "maint dem __ne__FRC9SubStringRC6String" \
+    test_demangling "gnu: __ne__FRC9SubStringRC6String" \
        "operator!=\[(\]+(const SubString|SubString const) &, (const String|String const) &\[)\]+"
-    gdb_test_exact "maint demangle __nt__3foo" "foo::operator!(void)"
-    gdb_test_exact "maint demangle __nw__3fooi" "foo::operator new(int)"
-    gdb_test_exact "maint demangle __oo__3fooRT0" "foo::operator||(foo &)"
-    gdb_test_exact "maint demangle __opPc__3foo" "foo::operator char *(void)"
-    gdb_test_exact "maint demangle __opi__3foo" "foo::operator int(void)"
-    gdb_test_exact "maint demangle __or__3fooRT0" "foo::operator|(foo &)"
-    gdb_test_exact "maint demangle __pl__3fooRT0" "foo::operator+(foo &)"
-    gdb_test_exact "maint demangle __pp__3fooi" "foo::operator++(int)"
-    gdb_test_exact "maint demangle __rf__3foo" "foo::operator->(void)"
-    gdb_test_exact "maint demangle __rm__3fooRT0" "foo::operator->*(foo &)"
-    gdb_test_exact "maint demangle __rs__3fooRT0" "foo::operator>>(foo &)"
-    gdb_test "maint dem __vc__3fooRT0" "foo::operator\\\[\\\]\\(foo &\\)"
-    gdb_test "maint dem _gsub__6StringRC5RegexPCci" \
+    test_demangling_exact "gnu: __nt__3foo" "foo::operator!(void)"
+    test_demangling_exact "gnu: __nw__3fooi" "foo::operator new(int)"
+    test_demangling_exact "gnu: __oo__3fooRT0" "foo::operator||(foo &)"
+    test_demangling_exact "gnu: __opPc__3foo" "foo::operator char *(void)"
+    test_demangling_exact "gnu: __opi__3foo" "foo::operator int(void)"
+    test_demangling_exact "gnu: __or__3fooRT0" "foo::operator|(foo &)"
+    test_demangling_exact "gnu: __pl__3fooRT0" "foo::operator+(foo &)"
+    test_demangling_exact "gnu: __pp__3fooi" "foo::operator++(int)"
+    test_demangling_exact "gnu: __rf__3foo" "foo::operator->(void)"
+    test_demangling_exact "gnu: __rm__3fooRT0" "foo::operator->*(foo &)"
+    test_demangling_exact "gnu: __rs__3fooRT0" "foo::operator>>(foo &)"
+    test_demangling "gnu: __vc__3fooRT0" "foo::operator\\\[\\\]\\(foo &\\)"
+    test_demangling "gnu: _gsub__6StringRC5RegexPCci" \
        "String::_gsub\[(\]+(const Regex|Regex const) &, (const char|char const) \[*\]+, int\[)\]+"
-    gdb_test_exact "maint demangle _new_Fix__FUs" "_new_Fix(unsigned short)"
+    test_demangling_exact "gnu: _new_Fix__FUs" "_new_Fix(unsigned short)"
 
     # gcc 2.4.5 (and earlier) style virtual tables.  We want to continue to
     # correctly demangle these even if newer compilers use a different form.
-    gdb_test_exact "maint demangle _vt.foo" "foo virtual table"
-    gdb_test_exact "maint demangle _vt.foo.bar" "foo::bar virtual table"
-    gdb_test_exact "maint demangle _vt\$foo" "foo virtual table"
-    gdb_test_exact "maint demangle _vt\$foo\$bar" "foo::bar virtual table"
+    test_demangling_exact "gnu: _vt.foo" "foo virtual table"
+    test_demangling_exact "gnu: _vt.foo.bar" "foo::bar virtual table"
+    test_demangling_exact "gnu: _vt\$foo" "foo virtual table"
+    test_demangling_exact "gnu: _vt\$foo\$bar" "foo::bar virtual table"
 
-    gdb_test_exact "maint demangle append__7ivGlyphPT0" "ivGlyph::append(ivGlyph *)"
-    gdb_test "maint dem arg__FRC7Complex" \
+    test_demangling_exact "gnu: append__7ivGlyphPT0" "ivGlyph::append(ivGlyph *)"
+    test_demangling "gnu: arg__FRC7Complex" \
        "arg\[(\]+(const Complex|Complex const) &\[)\]+"
-    gdb_test_exact "maint demangle clearok__FP7_win_sti" "clearok(_win_st *, int)"
-
-    gdb_test_exact "maint demangle complexfunc2__FPFPc_i" "complexfunc2(int (*)(char *))"
-    gdb_test_exact "maint demangle complexfunc3__FPFPFPl_s_i" "complexfunc3(int (*)(short (*)(long *)))"
-    gdb_test_exact "maint demangle complexfunc4__FPFPFPc_s_i" "complexfunc4(int (*)(short (*)(char *)))"
-    gdb_test_exact "maint demangle complexfunc5__FPFPc_PFl_i" "complexfunc5(int (*(*)(char *))(long))"
-    gdb_test_exact "maint demangle complexfunc6__FPFPi_PFl_i" "complexfunc6(int (*(*)(int *))(long))"
-    gdb_test_exact "maint demangle complexfunc7__FPFPFPc_i_PFl_i" "complexfunc7(int (*(*)(int (*)(char *)))(long))"
-    gdb_test "maint dem contains__C9BitStringRC10BitPattern" \
+    test_demangling_exact "gnu: clearok__FP7_win_sti" "clearok(_win_st *, int)"
+
+    test_demangling_exact "gnu: complexfunc2__FPFPc_i" "complexfunc2(int (*)(char *))"
+    test_demangling_exact "gnu: complexfunc3__FPFPFPl_s_i" "complexfunc3(int (*)(short (*)(long *)))"
+    test_demangling_exact "gnu: complexfunc4__FPFPFPc_s_i" "complexfunc4(int (*)(short (*)(char *)))"
+    test_demangling_exact "gnu: complexfunc5__FPFPc_PFl_i" "complexfunc5(int (*(*)(char *))(long))"
+    test_demangling_exact "gnu: complexfunc6__FPFPi_PFl_i" "complexfunc6(int (*(*)(int *))(long))"
+    test_demangling_exact "gnu: complexfunc7__FPFPFPc_i_PFl_i" "complexfunc7(int (*(*)(int (*)(char *)))(long))"
+    test_demangling "gnu: contains__C9BitStringRC10BitPattern" \
        "BitString::contains\[(\]+(const BitPattern|BitPattern const) &\[)\]+ const"
-    gdb_test "maint dem contains__C9BitStringRC12BitSubStringi" \
+    test_demangling "gnu: contains__C9BitStringRC12BitSubStringi" \
        "BitString::contains\[(\]+(const BitSubString|BitSubString const) &, int\[)\]+ const"
-    gdb_test "maint dem contains__C9BitStringRT0" \
+    test_demangling "gnu: contains__C9BitStringRT0" \
        "BitString::contains\[(\]+(const BitString|BitString const) &\[)\]+ const"
-    gdb_test "maint dem div__FPC6IntRepT0P6IntRep" \
+    test_demangling "gnu: div__FPC6IntRepT0P6IntRep" \
        "div\[(\]+(const IntRep|IntRep const) \[*\]+, (const IntRep|IntRep const) \[*\]+, IntRep \[*\]+\[)\]+"
-    gdb_test "maint dem div__FPC6IntReplP6IntRep" \
+    test_demangling "gnu: div__FPC6IntReplP6IntRep" \
        "div\[(\]+(const IntRep|IntRep const) \[*\]+, long, IntRep \[*\]+\[)\]+"
-    gdb_test "maint dem div__FRC8RationalT0R8Rational" \
+    test_demangling "gnu: div__FRC8RationalT0R8Rational" \
        "div\[(\]+(const Rational|Rational const) &, (const Rational|Rational const) &, Rational &\[)\]+"
-    gdb_test "maint dem divide__FRC7IntegerT0R7IntegerT2" \
+    test_demangling "gnu: divide__FRC7IntegerT0R7IntegerT2" \
        "divide\[(\]+(const Integer|Integer const) &, (const Integer|Integer const) &, Integer &, Integer &\[)\]+"
-    gdb_test "maint dem divide__FRC7IntegerlR7IntegerRl" \
+    test_demangling "gnu: divide__FRC7IntegerlR7IntegerRl" \
        "divide\[(\]+(const Integer|Integer const) &, long, Integer &, long &\[)\]+"
-    gdb_test "maint dem enable__14DocumentViewerPCcUi" \
+    test_demangling "gnu: enable__14DocumentViewerPCcUi" \
        "DocumentViewer::enable\[(\]+(const char|char const) \[*\]+, unsigned int\[)\]+"
 
-    gdb_test_exact "maint demangle foo__FiN30" "foo(int, int, int, int)"
-    gdb_test_exact "maint demangle foo__FiR3fooiT1iT1" "foo(int, foo &, int, foo &, int, foo &)"
-    gdb_test_exact "maint demangle foo___3barl" "bar::foo_(long)"
-    gdb_test_exact "maint demangle insert__15ivClippingStacklRP8_XRegion" "ivClippingStack::insert(long, _XRegion *&)"
-    gdb_test_exact "maint demangle insert__16ChooserInfo_ListlR11ChooserInfo" "ChooserInfo_List::insert(long, ChooserInfo &)"
-    gdb_test_exact "maint demangle insert__17FontFamilyRepListlRP15ivFontFamilyRep" "FontFamilyRepList::insert(long, ivFontFamilyRep *&)"
-    gdb_test_exact "maint demangle leaveok__FP7_win_stc" "leaveok(_win_st *, char)"
-    gdb_test_exact "maint demangle left_mover__C7ivMFKitP12ivAdjustableP7ivStyle" "ivMFKit::left_mover(ivAdjustable *, ivStyle *) const"
-    gdb_test "maint dem matches__C9BitStringRC10BitPatterni" \
+    test_demangling_exact "gnu: foo__FiN30" "foo(int, int, int, int)"
+    test_demangling_exact "gnu: foo__FiR3fooiT1iT1" "foo(int, foo &, int, foo &, int, foo &)"
+    test_demangling_exact "gnu: foo___3barl" "bar::foo_(long)"
+    test_demangling_exact "gnu: insert__15ivClippingStacklRP8_XRegion" "ivClippingStack::insert(long, _XRegion *&)"
+    test_demangling_exact "gnu: insert__16ChooserInfo_ListlR11ChooserInfo" "ChooserInfo_List::insert(long, ChooserInfo &)"
+    test_demangling_exact "gnu: insert__17FontFamilyRepListlRP15ivFontFamilyRep" "FontFamilyRepList::insert(long, ivFontFamilyRep *&)"
+    test_demangling_exact "gnu: leaveok__FP7_win_stc" "leaveok(_win_st *, char)"
+    test_demangling_exact "gnu: left_mover__C7ivMFKitP12ivAdjustableP7ivStyle" "ivMFKit::left_mover(ivAdjustable *, ivStyle *) const"
+    test_demangling "gnu: matches__C9BitStringRC10BitPatterni" \
        "BitString::matches\[(\]+(const BitPattern|BitPattern const) &, int\[)\]+ const"
-    gdb_test "maint dem matches__C9SubStringRC5Regex" \
+    test_demangling "gnu: matches__C9SubStringRC5Regex" \
        "SubString::matches\[(\]+(const Regex|Regex const) &\[)\]+ const"
 
-    gdb_test_exact "maint demangle overload1arg__FSc" "overload1arg(signed char)"
-    gdb_test_exact "maint demangle overload1arg__FUc" "overload1arg(unsigned char)"
-    gdb_test_exact "maint demangle overload1arg__FUi" "overload1arg(unsigned int)"
-    gdb_test_exact "maint demangle overload1arg__FUl" "overload1arg(unsigned long)"
-    gdb_test_exact "maint demangle overload1arg__FUs" "overload1arg(unsigned short)"
-    gdb_test_exact "maint demangle overload1arg__Fc" "overload1arg(char)"
-    gdb_test_exact "maint demangle overload1arg__Fd" "overload1arg(double)"
-    gdb_test_exact "maint demangle overload1arg__Ff" "overload1arg(float)"
-    gdb_test_exact "maint demangle overload1arg__Fi" "overload1arg(int)"
-    gdb_test_exact "maint demangle overload1arg__Fl" "overload1arg(long)"
-    gdb_test_exact "maint demangle overload1arg__Fs" "overload1arg(short)"
-    gdb_test_exact "maint demangle overload1arg__Fv" "overload1arg(void)"
-    gdb_test_exact "maint demangle overloadargs__Fi" "overloadargs(int)"
-    gdb_test_exact "maint demangle overloadargs__Fii" "overloadargs(int, int)"
-    gdb_test_exact "maint demangle overloadargs__Fiii" "overloadargs(int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__Fiiii" "overloadargs(int, int, int, int)"
-
-    gdb_test_exact "maint demangle overloadargs__Fiiiii" "overloadargs(int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__Fiiiiii" "overloadargs(int, int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__Fiiiiiii" "overloadargs(int, int, int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__Fiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__Fiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__Fiiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__Fiiiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"
-    gdb_test "maint dem pick__13ivCompositionP8ivCanvasRC12ivAllocationiR5ivHit" \
+    test_demangling_exact "gnu: overload1arg__FSc" "overload1arg(signed char)"
+    test_demangling_exact "gnu: overload1arg__FUc" "overload1arg(unsigned char)"
+    test_demangling_exact "gnu: overload1arg__FUi" "overload1arg(unsigned int)"
+    test_demangling_exact "gnu: overload1arg__FUl" "overload1arg(unsigned long)"
+    test_demangling_exact "gnu: overload1arg__FUs" "overload1arg(unsigned short)"
+    test_demangling_exact "gnu: overload1arg__Fc" "overload1arg(char)"
+    test_demangling_exact "gnu: overload1arg__Fd" "overload1arg(double)"
+    test_demangling_exact "gnu: overload1arg__Ff" "overload1arg(float)"
+    test_demangling_exact "gnu: overload1arg__Fi" "overload1arg(int)"
+    test_demangling_exact "gnu: overload1arg__Fl" "overload1arg(long)"
+    test_demangling_exact "gnu: overload1arg__Fs" "overload1arg(short)"
+    test_demangling_exact "gnu: overload1arg__Fv" "overload1arg(void)"
+    test_demangling_exact "gnu: overloadargs__Fi" "overloadargs(int)"
+    test_demangling_exact "gnu: overloadargs__Fii" "overloadargs(int, int)"
+    test_demangling_exact "gnu: overloadargs__Fiii" "overloadargs(int, int, int)"
+    test_demangling_exact "gnu: overloadargs__Fiiii" "overloadargs(int, int, int, int)"
+
+    test_demangling_exact "gnu: overloadargs__Fiiiii" "overloadargs(int, int, int, int, int)"
+    test_demangling_exact "gnu: overloadargs__Fiiiiii" "overloadargs(int, int, int, int, int, int)"
+    test_demangling_exact "gnu: overloadargs__Fiiiiiii" "overloadargs(int, int, int, int, int, int, int)"
+    test_demangling_exact "gnu: overloadargs__Fiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int)"
+    test_demangling_exact "gnu: overloadargs__Fiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int)"
+    test_demangling_exact "gnu: overloadargs__Fiiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int, int)"
+    test_demangling_exact "gnu: overloadargs__Fiiiiiiiiiii" "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"
+    test_demangling "gnu: pick__13ivCompositionP8ivCanvasRC12ivAllocationiR5ivHit" \
        "ivComposition::pick\[(\]+ivCanvas \[*\]+, (const ivAllocation|ivAllocation const) &, int, ivHit &\[)\]+"
-    gdb_test "maint dem pointer__C11ivHScrollerRC7ivEventRC12ivAllocation" \
+    test_demangling "gnu: pointer__C11ivHScrollerRC7ivEventRC12ivAllocation" \
        "ivHScroller::pointer\[(\]+(const ivEvent|ivEvent const) &, (const ivAllocation|ivAllocation const) &\[)\]+ const"
-    gdb_test_exact "maint demangle poke__8ivRasterUlUlffff" "ivRaster::poke(unsigned long, unsigned long, float, float, float, float)"
-    gdb_test_exact "maint demangle polar__Fdd" "polar(double, double)"
-    gdb_test "maint dem read__10osStdInputRPCc" \
+    test_demangling_exact "gnu: poke__8ivRasterUlUlffff" "ivRaster::poke(unsigned long, unsigned long, float, float, float, float)"
+    test_demangling_exact "gnu: polar__Fdd" "polar(double, double)"
+    test_demangling "gnu: read__10osStdInputRPCc" \
        "osStdInput::read\[(\]+(const char|char const) \[*\]+&\[)\]+"
 
-    gdb_test_exact "maint demangle scale__13ivTransformerff" "ivTransformer::scale(float, float)"
-    gdb_test "maint dem scanw__12CursesWindowPCce" \
+    test_demangling_exact "gnu: scale__13ivTransformerff" "ivTransformer::scale(float, float)"
+    test_demangling "gnu: scanw__12CursesWindowPCce" \
        "CursesWindow::scanw\[(\]+(const char|char const) \[*\]+,...\[)\]+"
-    gdb_test "maint dem scmp__FPCcT0" \
+    test_demangling "gnu: scmp__FPCcT0" \
        "scmp\[(\]+(const char|char const) \[*\]+, (const char|char const) \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle sgetn__7filebufPci" "filebuf::sgetn(char *, int)"
-    gdb_test_exact "maint demangle shift__FP5_FrepiT0" "shift(_Frep *, int, _Frep *)"
-    gdb_test_exact "maint demangle test__C6BitSeti" "BitSet::test(int) const"
-    gdb_test_exact "maint demangle test__C6BitSetii" "BitSet::test(int, int) const"
-    gdb_test "maint dem testbit__FRC7Integerl" \
+    test_demangling_exact "gnu: sgetn__7filebufPci" "filebuf::sgetn(char *, int)"
+    test_demangling_exact "gnu: shift__FP5_FrepiT0" "shift(_Frep *, int, _Frep *)"
+    test_demangling_exact "gnu: test__C6BitSeti" "BitSet::test(int) const"
+    test_demangling_exact "gnu: test__C6BitSetii" "BitSet::test(int, int) const"
+    test_demangling "gnu: testbit__FRC7Integerl" \
        "testbit\[(\]+(const Integer|Integer const) &, long\[)\]+"
-    gdb_test_exact "maint demangle text_source__8Documentl" "Document::text_source(long)"
-    gdb_test_exact "maint demangle variance__6Erlangd" "Erlang::variance(double)"
-    gdb_test "maint dem vform__8iostreamPCcPc" \
+    test_demangling_exact "gnu: text_source__8Documentl" "Document::text_source(long)"
+    test_demangling_exact "gnu: variance__6Erlangd" "Erlang::variance(double)"
+    test_demangling "gnu: vform__8iostreamPCcPc" \
        "iostream::vform\[(\]+(const char|char const) \[*\]+, char \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle view__14DocumentViewerP8ItemViewP11TabularItem" "DocumentViewer::view(ItemView *, TabularItem *)"
-    gdb_test_exact "maint demangle xy_extents__11ivExtensionffff" "ivExtension::xy_extents(float, float, float, float)"
-    gdb_test_exact "maint demangle zero__8osMemoryPvUi" "osMemory::zero(void *, unsigned int)"
-    gdb_test_exact "maint demangle _2T4\$N" "T4::N"
-    gdb_test_exact "maint demangle _Q22T42t1\$N" "T4::t1::N"
-    gdb_test_exact "maint demangle get__2T1" "T1::get(void)"
-    gdb_test_exact "maint demangle get__Q22T11a" "T1::a::get(void)"
-    gdb_test_exact "maint demangle get__Q32T11a1b" "T1::a::b::get(void)"
-    gdb_test_exact "maint demangle get__Q42T11a1b1c" "T1::a::b::c::get(void)"
-    gdb_test_exact "maint demangle get__Q52T11a1b1c1d" "T1::a::b::c::d::get(void)"
-    gdb_test_exact "maint demangle put__2T1i" "T1::put(int)"
-    gdb_test_exact "maint demangle put__Q22T11ai" "T1::a::put(int)"
-    gdb_test_exact "maint demangle put__Q32T11a1bi" "T1::a::b::put(int)"
-    gdb_test_exact "maint demangle put__Q42T11a1b1ci" "T1::a::b::c::put(int)"
-    gdb_test_exact "maint demangle put__Q52T11a1b1c1di" "T1::a::b::c::d::put(int)"
-
-    gdb_test_exact "maint demangle bar__3fooPv"       "foo::bar(void *)"
-    gdb_test "maint dem bar__3fooPCv" \
+    test_demangling_exact "gnu: view__14DocumentViewerP8ItemViewP11TabularItem" "DocumentViewer::view(ItemView *, TabularItem *)"
+    test_demangling_exact "gnu: xy_extents__11ivExtensionffff" "ivExtension::xy_extents(float, float, float, float)"
+    test_demangling_exact "gnu: zero__8osMemoryPvUi" "osMemory::zero(void *, unsigned int)"
+    test_demangling_exact "gnu: _2T4\$N" "T4::N"
+    test_demangling_exact "gnu: _Q22T42t1\$N" "T4::t1::N"
+    test_demangling_exact "gnu: get__2T1" "T1::get(void)"
+    test_demangling_exact "gnu: get__Q22T11a" "T1::a::get(void)"
+    test_demangling_exact "gnu: get__Q32T11a1b" "T1::a::b::get(void)"
+    test_demangling_exact "gnu: get__Q42T11a1b1c" "T1::a::b::c::get(void)"
+    test_demangling_exact "gnu: get__Q52T11a1b1c1d" "T1::a::b::c::d::get(void)"
+    test_demangling_exact "gnu: put__2T1i" "T1::put(int)"
+    test_demangling_exact "gnu: put__Q22T11ai" "T1::a::put(int)"
+    test_demangling_exact "gnu: put__Q32T11a1bi" "T1::a::b::put(int)"
+    test_demangling_exact "gnu: put__Q42T11a1b1ci" "T1::a::b::c::put(int)"
+    test_demangling_exact "gnu: put__Q52T11a1b1c1di" "T1::a::b::c::d::put(int)"
+
+    test_demangling_exact "gnu: bar__3fooPv"       "foo::bar(void *)"
+    test_demangling "gnu: bar__3fooPCv" \
        "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+"
-    gdb_test_exact "maint demangle bar__C3fooPv"      "foo::bar(void *) const"
-    gdb_test "maint dem bar__C3fooPCv" \
+    test_demangling_exact "gnu: bar__C3fooPv"      "foo::bar(void *) const"
+    test_demangling "gnu: bar__C3fooPCv" \
        "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+ const"
-    gdb_test_exact "maint demangle __eq__3fooRT0"     "foo::operator==(foo &)"
-    gdb_test "maint dem __eq__3fooRC3foo" \
+    test_demangling_exact "gnu: __eq__3fooRT0"     "foo::operator==(foo &)"
+    test_demangling "gnu: __eq__3fooRC3foo" \
         "foo::operator==\[(\]+(const foo|foo const) &\[)\]+"
-    gdb_test_exact "maint demangle __eq__C3fooR3foo"  "foo::operator==(foo &) const"
-    gdb_test "maint dem __eq__C3fooRT0" \
+    test_demangling_exact "gnu: __eq__C3fooR3foo"  "foo::operator==(foo &) const"
+    test_demangling "gnu: __eq__C3fooRT0" \
           "foo::operator==\[(\]+(const foo|foo const) &\[)\]+ const"
 
-    gdb_test_exact "maint demangle elem__t6vector1Zdi" "vector<double>::elem(int)"
-    gdb_test_exact "maint demangle elem__t6vector1Zii" "vector<int>::elem(int)"
-    gdb_test_exact "maint demangle __t6vector1Zdi"     "vector<double>::vector(int)"
-    gdb_test_exact "maint demangle __t6vector1Zii"     "vector<int>::vector(int)"
-    gdb_test_exact "maint demangle _\$_t6vector1Zdi"    "vector<double>::~vector(int)"
-    gdb_test_exact "maint demangle _\$_t6vector1Zii"    "vector<int>::~vector(int)"
-
-    gdb_test_exact "maint demangle __nw__t2T11ZcUi" "T1<char>::operator new(unsigned int)"
-    gdb_test_exact "maint demangle __nw__t2T11Z1tUi" "T1<t>::operator new(unsigned int)"
-    gdb_test_exact "maint demangle __dl__t2T11ZcPv" "T1<char>::operator delete(void *)"
-    gdb_test_exact "maint demangle __dl__t2T11Z1tPv" "T1<t>::operator delete(void *)"
-    gdb_test_exact "maint demangle __t2T11Zci" "T1<char>::T1(int)"
-    gdb_test_exact "maint demangle __t2T11Zc" "T1<char>::T1(void)"
-    gdb_test_exact "maint demangle __t2T11Z1ti" "T1<t>::T1(int)"
-    gdb_test_exact "maint demangle __t2T11Z1t" "T1<t>::T1(void)"
-
-    gdb_test_exact "maint demangle __Q2t4List1Z10VHDLEntity3Pix" \
+    test_demangling_exact "gnu: elem__t6vector1Zdi" "vector<double>::elem(int)"
+    test_demangling_exact "gnu: elem__t6vector1Zii" "vector<int>::elem(int)"
+    test_demangling_exact "gnu: __t6vector1Zdi"     "vector<double>::vector(int)"
+    test_demangling_exact "gnu: __t6vector1Zii"     "vector<int>::vector(int)"
+    test_demangling_exact "gnu: _\$_t6vector1Zdi"    "vector<double>::~vector(int)"
+    test_demangling_exact "gnu: _\$_t6vector1Zii"    "vector<int>::~vector(int)"
+
+    test_demangling_exact "gnu: __nw__t2T11ZcUi" "T1<char>::operator new(unsigned int)"
+    test_demangling_exact "gnu: __nw__t2T11Z1tUi" "T1<t>::operator new(unsigned int)"
+    test_demangling_exact "gnu: __dl__t2T11ZcPv" "T1<char>::operator delete(void *)"
+    test_demangling_exact "gnu: __dl__t2T11Z1tPv" "T1<t>::operator delete(void *)"
+    test_demangling_exact "gnu: __t2T11Zci" "T1<char>::T1(int)"
+    test_demangling_exact "gnu: __t2T11Zc" "T1<char>::T1(void)"
+    test_demangling_exact "gnu: __t2T11Z1ti" "T1<t>::T1(int)"
+    test_demangling_exact "gnu: __t2T11Z1t" "T1<t>::T1(void)"
+
+    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3Pix" \
        "List<VHDLEntity>::Pix::Pix(void)"
 
-    gdb_test_exact "maint demangle __Q2t4List1Z10VHDLEntity3PixPQ2t4List1Z10VHDLEntity7element" \
+    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3PixPQ2t4List1Z10VHDLEntity7element" \
        "List<VHDLEntity>::Pix::Pix(List<VHDLEntity>::element *)"
 
-    gdb_test_exact "maint demangle __Q2t4List1Z10VHDLEntity3PixRCQ2t4List1Z10VHDLEntity3Pix" \
+    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity3PixRCQ2t4List1Z10VHDLEntity3Pix" \
        "List<VHDLEntity>::Pix::Pix(List<VHDLEntity>::Pix const &)"
 
-    gdb_test_exact "maint demangle __Q2t4List1Z10VHDLEntity7elementRC10VHDLEntityPT0" \
+    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity7elementRC10VHDLEntityPT0" \
        "List<VHDLEntity>::element::element(VHDLEntity const &, List<VHDLEntity>::element *)"
 
-    gdb_test_exact "maint demangle __Q2t4List1Z10VHDLEntity7elementRCQ2t4List1Z10VHDLEntity7element" \
+    test_demangling_exact "gnu: __Q2t4List1Z10VHDLEntity7elementRCQ2t4List1Z10VHDLEntity7element" \
        "List<VHDLEntity>::element::element(List<VHDLEntity>::element const &)"
 
-    gdb_test_exact "maint demangle __cl__C11VHDLLibraryGt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
+    test_demangling_exact "gnu: __cl__C11VHDLLibraryGt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
        "VHDLLibrary::operator()(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >) const"
 
-    gdb_test_exact "maint demangle __cl__Ct4List1Z10VHDLEntityRCQ2t4List1Z10VHDLEntity3Pix" \
+    test_demangling_exact "gnu: __cl__Ct4List1Z10VHDLEntityRCQ2t4List1Z10VHDLEntity3Pix" \
        "List<VHDLEntity>::operator()(List<VHDLEntity>::Pix const &) const"
 
-    gdb_test_exact "maint demangle __ne__FPvRCQ2t4List1Z10VHDLEntity3Pix" \
+    test_demangling_exact "gnu: __ne__FPvRCQ2t4List1Z10VHDLEntity3Pix" \
        "operator!=(void *, List<VHDLEntity>::Pix const &)"
 
-    gdb_test_exact "maint demangle __ne__FPvRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
+    test_demangling_exact "gnu: __ne__FPvRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
        "operator!=(void *, PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> > const &)"
 
-    gdb_test_exact "maint demangle __t4List1Z10VHDLEntityRCt4List1Z10VHDLEntity" \
+    test_demangling_exact "gnu: __t4List1Z10VHDLEntityRCt4List1Z10VHDLEntity" \
        "List<VHDLEntity>::List(List<VHDLEntity> const &)"
 
-    gdb_test_exact "maint demangle __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
+    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
        "PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >::PixX(void)"
 
-    gdb_test_exact "maint demangle __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityP14VHDLLibraryRepGQ2t4List1Z10VHDLEntity3Pix" \
+    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityP14VHDLLibraryRepGQ2t4List1Z10VHDLEntity3Pix" \
        "PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >::PixX(VHDLLibraryRep *, List<VHDLEntity>::Pix)"
 
-    gdb_test_exact "maint demangle __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
+    test_demangling_exact "gnu: __t4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntityRCt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
        "PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> >::PixX(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> > const &)"
 
-    gdb_test_exact "maint demangle nextE__C11VHDLLibraryRt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
+    test_demangling_exact "gnu: nextE__C11VHDLLibraryRt4PixX3Z11VHDLLibraryZ14VHDLLibraryRepZt4List1Z10VHDLEntity" \
        "VHDLLibrary::nextE(PixX<VHDLLibrary, VHDLLibraryRep, List<VHDLEntity> > &) const"
 
-    gdb_test_exact "maint demangle next__Ct4List1Z10VHDLEntityRQ2t4List1Z10VHDLEntity3Pix" \
+    test_demangling_exact "gnu: next__Ct4List1Z10VHDLEntityRQ2t4List1Z10VHDLEntity3Pix" \
        "List<VHDLEntity>::next(List<VHDLEntity>::Pix &) const"
 
-    gdb_test_exact "maint demangle _GLOBAL_\$D\$set" "global destructors keyed to set"
+    test_demangling_exact "gnu: _GLOBAL_\$D\$set" "global destructors keyed to set"
 
-    gdb_test_exact "maint demangle _GLOBAL_\$I\$set" "global constructors keyed to set"
+    test_demangling_exact "gnu: _GLOBAL_\$I\$set" "global constructors keyed to set"
 
-    gdb_test_exact "maint demangle __as__t5ListS1ZUiRCt5ListS1ZUi" \
+    test_demangling_exact "gnu: __as__t5ListS1ZUiRCt5ListS1ZUi" \
        "ListS<unsigned int>::operator=(ListS<unsigned int> const &)"
 
-    gdb_test_exact "maint demangle __cl__Ct5ListS1ZUiRCQ2t5ListS1ZUi3Vix" \
+    test_demangling_exact "gnu: __cl__Ct5ListS1ZUiRCQ2t5ListS1ZUi3Vix" \
        "ListS<unsigned int>::operator()(ListS<unsigned int>::Vix const &) const"
 
-    gdb_test_exact "maint demangle __cl__Ct5SetLS1ZUiRCQ2t5SetLS1ZUi3Vix" \
+    test_demangling_exact "gnu: __cl__Ct5SetLS1ZUiRCQ2t5SetLS1ZUi3Vix" \
        "SetLS<unsigned int>::operator()(SetLS<unsigned int>::Vix const &) const"
 
-    gdb_test_exact "maint demangle __t10ListS_link1ZUiRCUiPT0" \
+    test_demangling_exact "gnu: __t10ListS_link1ZUiRCUiPT0" \
        "ListS_link<unsigned int>::ListS_link(unsigned int const &, ListS_link<unsigned int> *)"
 
-    gdb_test_exact "maint demangle __t10ListS_link1ZUiRCt10ListS_link1ZUi" \
+    test_demangling_exact "gnu: __t10ListS_link1ZUiRCt10ListS_link1ZUi" \
        "ListS_link<unsigned int>::ListS_link(ListS_link<unsigned int> const &)"
 
-    gdb_test_exact "maint demangle __t5ListS1ZUiRCt5ListS1ZUi" \
+    test_demangling_exact "gnu: __t5ListS1ZUiRCt5ListS1ZUi" \
        "ListS<unsigned int>::ListS(ListS<unsigned int> const &)"
 
-    gdb_test_exact "maint demangle next__Ct5ListS1ZUiRQ2t5ListS1ZUi3Vix" \
+    test_demangling_exact "gnu: next__Ct5ListS1ZUiRQ2t5ListS1ZUi3Vix" \
        "ListS<unsigned int>::next(ListS<unsigned int>::Vix &) const"
 
-    gdb_test_exact "maint demangle __ne__FPvRCQ2t5SetLS1ZUi3Vix" \
+    test_demangling_exact "gnu: __ne__FPvRCQ2t5SetLS1ZUi3Vix" \
        "operator!=(void *, SetLS<unsigned int>::Vix const &)"
-    gdb_test_exact "maint demangle __t8ListElem1Z5LabelRt4List1Z5Label" \
+    test_demangling_exact "gnu: __t8ListElem1Z5LabelRt4List1Z5Label" \
        "ListElem<Label>::ListElem(List<Label> &)"
-    gdb_test_exact "maint demangle __t8BDDHookV1ZPcRCPc" \
+    test_demangling_exact "gnu: __t8BDDHookV1ZPcRCPc" \
        "BDDHookV<char *>::BDDHookV(char *const &)"
 
-    gdb_test_exact "maint demangle _vt\$t8BDDHookV1ZPc" "BDDHookV<char *> virtual table"
+    test_demangling_exact "gnu: _vt\$t8BDDHookV1ZPc" "BDDHookV<char *> virtual table"
 
-    gdb_test_exact "maint demangle __ne__FPvRCQ211BDDFunction4VixB" \
+    test_demangling_exact "gnu: __ne__FPvRCQ211BDDFunction4VixB" \
        "operator!=(void *, BDDFunction::VixB const &)"
-    gdb_test_exact "maint demangle __eq__FPvRCQ211BDDFunction4VixB" \
+    test_demangling_exact "gnu: __eq__FPvRCQ211BDDFunction4VixB" \
        "operator==(void *, BDDFunction::VixB const &)"
 
-    gdb_test_exact "maint demangle relativeId__CQ36T_phi210T_preserve8FPC_nextRCQ26T_phi210T_preserveRC10Parameters" \
+    test_demangling_exact "gnu: relativeId__CQ36T_phi210T_preserve8FPC_nextRCQ26T_phi210T_preserveRC10Parameters" \
         "T_phi2::T_preserve::FPC_next::relativeId(T_phi2::T_preserve const &, Parameters const &) const"
 
+    test_demangling_exact "gnu: _Utf390_1__1_9223372036854775807__9223372036854775" \
+           "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
+    test_demangling_exact "gnu: foo__I40" "foo(int64_t)"
+    test_demangling_exact "gnu: foo__I_200_" "foo(int512_t)"
+    test_demangling_exact "gnu: foo__I_200" "Can't demangle \"foo__I_200\""
+
+    ## Buffer overrun.  Should make GDB crash.  Woo hoo!
+    test_demangling_exact "gnu: foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000" "Can't demangle \"foo__I_4000000000000000000000000000000000000000000000000000000000000000000000000\""
+
+    ## 1999-04-19: "Fix from Dale Hawkins".  Shouldn't segfault.
+    test_demangling_exact "gnu: __thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator" "Can't demangle \"__thunk_64__0RL__list__Q29CosNaming20_proxy_NamingContextUlRPt25_CORBA_Unbounded_Sequence1ZQ29CosNaming7BindingRPQ29CosNaming15BindingIterator\""
 }
 
 #
@@ -453,277 +537,260 @@ proc test_gnu_style_demangling {} {
 #
 
 proc test_lucid_style_demangling {} {
-    global gdb_prompt
-
-    # Set the demangling style to "lucid" and then check to make sure
-    # it really got set.  Return if the style failed to get set for
-    # some reason.
-
-    send_gdb "set demangle-style lucid\n"
-    gdb_expect {
-       -re "set demangle-style lucid\[\r\n\]+$gdb_prompt $" {}
-       -re ".*$gdb_prompt $" { fail "set demangle-style lucid failed" ; return }
-       timeout { fail "set demangle-style lucid failed (timeout)" ; return }
-    }
-
-    send_gdb "show demangle-style\n"
-    gdb_expect {
-       -re "The current C\[+\]+ demangling style is \"lucid\".\r\n$gdb_prompt $" {}
-       -re ".*$gdb_prompt $" { fail "demangling style not set to lucid" }
-       timeout { fail "show demangle-style timed out" }
-    }
-
-    gdb_test_exact "maint demangle WS__FR7istream" "WS(istream &)"
-    gdb_test_exact "maint demangle __aa__3fooFR3foo" "foo::operator&&(foo &)"
-    gdb_test_exact "maint demangle __aad__3fooFR3foo" "foo::operator&=(foo &)"
-    gdb_test_exact "maint demangle __ad__3fooFR3foo" "foo::operator&(foo &)"
-    gdb_test_exact "maint demangle __adv__3fooFR3foo" "foo::operator/=(foo &)"
-    gdb_test_exact "maint demangle __adv__7complexF7complex" "complex::operator/=(complex)"
-    gdb_test_exact "maint demangle __aer__3fooFR3foo" "foo::operator^=(foo &)"
-    gdb_test_exact "maint demangle __als__3fooFR3foo" "foo::operator<<=(foo &)"
-    gdb_test_exact "maint demangle __amd__3fooFR3foo" "foo::operator%=(foo &)"
-    gdb_test_exact "maint demangle __ami__3fooFR3foo" "foo::operator-=(foo &)"
-    gdb_test_exact "maint demangle __amu__3fooFR3foo" "foo::operator*=(foo &)"
-    gdb_test_exact "maint demangle __amu__7complexF7complex" "complex::operator*=(complex)"
-    gdb_test_exact "maint demangle __aor__3fooFR3foo" "foo::operator|=(foo &)"
-    gdb_test_exact "maint demangle __apl__3fooFR3foo" "foo::operator+=(foo &)"
-    gdb_test_exact "maint demangle __ars__3fooFR3foo" "foo::operator>>=(foo &)"
-    gdb_test_exact "maint demangle __as__18istream_withassignFP9streambuf" "istream_withassign::operator=(streambuf *)"
-    gdb_test_exact "maint demangle __as__18istream_withassignFR7istream" "istream_withassign::operator=(istream &)"
-    gdb_test_exact "maint demangle __as__3fooFR3foo" "foo::operator=(foo &)"
-    gdb_test_exact "maint demangle __as__3iosFR3ios" "ios::operator=(ios &)"
-    gdb_test_exact "maint demangle __cl__3fooFR3foo" "foo::operator()(foo &)"
-    gdb_test_exact "maint demangle __cm__3fooFR3foo" "foo::operator, (foo &)"
-
-    gdb_test_exact "maint demangle __co__3fooFv" "foo::operator~(void)"
-    gdb_test_exact "maint demangle __ct__10istrstreamFPc" "istrstream::istrstream(char *)"
-    gdb_test_exact "maint demangle __ct__10istrstreamFPci" "istrstream::istrstream(char *, int)"
-    gdb_test_exact "maint demangle __ct__10ostrstreamFPciT2" "ostrstream::ostrstream(char *, int, int)"
-    gdb_test_exact "maint demangle __ct__10ostrstreamFv" "ostrstream::ostrstream(void)"
-    gdb_test_exact "maint demangle __ct__10smanip_intFPFR3iosi_R3iosi" "smanip_int::smanip_int(ios &(*)(ios &, int), int)"
-    gdb_test "maint dem __ct__11c_exceptionFPcRC7complexT2" "c_exception::c_exception\[(\]+char \[*\]+, (const complex|complex const) &, (const complex|complex const) &\[)\]+"
-    gdb_test "maint dem __ct__11fstreambaseFPCciT2" "fstreambase::fstreambase\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-    gdb_test_exact "maint demangle __ct__11fstreambaseFi" "fstreambase::fstreambase(int)"
-    gdb_test_exact "maint demangle __ct__11fstreambaseFiPcT1" "fstreambase::fstreambase(int, char *, int)"
-    gdb_test_exact "maint demangle __ct__11fstreambaseFv" "fstreambase::fstreambase(void)"
-    gdb_test_exact "maint demangle __ct__11smanip_longFPFR3iosl_R3iosl" "smanip_long::smanip_long(ios &(*)(ios &, long), long)"
-    gdb_test_exact "maint demangle __ct__11stdiostreamFP4FILE" "stdiostream::stdiostream(FILE *)"
-    gdb_test_exact "maint demangle __ct__12strstreambufFPFl_PvPFPv_v" "strstreambuf::strstreambuf(void *(*)(long), void (*)(void *))"
-    gdb_test_exact "maint demangle __ct__12strstreambufFPUciT1" "strstreambuf::strstreambuf(unsigned char *, int, unsigned char *)"
-    gdb_test_exact "maint demangle __ct__12strstreambufFPciT1" "strstreambuf::strstreambuf(char *, int, char *)"
-    gdb_test_exact "maint demangle __ct__12strstreambufFi" "strstreambuf::strstreambuf(int)"
-    gdb_test_exact "maint demangle __ct__12strstreambufFv" "strstreambuf::strstreambuf(void)"
-    gdb_test_exact "maint demangle __ct__13strstreambaseFPciT1" "strstreambase::strstreambase(char *, int, char *)"
-    gdb_test_exact "maint demangle __ct__3fooFR3foo" "foo::foo(foo &)"
-
-    gdb_test_exact "maint demangle __ct__3fooFi" "foo::foo(int)"
-    gdb_test_exact "maint demangle __ct__3fooFiN31" "foo::foo(int, int, int, int)"
-    gdb_test "maint dem __ct__3fooFiPCc" \
+    test_demangling_exact "lucid: WS__FR7istream" "WS(istream &)"
+    test_demangling_exact "lucid: __aa__3fooFR3foo" "foo::operator&&(foo &)"
+    test_demangling_exact "lucid: __aad__3fooFR3foo" "foo::operator&=(foo &)"
+    test_demangling_exact "lucid: __ad__3fooFR3foo" "foo::operator&(foo &)"
+    test_demangling_exact "lucid: __adv__3fooFR3foo" "foo::operator/=(foo &)"
+    test_demangling_exact "lucid: __adv__7complexF7complex" "complex::operator/=(complex)"
+    test_demangling_exact "lucid: __aer__3fooFR3foo" "foo::operator^=(foo &)"
+    test_demangling_exact "lucid: __als__3fooFR3foo" "foo::operator<<=(foo &)"
+    test_demangling_exact "lucid: __amd__3fooFR3foo" "foo::operator%=(foo &)"
+    test_demangling_exact "lucid: __ami__3fooFR3foo" "foo::operator-=(foo &)"
+    test_demangling_exact "lucid: __amu__3fooFR3foo" "foo::operator*=(foo &)"
+    test_demangling_exact "lucid: __amu__7complexF7complex" "complex::operator*=(complex)"
+    test_demangling_exact "lucid: __aor__3fooFR3foo" "foo::operator|=(foo &)"
+    test_demangling_exact "lucid: __apl__3fooFR3foo" "foo::operator+=(foo &)"
+    test_demangling_exact "lucid: __ars__3fooFR3foo" "foo::operator>>=(foo &)"
+    test_demangling_exact "lucid: __as__18istream_withassignFP9streambuf" "istream_withassign::operator=(streambuf *)"
+    test_demangling_exact "lucid: __as__18istream_withassignFR7istream" "istream_withassign::operator=(istream &)"
+    test_demangling_exact "lucid: __as__3fooFR3foo" "foo::operator=(foo &)"
+    test_demangling_exact "lucid: __as__3iosFR3ios" "ios::operator=(ios &)"
+    test_demangling_exact "lucid: __cl__3fooFR3foo" "foo::operator()(foo &)"
+    test_demangling_exact "lucid: __cm__3fooFR3foo" "foo::operator, (foo &)"
+
+    test_demangling_exact "lucid: __co__3fooFv" "foo::operator~(void)"
+    test_demangling_exact "lucid: __ct__10istrstreamFPc" "istrstream::istrstream(char *)"
+    test_demangling_exact "lucid: __ct__10istrstreamFPci" "istrstream::istrstream(char *, int)"
+    test_demangling_exact "lucid: __ct__10ostrstreamFPciT2" "ostrstream::ostrstream(char *, int, int)"
+    test_demangling_exact "lucid: __ct__10ostrstreamFv" "ostrstream::ostrstream(void)"
+    test_demangling_exact "lucid: __ct__10smanip_intFPFR3iosi_R3iosi" "smanip_int::smanip_int(ios &(*)(ios &, int), int)"
+    test_demangling "lucid: __ct__11c_exceptionFPcRC7complexT2" "c_exception::c_exception\[(\]+char \[*\]+, (const complex|complex const) &, (const complex|complex const) &\[)\]+"
+    test_demangling "lucid: __ct__11fstreambaseFPCciT2" "fstreambase::fstreambase\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
+    test_demangling_exact "lucid: __ct__11fstreambaseFi" "fstreambase::fstreambase(int)"
+    test_demangling_exact "lucid: __ct__11fstreambaseFiPcT1" "fstreambase::fstreambase(int, char *, int)"
+    test_demangling_exact "lucid: __ct__11fstreambaseFv" "fstreambase::fstreambase(void)"
+    test_demangling_exact "lucid: __ct__11smanip_longFPFR3iosl_R3iosl" "smanip_long::smanip_long(ios &(*)(ios &, long), long)"
+    test_demangling_exact "lucid: __ct__11stdiostreamFP4FILE" "stdiostream::stdiostream(FILE *)"
+    test_demangling_exact "lucid: __ct__12strstreambufFPFl_PvPFPv_v" "strstreambuf::strstreambuf(void *(*)(long), void (*)(void *))"
+    test_demangling_exact "lucid: __ct__12strstreambufFPUciT1" "strstreambuf::strstreambuf(unsigned char *, int, unsigned char *)"
+    test_demangling_exact "lucid: __ct__12strstreambufFPciT1" "strstreambuf::strstreambuf(char *, int, char *)"
+    test_demangling_exact "lucid: __ct__12strstreambufFi" "strstreambuf::strstreambuf(int)"
+    test_demangling_exact "lucid: __ct__12strstreambufFv" "strstreambuf::strstreambuf(void)"
+    test_demangling_exact "lucid: __ct__13strstreambaseFPciT1" "strstreambase::strstreambase(char *, int, char *)"
+    test_demangling_exact "lucid: __ct__3fooFR3foo" "foo::foo(foo &)"
+
+    test_demangling_exact "lucid: __ct__3fooFi" "foo::foo(int)"
+    test_demangling_exact "lucid: __ct__3fooFiN31" "foo::foo(int, int, int, int)"
+    test_demangling "lucid: __ct__3fooFiPCc" \
        "foo::foo\[(\]+int, (const char|char const) \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle __ct__3fooFiR3fooT1T2T1T2" "foo::foo(int, foo &, int, foo &, int, foo &)"
-    gdb_test_exact "maint demangle __ct__3iosFP9streambuf" "ios::ios(streambuf *)"
-    gdb_test_exact "maint demangle __ct__7filebufFiPcT1" "filebuf::filebuf(int, char *, int)"
-    gdb_test "maint dem __ct__7fstreamFPCciT2" \
+    test_demangling_exact "lucid: __ct__3fooFiR3fooT1T2T1T2" "foo::foo(int, foo &, int, foo &, int, foo &)"
+    test_demangling_exact "lucid: __ct__3iosFP9streambuf" "ios::ios(streambuf *)"
+    test_demangling_exact "lucid: __ct__7filebufFiPcT1" "filebuf::filebuf(int, char *, int)"
+    test_demangling "lucid: __ct__7fstreamFPCciT2" \
        "fstream::fstream\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-    gdb_test_exact "maint demangle __ct__7fstreamFiPcT1" "fstream::fstream(int, char *, int)"
-    gdb_test_exact "maint demangle __ct__7istreamFP9streambuf" "istream::istream(streambuf *)"
-    gdb_test_exact "maint demangle __ct__7istreamFP9streambufiP7ostream" "istream::istream(streambuf *, int, ostream *)"
-    gdb_test_exact "maint demangle __ct__7istreamFiPcT1" "istream::istream(int, char *, int)"
-    gdb_test_exact "maint demangle __ct__7istreamFiT1P7ostream" "istream::istream(int, int, ostream *)"
-    gdb_test_exact "maint demangle __ct__7ostreamFP9streambuf" "ostream::ostream(streambuf *)"
-    gdb_test_exact "maint demangle __ct__7ostreamFiPc" "ostream::ostream(int, char *)"
-    gdb_test "maint dem __ct__8ifstreamFPCciT2" \
+    test_demangling_exact "lucid: __ct__7fstreamFiPcT1" "fstream::fstream(int, char *, int)"
+    test_demangling_exact "lucid: __ct__7istreamFP9streambuf" "istream::istream(streambuf *)"
+    test_demangling_exact "lucid: __ct__7istreamFP9streambufiP7ostream" "istream::istream(streambuf *, int, ostream *)"
+    test_demangling_exact "lucid: __ct__7istreamFiPcT1" "istream::istream(int, char *, int)"
+    test_demangling_exact "lucid: __ct__7istreamFiT1P7ostream" "istream::istream(int, int, ostream *)"
+    test_demangling_exact "lucid: __ct__7ostreamFP9streambuf" "ostream::ostream(streambuf *)"
+    test_demangling_exact "lucid: __ct__7ostreamFiPc" "ostream::ostream(int, char *)"
+    test_demangling "lucid: __ct__8ifstreamFPCciT2" \
        "ifstream::ifstream\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-    gdb_test_exact "maint demangle __ct__8ifstreamFiPcT1" "ifstream::ifstream(int, char *, int)"
-
-    gdb_test_exact "maint demangle __ct__Q23foo3barFv" "foo::bar::bar(void)"
-    gdb_test_exact "maint demangle __ct__Q33foo3bar4bellFv" "foo::bar::bell::bell(void)"
-    gdb_test_exact "maint demangle __dl__3fooSFPv" "foo::operator delete(void *) static"
-    gdb_test_exact "maint demangle __dl__FPv" "operator delete(void *)"
-    gdb_test_exact "maint demangle __dt__10istrstreamFv" "istrstream::~istrstream(void)"
-
-    gdb_test_exact "maint demangle __dt__Q23foo3barFv" "foo::bar::~bar(void)"
-    gdb_test_exact "maint demangle __dt__Q33foo3bar4bellFv" "foo::bar::bell::~bell(void)"
-    gdb_test_exact "maint demangle __dv__3fooFR3foo" "foo::operator/(foo &)"
-    gdb_test_exact "maint demangle __dv__F7complexT1" "operator/(complex, complex)"
-    gdb_test_exact "maint demangle __eq__3fooFR3foo" "foo::operator==(foo &)"
-    gdb_test_exact "maint demangle __er__3fooFR3foo" "foo::operator^(foo &)"
-    gdb_test_exact "maint demangle __ge__3fooFR3foo" "foo::operator>=(foo &)"
-    gdb_test_exact "maint demangle __gt__3fooFR3foo" "foo::operator>(foo &)"
-    gdb_test_exact "maint demangle __le__3fooFR3foo" "foo::operator<=(foo &)"
-    gdb_test_exact "maint demangle __ls__3fooFR3foo" "foo::operator<<(foo &)"
-    gdb_test_exact "maint demangle __ls__7ostreamFP9streambuf" "ostream::operator<<(streambuf *)"
-
-    gdb_test "maint dem __ls__7ostreamFPCc" \
+    test_demangling_exact "lucid: __ct__8ifstreamFiPcT1" "ifstream::ifstream(int, char *, int)"
+
+    test_demangling_exact "lucid: __ct__Q23foo3barFv" "foo::bar::bar(void)"
+    test_demangling_exact "lucid: __ct__Q33foo3bar4bellFv" "foo::bar::bell::bell(void)"
+    test_demangling_exact "lucid: __dl__3fooSFPv" "foo::operator delete(void *) static"
+    test_demangling_exact "lucid: __dl__FPv" "operator delete(void *)"
+    test_demangling_exact "lucid: __dt__10istrstreamFv" "istrstream::~istrstream(void)"
+
+    test_demangling_exact "lucid: __dt__Q23foo3barFv" "foo::bar::~bar(void)"
+    test_demangling_exact "lucid: __dt__Q33foo3bar4bellFv" "foo::bar::bell::~bell(void)"
+    test_demangling_exact "lucid: __dv__3fooFR3foo" "foo::operator/(foo &)"
+    test_demangling_exact "lucid: __dv__F7complexT1" "operator/(complex, complex)"
+    test_demangling_exact "lucid: __eq__3fooFR3foo" "foo::operator==(foo &)"
+    test_demangling_exact "lucid: __er__3fooFR3foo" "foo::operator^(foo &)"
+    test_demangling_exact "lucid: __ge__3fooFR3foo" "foo::operator>=(foo &)"
+    test_demangling_exact "lucid: __gt__3fooFR3foo" "foo::operator>(foo &)"
+    test_demangling_exact "lucid: __le__3fooFR3foo" "foo::operator<=(foo &)"
+    test_demangling_exact "lucid: __ls__3fooFR3foo" "foo::operator<<(foo &)"
+    test_demangling_exact "lucid: __ls__7ostreamFP9streambuf" "ostream::operator<<(streambuf *)"
+
+    test_demangling "lucid: __ls__7ostreamFPCc" \
        "ostream::operator<<\[(\]+(const char|char const) \[*\]+\[)\]+"
-    gdb_test_exact "maint demangle __ls__7ostreamFPFR3ios_R3ios" "ostream::operator<<(ios &(*)(ios &))"
-    gdb_test_exact "maint demangle __ls__7ostreamFPv" "ostream::operator<<(void *)"
-    gdb_test_exact "maint demangle __ls__7ostreamFUi" "ostream::operator<<(unsigned int)"
-    gdb_test_exact "maint demangle __ls__7ostreamFUl" "ostream::operator<<(unsigned long)"
-    gdb_test_exact "maint demangle __ls__7ostreamFd" "ostream::operator<<(double)"
-    gdb_test_exact "maint demangle __ls__7ostreamFf" "ostream::operator<<(float)"
-    gdb_test_exact "maint demangle __ls__7ostreamFi" "ostream::operator<<(int)"
-    gdb_test_exact "maint demangle __ls__7ostreamFl" "ostream::operator<<(long)"
-    gdb_test_exact "maint demangle __ls__FR7ostream7complex" "operator<<(ostream &, complex)"
-    gdb_test_exact "maint demangle __lt__3fooFR3foo" "foo::operator<(foo &)"
-    gdb_test_exact "maint demangle __md__3fooFR3foo" "foo::operator%(foo &)"
-    gdb_test_exact "maint demangle __mi__3fooFR3foo" "foo::operator-(foo &)"
-    gdb_test_exact "maint demangle __ml__3fooFR3foo" "foo::operator*(foo &)"
-    gdb_test_exact "maint demangle __ml__F7complexT1" "operator*(complex, complex)"
-    gdb_test_exact "maint demangle __mm__3fooFi" "foo::operator--(int)"
-    gdb_test_exact "maint demangle __ne__3fooFR3foo" "foo::operator!=(foo &)"
-    gdb_test_exact "maint demangle __nt__3fooFv" "foo::operator!(void)"
-    gdb_test_exact "maint demangle __nw__3fooSFi" "foo::operator new(int) static"
-    gdb_test_exact "maint demangle __nw__FUi" "operator new(unsigned int)"
-    gdb_test_exact "maint demangle __nw__FUiPv" "operator new(unsigned int, void *)"
-    gdb_test_exact "maint demangle __oo__3fooFR3foo" "foo::operator||(foo &)"
-    gdb_test_exact "maint demangle __opPc__3fooFv" "foo::operator char *(void)"
-    gdb_test_exact "maint demangle __opi__3fooFv" "foo::operator int(void)"
-    gdb_test_exact "maint demangle __or__3fooFR3foo" "foo::operator|(foo &)"
-
-    gdb_test_exact "maint demangle __pl__3fooFR3foo" "foo::operator+(foo &)"
-    gdb_test_exact "maint demangle __pp__3fooFi" "foo::operator++(int)"
-    gdb_test_exact "maint demangle __pt__3fooFv" "foo::operator->(void)"
-    gdb_test_exact "maint demangle __rm__3fooFR3foo" "foo::operator->*(foo &)"
-    gdb_test_exact "maint demangle __rs__3fooFR3foo" "foo::operator>>(foo &)"
-    gdb_test_exact "maint demangle __rs__7istreamFP9streambuf" "istream::operator>>(streambuf *)"
-    gdb_test_exact "maint demangle __rs__7istreamFPFR3ios_R3ios" "istream::operator>>(ios &(*)(ios &))"
-    gdb_test_exact "maint demangle __rs__7istreamFPFR7istream_R7istream" "istream::operator>>(istream &(*)(istream &))"
-    gdb_test_exact "maint demangle __rs__7istreamFPUc" "istream::operator>>(unsigned char *)"
-    gdb_test_exact "maint demangle __rs__7istreamFPc" "istream::operator>>(char *)"
-    gdb_test_exact "maint demangle __rs__7istreamFRUi" "istream::operator>>(unsigned int &)"
-    gdb_test_exact "maint demangle __rs__7istreamFRUl" "istream::operator>>(unsigned long &)"
-    gdb_test_exact "maint demangle __rs__7istreamFRUs" "istream::operator>>(unsigned short &)"
-    gdb_test_exact "maint demangle __rs__7istreamFRd" "istream::operator>>(double &)"
-    gdb_test_exact "maint demangle __rs__7istreamFRf" "istream::operator>>(float &)"
-    gdb_test_exact "maint demangle __rs__7istreamFRi" "istream::operator>>(int &)"
-    gdb_test_exact "maint demangle __rs__7istreamFRl" "istream::operator>>(long &)"
-    gdb_test_exact "maint demangle __rs__7istreamFRs" "istream::operator>>(short &)"
-    gdb_test_exact "maint demangle __rs__FR7istreamR7complex" "operator>>(istream &, complex &)"
-    gdb_test "maint dem __vc__3fooFR3foo" "foo::operator\\\[\\\]\\(foo &\\)"
-    gdb_test_exact "maint demangle __vtbl__10istrstream" "istrstream virtual table"
-    gdb_test_exact "maint demangle __vtbl__17ostream__iostream__19iostream_withassign" "iostream_withassign::ostream__iostream virtual table"
-
-    gdb_test_exact "maint demangle __vtbl__3ios" "ios virtual table"
-    gdb_test_exact "maint demangle __vtbl__3ios__13strstreambase" "strstreambase::ios virtual table"
+    test_demangling_exact "lucid: __ls__7ostreamFPFR3ios_R3ios" "ostream::operator<<(ios &(*)(ios &))"
+    test_demangling_exact "lucid: __ls__7ostreamFPv" "ostream::operator<<(void *)"
+    test_demangling_exact "lucid: __ls__7ostreamFUi" "ostream::operator<<(unsigned int)"
+    test_demangling_exact "lucid: __ls__7ostreamFUl" "ostream::operator<<(unsigned long)"
+    test_demangling_exact "lucid: __ls__7ostreamFd" "ostream::operator<<(double)"
+    test_demangling_exact "lucid: __ls__7ostreamFf" "ostream::operator<<(float)"
+    test_demangling_exact "lucid: __ls__7ostreamFi" "ostream::operator<<(int)"
+    test_demangling_exact "lucid: __ls__7ostreamFl" "ostream::operator<<(long)"
+    test_demangling_exact "lucid: __ls__FR7ostream7complex" "operator<<(ostream &, complex)"
+    test_demangling_exact "lucid: __lt__3fooFR3foo" "foo::operator<(foo &)"
+    test_demangling_exact "lucid: __md__3fooFR3foo" "foo::operator%(foo &)"
+    test_demangling_exact "lucid: __mi__3fooFR3foo" "foo::operator-(foo &)"
+    test_demangling_exact "lucid: __ml__3fooFR3foo" "foo::operator*(foo &)"
+    test_demangling_exact "lucid: __ml__F7complexT1" "operator*(complex, complex)"
+    test_demangling_exact "lucid: __mm__3fooFi" "foo::operator--(int)"
+    test_demangling_exact "lucid: __ne__3fooFR3foo" "foo::operator!=(foo &)"
+    test_demangling_exact "lucid: __nt__3fooFv" "foo::operator!(void)"
+    test_demangling_exact "lucid: __nw__3fooSFi" "foo::operator new(int) static"
+    test_demangling_exact "lucid: __nw__FUi" "operator new(unsigned int)"
+    test_demangling_exact "lucid: __nw__FUiPv" "operator new(unsigned int, void *)"
+    test_demangling_exact "lucid: __oo__3fooFR3foo" "foo::operator||(foo &)"
+    test_demangling_exact "lucid: __opPc__3fooFv" "foo::operator char *(void)"
+    test_demangling_exact "lucid: __opi__3fooFv" "foo::operator int(void)"
+    test_demangling_exact "lucid: __or__3fooFR3foo" "foo::operator|(foo &)"
+
+    test_demangling_exact "lucid: __pl__3fooFR3foo" "foo::operator+(foo &)"
+    test_demangling_exact "lucid: __pp__3fooFi" "foo::operator++(int)"
+    test_demangling_exact "lucid: __pt__3fooFv" "foo::operator->(void)"
+    test_demangling_exact "lucid: __rm__3fooFR3foo" "foo::operator->*(foo &)"
+    test_demangling_exact "lucid: __rs__3fooFR3foo" "foo::operator>>(foo &)"
+    test_demangling_exact "lucid: __rs__7istreamFP9streambuf" "istream::operator>>(streambuf *)"
+    test_demangling_exact "lucid: __rs__7istreamFPFR3ios_R3ios" "istream::operator>>(ios &(*)(ios &))"
+    test_demangling_exact "lucid: __rs__7istreamFPFR7istream_R7istream" "istream::operator>>(istream &(*)(istream &))"
+    test_demangling_exact "lucid: __rs__7istreamFPUc" "istream::operator>>(unsigned char *)"
+    test_demangling_exact "lucid: __rs__7istreamFPc" "istream::operator>>(char *)"
+    test_demangling_exact "lucid: __rs__7istreamFRUi" "istream::operator>>(unsigned int &)"
+    test_demangling_exact "lucid: __rs__7istreamFRUl" "istream::operator>>(unsigned long &)"
+    test_demangling_exact "lucid: __rs__7istreamFRUs" "istream::operator>>(unsigned short &)"
+    test_demangling_exact "lucid: __rs__7istreamFRd" "istream::operator>>(double &)"
+    test_demangling_exact "lucid: __rs__7istreamFRf" "istream::operator>>(float &)"
+    test_demangling_exact "lucid: __rs__7istreamFRi" "istream::operator>>(int &)"
+    test_demangling_exact "lucid: __rs__7istreamFRl" "istream::operator>>(long &)"
+    test_demangling_exact "lucid: __rs__7istreamFRs" "istream::operator>>(short &)"
+    test_demangling_exact "lucid: __rs__FR7istreamR7complex" "operator>>(istream &, complex &)"
+    test_demangling "lucid: __vc__3fooFR3foo" "foo::operator\\\[\\\]\\(foo &\\)"
+    test_demangling_exact "lucid: __vtbl__10istrstream" "istrstream virtual table"
+    test_demangling_exact "lucid: __vtbl__17ostream__iostream__19iostream_withassign" "iostream_withassign::ostream__iostream virtual table"
+
+    test_demangling_exact "lucid: __vtbl__3ios" "ios virtual table"
+    test_demangling_exact "lucid: __vtbl__3ios__13strstreambase" "strstreambase::ios virtual table"
 
     # GDB 930414 demangles this as t_cc_main_ (obviously wrong).
     # GDB 930701 gets into an infinite loop.
     # GDB 930727 says "Can't demangle".
     # What is the correct demangling?  FIXME.
     setup_xfail "*-*-*"
-    gdb_test_exact "maint demangle __vtbl__3foo__vt_cc_main_" ""
-
-    gdb_test_exact "maint demangle abs__F7complex" "abs(complex)"
-    gdb_test_exact "maint demangle allocate__9streambufFv" "streambuf::allocate(void)"
-    gdb_test_exact "maint demangle attach__11fstreambaseFi" "fstreambase::attach(int)"
-    gdb_test_exact "maint demangle bitalloc__3iosSFv" "ios::bitalloc(void) static"
-    gdb_test_exact "maint demangle chr__FiT1" "chr(int, int)"
-    gdb_test_exact "maint demangle complex_error__FR11c_exception" "complex_error(c_exception &)"
-    gdb_test_exact "maint demangle complexfunc2__FPFPc_i" "complexfunc2(int (*)(char *))"
-    gdb_test_exact "maint demangle complexfunc3__FPFPFPl_s_i" "complexfunc3(int (*)(short (*)(long *)))"
-
-    gdb_test_exact "maint demangle complexfunc4__FPFPFPc_s_i" "complexfunc4(int (*)(short (*)(char *)))"
-    gdb_test_exact "maint demangle complexfunc5__FPFPc_PFl_i" "complexfunc5(int (*(*)(char *))(long))"
-    gdb_test_exact "maint demangle complexfunc6__FPFPi_PFl_i" "complexfunc6(int (*(*)(int *))(long))"
-    gdb_test_exact "maint demangle complexfunc7__FPFPFPc_i_PFl_i" "complexfunc7(int (*(*)(int (*)(char *)))(long))"
-    gdb_test_exact "maint demangle complicated_put__7ostreamFc" "ostream::complicated_put(char)"
-    gdb_test_exact "maint demangle conv10__FlPc" "conv10(long, char *)"
-    gdb_test_exact "maint demangle conv16__FUlPc" "conv16(unsigned long, char *)"
-    gdb_test_exact "maint demangle dec__FR3ios" "dec(ios &)"
-    gdb_test_exact "maint demangle dec__Fli" "dec(long, int)"
-    gdb_test_exact "maint demangle dofield__FP7ostreamPciT2T3" "dofield(ostream *, char *, int, char *, int)"
-
-    gdb_test_exact "maint demangle flags__3iosFl" "ios::flags(long)"
-    gdb_test_exact "maint demangle flags__3iosFv" "ios::flags(void)"
-    gdb_test_exact "maint demangle foo__FiN31" "foo(int, int, int, int)"
-    gdb_test_exact "maint demangle foo__FiR3fooT1T2T1T2" "foo(int, foo &, int, foo &, int, foo &)"
-    gdb_test_exact "maint demangle foo___3barFl" "bar::foo_(long)"
-    gdb_test "maint dem form__FPCce" "form\[(\]+(const char|char const) \[*\]+,...\[)\]+"
-    gdb_test_exact "maint demangle get__7istreamFPcic" "istream::get(char *, int, char)"
-    gdb_test_exact "maint demangle get__7istreamFR9streambufc" "istream::get(streambuf &, char)"
-    gdb_test_exact "maint demangle get_complicated__7istreamFRUc" "istream::get_complicated(unsigned char &)"
-    gdb_test_exact "maint demangle get_complicated__7istreamFRc" "istream::get_complicated(char &)"
-    gdb_test_exact "maint demangle getline__7istreamFPUcic" "istream::getline(unsigned char *, int, char)"
-    gdb_test_exact "maint demangle getline__7istreamFPcic" "istream::getline(char *, int, char)"
-
-    gdb_test_exact "maint demangle ignore__7istreamFiT1" "istream::ignore(int, int)"
-    gdb_test_exact "maint demangle init__12strstreambufFPciT1" "strstreambuf::init(char *, int, char *)"
-    gdb_test_exact "maint demangle init__3iosFP9streambuf" "ios::init(streambuf *)"
-    gdb_test_exact "maint demangle initcount__13Iostream_init" "Iostream_init::initcount"
-    gdb_test_exact "maint demangle ipfx__7istreamFi" "istream::ipfx(int)"
-    gdb_test_exact "maint demangle ls_complicated__7ostreamFUc" "ostream::ls_complicated(unsigned char)"
-    gdb_test_exact "maint demangle ls_complicated__7ostreamFc" "ostream::ls_complicated(char)"
-    gdb_test "maint dem open__11fstreambaseFPCciT2" \
+    test_demangling_exact "lucid: __vtbl__3foo__vt_cc_main_" ""
+
+    test_demangling_exact "lucid: abs__F7complex" "abs(complex)"
+    test_demangling_exact "lucid: allocate__9streambufFv" "streambuf::allocate(void)"
+    test_demangling_exact "lucid: attach__11fstreambaseFi" "fstreambase::attach(int)"
+    test_demangling_exact "lucid: bitalloc__3iosSFv" "ios::bitalloc(void) static"
+    test_demangling_exact "lucid: chr__FiT1" "chr(int, int)"
+    test_demangling_exact "lucid: complex_error__FR11c_exception" "complex_error(c_exception &)"
+    test_demangling_exact "lucid: complexfunc2__FPFPc_i" "complexfunc2(int (*)(char *))"
+    test_demangling_exact "lucid: complexfunc3__FPFPFPl_s_i" "complexfunc3(int (*)(short (*)(long *)))"
+
+    test_demangling_exact "lucid: complexfunc4__FPFPFPc_s_i" "complexfunc4(int (*)(short (*)(char *)))"
+    test_demangling_exact "lucid: complexfunc5__FPFPc_PFl_i" "complexfunc5(int (*(*)(char *))(long))"
+    test_demangling_exact "lucid: complexfunc6__FPFPi_PFl_i" "complexfunc6(int (*(*)(int *))(long))"
+    test_demangling_exact "lucid: complexfunc7__FPFPFPc_i_PFl_i" "complexfunc7(int (*(*)(int (*)(char *)))(long))"
+    test_demangling_exact "lucid: complicated_put__7ostreamFc" "ostream::complicated_put(char)"
+    test_demangling_exact "lucid: conv10__FlPc" "conv10(long, char *)"
+    test_demangling_exact "lucid: conv16__FUlPc" "conv16(unsigned long, char *)"
+    test_demangling_exact "lucid: dec__FR3ios" "dec(ios &)"
+    test_demangling_exact "lucid: dec__Fli" "dec(long, int)"
+    test_demangling_exact "lucid: dofield__FP7ostreamPciT2T3" "dofield(ostream *, char *, int, char *, int)"
+
+    test_demangling_exact "lucid: flags__3iosFl" "ios::flags(long)"
+    test_demangling_exact "lucid: flags__3iosFv" "ios::flags(void)"
+    test_demangling_exact "lucid: foo__FiN31" "foo(int, int, int, int)"
+    test_demangling_exact "lucid: foo__FiR3fooT1T2T1T2" "foo(int, foo &, int, foo &, int, foo &)"
+    test_demangling_exact "lucid: foo___3barFl" "bar::foo_(long)"
+    test_demangling "lucid: form__FPCce" "form\[(\]+(const char|char const) \[*\]+,...\[)\]+"
+    test_demangling_exact "lucid: get__7istreamFPcic" "istream::get(char *, int, char)"
+    test_demangling_exact "lucid: get__7istreamFR9streambufc" "istream::get(streambuf &, char)"
+    test_demangling_exact "lucid: get_complicated__7istreamFRUc" "istream::get_complicated(unsigned char &)"
+    test_demangling_exact "lucid: get_complicated__7istreamFRc" "istream::get_complicated(char &)"
+    test_demangling_exact "lucid: getline__7istreamFPUcic" "istream::getline(unsigned char *, int, char)"
+    test_demangling_exact "lucid: getline__7istreamFPcic" "istream::getline(char *, int, char)"
+
+    test_demangling_exact "lucid: ignore__7istreamFiT1" "istream::ignore(int, int)"
+    test_demangling_exact "lucid: init__12strstreambufFPciT1" "strstreambuf::init(char *, int, char *)"
+    test_demangling_exact "lucid: init__3iosFP9streambuf" "ios::init(streambuf *)"
+    test_demangling_exact "lucid: initcount__13Iostream_init" "Iostream_init::initcount"
+    test_demangling_exact "lucid: ipfx__7istreamFi" "istream::ipfx(int)"
+    test_demangling_exact "lucid: ls_complicated__7ostreamFUc" "ostream::ls_complicated(unsigned char)"
+    test_demangling_exact "lucid: ls_complicated__7ostreamFc" "ostream::ls_complicated(char)"
+    test_demangling "lucid: open__11fstreambaseFPCciT2" \
        "fstreambase::open\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
-    gdb_test "maint dem open__7filebufFPCciT2" \
+    test_demangling "lucid: open__7filebufFPCciT2" \
        "filebuf::open\[(\]+(const char|char const) \[*\]+, int, int\[)\]+"
 
-    gdb_test_exact "maint demangle overload1arg__FSc" "overload1arg(signed char)"
-    gdb_test_exact "maint demangle overload1arg__FUc" "overload1arg(unsigned char)"
-    gdb_test_exact "maint demangle overload1arg__FUi" "overload1arg(unsigned int)"
-    gdb_test_exact "maint demangle overload1arg__FUl" "overload1arg(unsigned long)"
-    gdb_test_exact "maint demangle overload1arg__FUs" "overload1arg(unsigned short)"
-    gdb_test_exact "maint demangle overload1arg__Fc" "overload1arg(char)"
-    gdb_test_exact "maint demangle overload1arg__Fd" "overload1arg(double)"
-    gdb_test_exact "maint demangle overload1arg__Ff" "overload1arg(float)"
-    gdb_test_exact "maint demangle overload1arg__Fi" "overload1arg(int)"
-    gdb_test_exact "maint demangle overload1arg__Fl" "overload1arg(long)"
-    gdb_test_exact "maint demangle overload1arg__Fs" "overload1arg(short)"
-    gdb_test_exact "maint demangle overload1arg__Fv" "overload1arg(void)"
-    gdb_test_exact "maint demangle overloadargs__FiN21" "overloadargs(int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__FiN31" "overloadargs(int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__FiN41" "overloadargs(int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__FiN51" "overloadargs(int, int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__FiN61" "overloadargs(int, int, int, int, int, int, int)"
-
-    gdb_test_exact "maint demangle overloadargs__FiN71" "overloadargs(int, int, int, int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__FiN81" "overloadargs(int, int, int, int, int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__FiN91" "overloadargs(int, int, int, int, int, int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__FiN91N11" "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"
-    gdb_test_exact "maint demangle overloadargs__FiT1" "overloadargs(int, int)"
-    gdb_test_exact "maint demangle polar__FdT1" "polar(double, double)"
-    gdb_test_exact "maint demangle pow__F7complexT1" "pow(complex, complex)"
-    gdb_test_exact "maint demangle pow__F7complexd" "pow(complex, double)"
-    gdb_test_exact "maint demangle pow__F7complexi" "pow(complex, int)"
-    gdb_test_exact "maint demangle pow__Fd7complex" "pow(double, complex)"
-    gdb_test_exact "maint demangle pstart__FPciT2" "pstart(char *, int, int)"
-    gdb_test_exact "maint demangle put__7ostreamFc" "ostream::put(char)"
-
-    gdb_test_exact "maint demangle read__7istreamFPci" "istream::read(char *, int)"
-    gdb_test_exact "maint demangle resetiosflags__FR3iosl" "resetiosflags(ios &, long)"
-    gdb_test_exact "maint demangle restore_errno__FRi" "restore_errno(int &)"
-    gdb_test_exact "maint demangle rs_complicated__7istreamFRUc" "istream::rs_complicated(unsigned char &)"
-    gdb_test_exact "maint demangle rs_complicated__7istreamFRc" "istream::rs_complicated(char &)"
-    gdb_test_exact "maint demangle seekg__7istreamFl8seek_dir" "istream::seekg(long, seek_dir)"
-    gdb_test_exact "maint demangle seekoff__12strstreambufFl8seek_diri" "strstreambuf::seekoff(long, seek_dir, int)"
-    gdb_test_exact "maint demangle seekoff__9streambufFlQ2_3ios12ios_seek_diri" "streambuf::seekoff(long, ios::ios_seek_dir, int)"
-    gdb_test_exact "maint demangle seekpos__9streambufFli" "streambuf::seekpos(long, int)"
-    gdb_test_exact "maint demangle set_new_handler__FPFv_v" "set_new_handler(void (*)(void))"
-    gdb_test_exact "maint demangle setb__9streambufFPcT1i" "streambuf::setb(char *, char *, int)"
-
-    gdb_test_exact "maint demangle setb__FR3iosi" "setb(ios &, int)"
-    gdb_test_exact "maint demangle setbuf__11fstreambaseFPci" "fstreambase::setbuf(char *, int)"
-    gdb_test_exact "maint demangle setbuf__9streambufFPUci" "streambuf::setbuf(unsigned char *, int)"
-    gdb_test_exact "maint demangle setbuf__9streambufFPciT2" "streambuf::setbuf(char *, int, int)"
-    gdb_test_exact "maint demangle setf__3iosFlT1" "ios::setf(long, long)"
-    gdb_test_exact "maint demangle setfill__FR3iosi" "setfill(ios &, int)"
-    gdb_test_exact "maint demangle setg__9streambufFPcN21" "streambuf::setg(char *, char *, char *)"
-    gdb_test_exact "maint demangle setp__9streambufFPcT1" "streambuf::setp(char *, char *)"
-
-    gdb_test "maint dem sputn__9streambufFPCci" \
+    test_demangling_exact "lucid: overload1arg__FSc" "overload1arg(signed char)"
+    test_demangling_exact "lucid: overload1arg__FUc" "overload1arg(unsigned char)"
+    test_demangling_exact "lucid: overload1arg__FUi" "overload1arg(unsigned int)"
+    test_demangling_exact "lucid: overload1arg__FUl" "overload1arg(unsigned long)"
+    test_demangling_exact "lucid: overload1arg__FUs" "overload1arg(unsigned short)"
+    test_demangling_exact "lucid: overload1arg__Fc" "overload1arg(char)"
+    test_demangling_exact "lucid: overload1arg__Fd" "overload1arg(double)"
+    test_demangling_exact "lucid: overload1arg__Ff" "overload1arg(float)"
+    test_demangling_exact "lucid: overload1arg__Fi" "overload1arg(int)"
+    test_demangling_exact "lucid: overload1arg__Fl" "overload1arg(long)"
+    test_demangling_exact "lucid: overload1arg__Fs" "overload1arg(short)"
+    test_demangling_exact "lucid: overload1arg__Fv" "overload1arg(void)"
+    test_demangling_exact "lucid: overloadargs__FiN21" "overloadargs(int, int, int)"
+    test_demangling_exact "lucid: overloadargs__FiN31" "overloadargs(int, int, int, int)"
+    test_demangling_exact "lucid: overloadargs__FiN41" "overloadargs(int, int, int, int, int)"
+    test_demangling_exact "lucid: overloadargs__FiN51" "overloadargs(int, int, int, int, int, int)"
+    test_demangling_exact "lucid: overloadargs__FiN61" "overloadargs(int, int, int, int, int, int, int)"
+
+    test_demangling_exact "lucid: overloadargs__FiN71" "overloadargs(int, int, int, int, int, int, int, int)"
+    test_demangling_exact "lucid: overloadargs__FiN81" "overloadargs(int, int, int, int, int, int, int, int, int)"
+    test_demangling_exact "lucid: overloadargs__FiN91" "overloadargs(int, int, int, int, int, int, int, int, int, int)"
+    test_demangling_exact "lucid: overloadargs__FiN91N11" "overloadargs(int, int, int, int, int, int, int, int, int, int, int)"
+    test_demangling_exact "lucid: overloadargs__FiT1" "overloadargs(int, int)"
+    test_demangling_exact "lucid: polar__FdT1" "polar(double, double)"
+    test_demangling_exact "lucid: pow__F7complexT1" "pow(complex, complex)"
+    test_demangling_exact "lucid: pow__F7complexd" "pow(complex, double)"
+    test_demangling_exact "lucid: pow__F7complexi" "pow(complex, int)"
+    test_demangling_exact "lucid: pow__Fd7complex" "pow(double, complex)"
+    test_demangling_exact "lucid: pstart__FPciT2" "pstart(char *, int, int)"
+    test_demangling_exact "lucid: put__7ostreamFc" "ostream::put(char)"
+
+    test_demangling_exact "lucid: read__7istreamFPci" "istream::read(char *, int)"
+    test_demangling_exact "lucid: resetiosflags__FR3iosl" "resetiosflags(ios &, long)"
+    test_demangling_exact "lucid: restore_errno__FRi" "restore_errno(int &)"
+    test_demangling_exact "lucid: rs_complicated__7istreamFRUc" "istream::rs_complicated(unsigned char &)"
+    test_demangling_exact "lucid: rs_complicated__7istreamFRc" "istream::rs_complicated(char &)"
+    test_demangling_exact "lucid: seekg__7istreamFl8seek_dir" "istream::seekg(long, seek_dir)"
+    test_demangling_exact "lucid: seekoff__12strstreambufFl8seek_diri" "strstreambuf::seekoff(long, seek_dir, int)"
+    test_demangling_exact "lucid: seekoff__9streambufFlQ2_3ios12ios_seek_diri" "streambuf::seekoff(long, ios::ios_seek_dir, int)"
+    test_demangling_exact "lucid: seekpos__9streambufFli" "streambuf::seekpos(long, int)"
+    test_demangling_exact "lucid: set_new_handler__FPFv_v" "set_new_handler(void (*)(void))"
+    test_demangling_exact "lucid: setb__9streambufFPcT1i" "streambuf::setb(char *, char *, int)"
+
+    test_demangling_exact "lucid: setb__FR3iosi" "setb(ios &, int)"
+    test_demangling_exact "lucid: setbuf__11fstreambaseFPci" "fstreambase::setbuf(char *, int)"
+    test_demangling_exact "lucid: setbuf__9streambufFPUci" "streambuf::setbuf(unsigned char *, int)"
+    test_demangling_exact "lucid: setbuf__9streambufFPciT2" "streambuf::setbuf(char *, int, int)"
+    test_demangling_exact "lucid: setf__3iosFlT1" "ios::setf(long, long)"
+    test_demangling_exact "lucid: setfill__FR3iosi" "setfill(ios &, int)"
+    test_demangling_exact "lucid: setg__9streambufFPcN21" "streambuf::setg(char *, char *, char *)"
+    test_demangling_exact "lucid: setp__9streambufFPcT1" "streambuf::setp(char *, char *)"
+
+    test_demangling "lucid: sputn__9streambufFPCci" \
        "streambuf::sputn\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-    gdb_test "maint dem str__FPCci" \
+    test_demangling "lucid: str__FPCci" \
        "str\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-    gdb_test_exact "maint demangle tie__3iosFP7ostream" "ios::tie(ostream *)"
-    gdb_test_exact "maint demangle uconv10__FUlPc" "uconv10(unsigned long, char *)"
+    test_demangling_exact "lucid: tie__3iosFP7ostream" "ios::tie(ostream *)"
+    test_demangling_exact "lucid: uconv10__FUlPc" "uconv10(unsigned long, char *)"
 
-    gdb_test "maint dem write__7ostreamFPCci" \
+    test_demangling "lucid: write__7ostreamFPCci" \
        "ostream::write\[(\]+(const char|char const) \[*\]+, int\[)\]+"
-    gdb_test_exact "maint demangle xget__7istreamFPc" "istream::xget(char *)"
-    gdb_test_exact "maint demangle xsgetn__9streambufFPci" "streambuf::xsgetn(char *, int)"
-    gdb_test "maint dem xsputn__9streambufFPCci" \
+    test_demangling_exact "lucid: xget__7istreamFPc" "istream::xget(char *)"
+    test_demangling_exact "lucid: xsgetn__9streambufFPci" "streambuf::xsgetn(char *, int)"
+    test_demangling "lucid: xsputn__9streambufFPCci" \
        "streambuf::xsputn\[(\]+(const char|char const) \[*\]+, int\[)\]+"
+
+    test_demangling_exact "lucid: _Utf390_1__1_9223372036854775807__9223372036854775" \
+           "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
 }
 
 #
@@ -731,759 +798,732 @@ proc test_lucid_style_demangling {} {
 #
 
 proc test_arm_style_demangling {} {
-    global gdb_prompt
-
-    # Set the demangling style to "arm" and then check to make sure
-    # it really got set.  Return if the style failed to get set for
-    # some reason.
-
-    send_gdb "set demangle-style arm\n"
-    gdb_expect {
-       -re "set demangle-style arm\[\r\n\]+$gdb_prompt $" {}
-       -re ".*$gdb_prompt $" { fail "set demangle-style arm failed" ; return }
-       timeout { fail "set demangle-style arm failed (timeout)" ; return }
-    }
-
-    send_gdb "show demangle-style\n"
-    gdb_expect {
-       -re "The current C\[+\]+ demangling style is \"arm\".\r\n$gdb_prompt $" {}
-       -re ".*$gdb_prompt $" { fail "demangling style not set to arm" }
-       timeout { fail "show demangle-style timed out" }
-    }
-
-    gdb_test_exact "maint demangle __dt__21T5__pt__11_PFiPPdPv_iFv" "T5<int (*)(int, double **, void *)>::~T5(void)"
+    test_demangling_exact "arm: __dt__21T5__pt__11_PFiPPdPv_iFv" "T5<int (*)(int, double **, void *)>::~T5(void)"
 
-    gdb_test_exact "maint demangle __ct__1cFi" "c::c(int)"
+    test_demangling_exact "arm: __ct__1cFi" "c::c(int)"
 
-    gdb_test_exact "maint demangle __dt__11T5__pt__2_iFv" "T5<int>::~T5(void)"
+    test_demangling_exact "arm: __dt__11T5__pt__2_iFv" "T5<int>::~T5(void)"
 
-    gdb_test_exact "maint demangle __dt__11T5__pt__2_cFv" "T5<char>::~T5(void)"
+    test_demangling_exact "arm: __dt__11T5__pt__2_cFv" "T5<char>::~T5(void)"
 
-    gdb_test_exact "maint demangle __ct__2T2Fi" "T2::T2(int)"
-    gdb_test_exact "maint demangle __dt__2T1Fv" "T1::~T1(void)"
+    test_demangling_exact "arm: __ct__2T2Fi" "T2::T2(int)"
+    test_demangling_exact "arm: __dt__2T1Fv" "T1::~T1(void)"
 
-    gdb_test_exact "maint demangle __dt__12T5__pt__3_1xFv" "T5<x>::~T5(void)"
+    test_demangling_exact "arm: __dt__12T5__pt__3_1xFv" "T5<x>::~T5(void)"
 
-    gdb_test_exact "maint demangle __dt__17T5__pt__8_PFcPv_iFv" "T5<int (*)(char, void *)>::~T5(void)"
+    test_demangling_exact "arm: __dt__17T5__pt__8_PFcPv_iFv" "T5<int (*)(char, void *)>::~T5(void)"
 
-    gdb_test "maint dem g__FP1cPC1cT1" \
+    test_demangling "arm: g__FP1cPC1cT1" \
        "g\[(\]+c *\[*\]+, (const c|c const) *\[*\]+, c *\[*\]+\[)\]+"
-    gdb_test "maint dem g__FPUlPCUlT1" \
+    test_demangling "arm: g__FPUlPCUlT1" \
        "g\[(\]+unsigned long \[*\]+, (const unsigned long|unsigned long const) \[*\]+, unsigned long \[*\]+\[)\]+"
-    gdb_test "maint dem g__FPUiPCUiT1" \
+    test_demangling "arm: g__FPUiPCUiT1" \
        "g\[(\]+unsigned int \[*\]+, (const unsigned int|unsigned int const) \[*\]+, unsigned int \[*\]+\[)\]+"
-    gdb_test "maint dem g__FPUsPCUsT1" \
+    test_demangling "arm: g__FPUsPCUsT1" \
        "g\[(\]+unsigned short \[*\]+, (const unsigned short|unsigned short const) \[*\]+, unsigned short \[*\]+\[)\]+"
-    gdb_test "maint dem g__FPUcPCUcT1" \
+    test_demangling "arm: g__FPUcPCUcT1" \
        "g\[(\]+unsigned char \[*\]+, (const unsigned char|unsigned char const) \[*\]+, unsigned char \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1TPlPClT2" \
+    test_demangling "arm: g__F1TPlPClT2" \
        "g\[(\]+T, long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1RRlRClT2" \
+    test_demangling "arm: g__F1RRlRClT2" \
        "g\[(\]+R, long &, (const long|long const) &, long &\[)\]+"
-    gdb_test "maint dem g__F1TPiPCiT2" \
+    test_demangling "arm: g__F1TPiPCiT2" \
        "g\[(\]+T, int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1RRiRCiT2" \
+    test_demangling "arm: g__F1RRiRCiT2" \
        "g\[(\]+R, int &, (const int|int const) &, int &\[)\]+"
-    gdb_test "maint dem g__F1TPsPCsT2" \
+    test_demangling "arm: g__F1TPsPCsT2" \
        "g\[(\]+T, short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1RRsRCsT2" \
+    test_demangling "arm: g__F1RRsRCsT2" \
        "g\[(\]+R, short &, (const short|short const) &, short &\[)\]+"
-    gdb_test "maint dem g__F1TPcPCcT2" \
+    test_demangling "arm: g__F1TPcPCcT2" \
        "g\[(\]+T, char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1RRcRCcT2" \
+    test_demangling "arm: g__F1RRcRCcT2" \
        "g\[(\]+R, char &, (const char|char const) &, char &\[)\]+"
 
-    gdb_test_exact "maint demangle __ct__21T5__pt__11_PFiPPdPv_iFi" "T5<int (*)(int, double **, void *)>::T5(int)"
+    test_demangling_exact "arm: __ct__21T5__pt__11_PFiPPdPv_iFi" "T5<int (*)(int, double **, void *)>::T5(int)"
 
-    gdb_test "maint dem __gt__FRC2T2c" \
+    test_demangling "arm: __gt__FRC2T2c" \
        "operator>\[(\]+(const T2|T2 const) &, char\[)\]+"
-    gdb_test "maint dem __ge__FRC2T2c" \
+    test_demangling "arm: __ge__FRC2T2c" \
        "operator>=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    gdb_test "maint dem __lt__FRC2T2c" \
+    test_demangling "arm: __lt__FRC2T2c" \
        "operator<\[(\]+(const T2|T2 const) &, char\[)\]+"
 
-    gdb_test "maint dem __le__FRC2T2c" \
+    test_demangling "arm: __le__FRC2T2c" \
        "operator<=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    gdb_test "maint dem __ne__FRC2T2c" \
+    test_demangling "arm: __ne__FRC2T2c" \
        "operator!=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    gdb_test "maint dem __eq__FRC2T2c" \
+    test_demangling "arm: __eq__FRC2T2c" \
        "operator==\[(\]+(const T2|T2 const) &, char\[)\]+"
-    gdb_test_exact "maint demangle __amd__FR2T2i" "operator%=(T2 &, int)"
-    gdb_test_exact "maint demangle __adv__FR2T2i" "operator/=(T2 &, int)"
-    gdb_test_exact "maint demangle __amu__FR2T2i" "operator*=(T2 &, int)"
-    gdb_test_exact "maint demangle __ami__FR2T2i" "operator-=(T2 &, int)"
-    gdb_test_exact "maint demangle __apl__FR2T2i" "operator+=(T2 &, int)"
-    gdb_test_exact "maint demangle __nw__2T1SFUi" "T1::operator new(unsigned int) static"
-    gdb_test_exact "maint demangle __dl__2T1SFPv" "T1::operator delete(void *) static"
-    gdb_test_exact "maint demangle put__2T7SFi" "T7::put(int) static"
-
-    gdb_test_exact "maint demangle __dl__12T5__pt__3_1xSFPv" "T5<x>::operator delete(void *) static"
-
-    gdb_test_exact "maint demangle h__FUc" "h(unsigned char)"
-    gdb_test_exact "maint demangle f__Fic" "f(int, char)"
-    gdb_test_exact "maint demangle h__FUi" "h(unsigned int)"
-    gdb_test_exact "maint demangle h__Fci" "h(char, int)"
-    gdb_test_exact "maint demangle h__FUl" "h(unsigned long)"
-    gdb_test_exact "maint demangle h__Fcl" "h(char, long)"
-    gdb_test_exact "maint demangle h__FUs" "h(unsigned short)"
-    gdb_test_exact "maint demangle h__Fcs" "h(char, short)"
-    gdb_test "maint dem __amd__FR2T2RC2T2" \
+    test_demangling_exact "arm: __amd__FR2T2i" "operator%=(T2 &, int)"
+    test_demangling_exact "arm: __adv__FR2T2i" "operator/=(T2 &, int)"
+    test_demangling_exact "arm: __amu__FR2T2i" "operator*=(T2 &, int)"
+    test_demangling_exact "arm: __ami__FR2T2i" "operator-=(T2 &, int)"
+    test_demangling_exact "arm: __apl__FR2T2i" "operator+=(T2 &, int)"
+    test_demangling_exact "arm: __nw__2T1SFUi" "T1::operator new(unsigned int) static"
+    test_demangling_exact "arm: __dl__2T1SFPv" "T1::operator delete(void *) static"
+    test_demangling_exact "arm: put__2T7SFi" "T7::put(int) static"
+
+    test_demangling_exact "arm: __dl__12T5__pt__3_1xSFPv" "T5<x>::operator delete(void *) static"
+
+    test_demangling_exact "arm: h__FUc" "h(unsigned char)"
+    test_demangling_exact "arm: f__Fic" "f(int, char)"
+    test_demangling_exact "arm: h__FUi" "h(unsigned int)"
+    test_demangling_exact "arm: h__Fci" "h(char, int)"
+    test_demangling_exact "arm: h__FUl" "h(unsigned long)"
+    test_demangling_exact "arm: h__Fcl" "h(char, long)"
+    test_demangling_exact "arm: h__FUs" "h(unsigned short)"
+    test_demangling_exact "arm: h__Fcs" "h(char, short)"
+    test_demangling "arm: __amd__FR2T2RC2T2" \
        "operator%=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __adv__FR2T2RC2T2" \
+    test_demangling "arm: __adv__FR2T2RC2T2" \
        "operator/=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __amu__FR2T2RC2T2" \
+    test_demangling "arm: __amu__FR2T2RC2T2" \
        "operator\[*\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __ami__FR2T2RC2T2" \
+    test_demangling "arm: __ami__FR2T2RC2T2" \
        "operator-=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __apl__FR2T2RC2T2" \
+    test_demangling "arm: __apl__FR2T2RC2T2" \
        "operator\[+\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
 
-    gdb_test "maint dem g__F1SRPUlRPCUlT2" \
+    test_demangling "arm: g__F1SRPUlRPCUlT2" \
        "g\[(\]+S, unsigned long \[*\]+&, (const unsigned long|unsigned long const) \[*\]+&, unsigned long \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1SRPUiRPCUiT2" \
+    test_demangling "arm: g__F1SRPUiRPCUiT2" \
        "g\[(\]+S, unsigned int \[*\]+&, (const unsigned int|unsigned int const) \[*\]+&, unsigned int \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1SRPUsRPCUsT2" \
+    test_demangling "arm: g__F1SRPUsRPCUsT2" \
        "g\[(\]+S, unsigned short \[*\]+&, (const unsigned short|unsigned short const) \[*\]+&, unsigned short \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1SRPUcRPCUcT2" \
+    test_demangling "arm: g__F1SRPUcRPCUcT2" \
        "g\[(\]+S, unsigned char \[*\]+&, (const unsigned char|unsigned char const) \[*\]+&, unsigned char \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1T1SRPlRPClT3" \
+    test_demangling "arm: g__F1T1SRPlRPClT3" \
        "g\[(\]+T, S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1T1SRPiRPCiT3" \
+    test_demangling "arm: g__F1T1SRPiRPCiT3" \
        "g\[(\]+T, S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1T1SRPcRPCcT3" \
+    test_demangling "arm: g__F1T1SRPcRPCcT3" \
        "g\[(\]+T, S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
 
-    gdb_test_exact "maint demangle X__12T5__pt__3_1x" "T5<x>::X"
+    test_demangling_exact "arm: X__12T5__pt__3_1x" "T5<x>::X"
 
-    gdb_test_exact "maint demangle __ct__11T5__pt__2_iFi" "T5<int>::T5(int)"
+    test_demangling_exact "arm: __ct__11T5__pt__2_iFi" "T5<int>::T5(int)"
 
-    gdb_test_exact "maint demangle __ct__11T5__pt__2_cFi" "T5<char>::T5(int)"
+    test_demangling_exact "arm: __ct__11T5__pt__2_cFi" "T5<char>::T5(int)"
 
-    gdb_test "maint dem __gt__FRC2T2T1" \
+    test_demangling "arm: __gt__FRC2T2T1" \
        "operator>\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __ge__FRC2T2T1" \
+    test_demangling "arm: __ge__FRC2T2T1" \
        "operator>=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __lt__FRC2T2T1" \
+    test_demangling "arm: __lt__FRC2T2T1" \
        "operator<\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __le__FRC2T2T1" \
+    test_demangling "arm: __le__FRC2T2T1" \
        "operator<=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __ne__FRC2T2T1" \
+    test_demangling "arm: __ne__FRC2T2T1" \
        "operator!=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __eq__FRC2T2T1" \
+    test_demangling "arm: __eq__FRC2T2T1" \
        "operator==\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem g__FcR1cRC1cT2" \
+    test_demangling "arm: g__FcR1cRC1cT2" \
        "g\[(\]+char, c &, (const c|c const) &, c &\[)\]+"
-    gdb_test "maint dem g__FcRPdRPCdT2" \
+    test_demangling "arm: g__FcRPdRPCdT2" \
        "g\[(\]+char, double *\[*\]+&, (const double|double const) *\[*\]+&, double *\[*\]+&\[)\]+"
-    gdb_test "maint dem g__FcRPfRPCfT2" \
+    test_demangling "arm: g__FcRPfRPCfT2" \
        "g\[(\]+char, float *\[*\]+&, (const float|float const) *\[*\]+&, float *\[*\]+&\[)\]+"
-    gdb_test_exact "maint demangle h__FcT1" "h(char, char)"
-    gdb_test_exact "maint demangle f__Ficd" "f(int, char, double)"
-    gdb_test "maint dem g__F1T1SdRPsRPCsT4" \
+    test_demangling_exact "arm: h__FcT1" "h(char, char)"
+    test_demangling_exact "arm: f__Ficd" "f(int, char, double)"
+    test_demangling "arm: g__F1T1SdRPsRPCsT4" \
        "g\[(\]+T, S, double, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1cC1cT1" \
+    test_demangling "arm: g__F1cC1cT1" \
        "g\[(\]+c, (const c|c const), c\[)\]+"
-    gdb_test "maint dem g__FPdPCdT1" \
+    test_demangling "arm: g__FPdPCdT1" \
        "g\[(\]+double *\[*\]+, (const double|double const) *\[*\]+, double *\[*\]+\[)\]+"
-    gdb_test "maint dem g__FPfPCfT1" \
+    test_demangling "arm: g__FPfPCfT1" \
        "g\[(\]+float *\[*\]+, (const float|float const) *\[*\]+, float *\[*\]+\[)\]+"
 
-    gdb_test "maint dem g__FUlCUlT1" \
+    test_demangling "arm: g__FUlCUlT1" \
        "g\[(\]+unsigned long, (const unsigned long|unsigned long const), unsigned long\[)\]+"
-    gdb_test "maint dem g__FPlPClT1" \
+    test_demangling "arm: g__FPlPClT1" \
        "g\[(\]+long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
-    gdb_test "maint dem g__FUiCUiT1" \
+    test_demangling "arm: g__FUiCUiT1" \
        "g\[(\]+unsigned int, (const unsigned int|unsigned int const), unsigned int\[)\]+"
-    gdb_test "maint dem g__FPiPCiT1" \
+    test_demangling "arm: g__FPiPCiT1" \
        "g\[(\]+int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
-    gdb_test "maint dem g__FUsCUsT1" \
+    test_demangling "arm: g__FUsCUsT1" \
        "g\[(\]+unsigned short, (const unsigned short|unsigned short const), unsigned short\[)\]+"
-    gdb_test "maint dem g__FPsPCsT1" \
+    test_demangling "arm: g__FPsPCsT1" \
        "g\[(\]+short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
-    gdb_test "maint dem g__FUcCUcT1" \
+    test_demangling "arm: g__FUcCUcT1" \
        "g\[(\]+unsigned char, (const unsigned char|unsigned char const), unsigned char\[)\]+"
-    gdb_test "maint dem g__FPcPCcT1" \
+    test_demangling "arm: g__FPcPCcT1" \
        "g\[(\]+char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1TlClT2" \
+    test_demangling "arm: g__F1TlClT2" \
        "g\[(\]+T, long, (const long|long const), long\[)\]+"
-    gdb_test "maint dem g__F1TiCiT2" \
+    test_demangling "arm: g__F1TiCiT2" \
        "g\[(\]+T, int, (const int|int const), int\[)\]+"
-    gdb_test "maint dem g__F1TsCsT2" \
+    test_demangling "arm: g__F1TsCsT2" \
        "g\[(\]+T, short, (const short|short const), short\[)\]+"
-    gdb_test "maint dem g__F1TcCcT2" \
+    test_demangling "arm: g__F1TcCcT2" \
        "g\[(\]+T, char, (const char|char const), char\[)\]+"
 
-    gdb_test_exact "maint demangle __dl__17T5__pt__8_PFcPv_iSFPv" "T5<int (*)(char, void *)>::operator delete(void *) static"
+    test_demangling_exact "arm: __dl__17T5__pt__8_PFcPv_iSFPv" "T5<int (*)(char, void *)>::operator delete(void *) static"
 
-    gdb_test "maint dem printf__FPCce" \
+    test_demangling "arm: printf__FPCce" \
        "printf\[(\]+(const char|char const) \[*\]+,...\[)\]+"
 
-    gdb_test_exact "maint demangle X__17T5__pt__8_PFcPv_i" "T5<int (*)(char, void *)>::X"
+    test_demangling_exact "arm: X__17T5__pt__8_PFcPv_i" "T5<int (*)(char, void *)>::X"
 
-    gdb_test_exact "maint demangle __ct__12T5__pt__3_1xFi" "T5<x>::T5(int)"
+    test_demangling_exact "arm: __ct__12T5__pt__3_1xFi" "T5<x>::T5(int)"
 
-    gdb_test "maint dem g__F1SRUlRCUlT2" \
+    test_demangling "arm: g__F1SRUlRCUlT2" \
        "g\[(\]+S, unsigned long &, (const unsigned long|unsigned long const) &, unsigned long &\[)\]+"
-    gdb_test "maint dem g__F1SRPlRPClT2" \
+    test_demangling "arm: g__F1SRPlRPClT2" \
        "g\[(\]+S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1RRUiRCUiT2" \
+    test_demangling "arm: g__F1RRUiRCUiT2" \
        "g\[(\]+R, unsigned int &, (const unsigned int|unsigned int const) &, unsigned int &\[)\]+"
-    gdb_test "maint dem g__F1SRPiRPCiT2" \
+    test_demangling "arm: g__F1SRPiRPCiT2" \
        "g\[(\]+S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1RRUsRCUsT2" \
+    test_demangling "arm: g__F1RRUsRCUsT2" \
        "g\[(\]+R, unsigned short &, (const unsigned short|unsigned short const) &, unsigned short &\[)\]+"
-    gdb_test "maint dem g__F1SRPsRPCsT2" \
+    test_demangling "arm: g__F1SRPsRPCsT2" \
        "g\[(\]+S, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1RRUcRCUcT2" \
+    test_demangling "arm: g__F1RRUcRCUcT2" \
        "g\[(\]+R, unsigned char &, (const unsigned char|unsigned char const) &, unsigned char &\[)\]+"
-    gdb_test "maint dem g__F1SRPcRPCcT2" \
+    test_demangling "arm: g__F1SRPcRPCcT2" \
        "g\[(\]+S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1T1RRlRClT3" \
+    test_demangling "arm: g__F1T1RRlRClT3" \
        "g\[(\]+T, R, long &, (const long|long const) &, long &\[)\]+"
-    gdb_test "maint dem g__F1T1RRiRCiT3" \
+    test_demangling "arm: g__F1T1RRiRCiT3" \
        "g\[(\]+T, R, int &, (const int|int const) &, int &\[)\]+"
-    gdb_test "maint dem g__F1T1RRsRCsT3" \
+    test_demangling "arm: g__F1T1RRsRCsT3" \
        "g\[(\]+T, R, short &, (const short|short const) &, short &\[)\]+"
-    gdb_test "maint dem g__F1T1RRcRCcT3" \
+    test_demangling "arm: g__F1T1RRcRCcT3" \
        "g\[(\]+T, R, char &, (const char|char const) &, char &\[)\]+"
 
-    gdb_test_exact "maint demangle __dl__21T5__pt__11_PFiPPdPv_iSFPv" "T5<int (*)(int, double **, void *)>::operator delete(void *) static"
+    test_demangling_exact "arm: __dl__21T5__pt__11_PFiPPdPv_iSFPv" "T5<int (*)(int, double **, void *)>::operator delete(void *) static"
 
-    gdb_test_exact "maint demangle __std__foo" "global destructors keyed to foo"
+    test_demangling_exact "arm: __std__foo" "global destructors keyed to foo"
 
-    gdb_test_exact "maint demangle __sti__bar" "global constructors keyed to bar"
+    test_demangling_exact "arm: __sti__bar" "global constructors keyed to bar"
 
-    gdb_test_exact "maint demangle f__FicdPcPFci_v" "f(int, char, double, char *, void (*)(char, int))"
-    gdb_test_exact "maint demangle f__FicdPcPFic_v" "f(int, char, double, char *, void (*)(int, char))"
-    gdb_test_exact "maint demangle get__2T7SFv" "T7::get(void) static"
+    test_demangling_exact "arm: f__FicdPcPFci_v" "f(int, char, double, char *, void (*)(char, int))"
+    test_demangling_exact "arm: f__FicdPcPFic_v" "f(int, char, double, char *, void (*)(int, char))"
+    test_demangling_exact "arm: get__2T7SFv" "T7::get(void) static"
 
-    gdb_test_exact "maint demangle X__21T5__pt__11_PFiPPdPv_i" "T5<int (*)(int, double **, void *)>::X"
+    test_demangling_exact "arm: X__21T5__pt__11_PFiPPdPv_i" "T5<int (*)(int, double **, void *)>::X"
 
-    gdb_test "maint dem g__FcRdRCdT2" \
+    test_demangling "arm: g__FcRdRCdT2" \
        "g\[(\]+char, double &, (const double|double const) &, double &\[)\]+"
-    gdb_test "maint dem g__FcRfRCfT2" \
+    test_demangling "arm: g__FcRfRCfT2" \
        "g\[(\]+char, float &, (const float|float const) &, float &\[)\]+"
-    gdb_test "maint dem __md__FC2T2i" \
+    test_demangling "arm: __md__FC2T2i" \
        "operator%\[(\]+(const T2|T2 const), int\[)\]+"
-    gdb_test "maint dem __dv__FC2T2i" \
+    test_demangling "arm: __dv__FC2T2i" \
        "operator/\[(\]+(const T2|T2 const), int\[)\]+"
-    gdb_test "maint dem __ml__FC2T2i" \
+    test_demangling "arm: __ml__FC2T2i" \
        "operator\[*\]+\[(\]+(const T2|T2 const), int\[)\]+"
-    gdb_test "maint dem __mi__FC2T2i" \
+    test_demangling "arm: __mi__FC2T2i" \
        "operator-\[(\]+(const T2|T2 const), int\[)\]+"
-    gdb_test "maint dem __pl__FC2T2i" \
+    test_demangling "arm: __pl__FC2T2i" \
        "operator\[+\]+\[(\]+(const T2|T2 const), int\[)\]+"
 
-    gdb_test_exact "maint demangle __dl__11T5__pt__2_iSFPv" "T5<int>::operator delete(void *) static"
+    test_demangling_exact "arm: __dl__11T5__pt__2_iSFPv" "T5<int>::operator delete(void *) static"
 
-    gdb_test_exact "maint demangle __dl__11T5__pt__2_cSFPv" "T5<char>::operator delete(void *) static"
+    test_demangling_exact "arm: __dl__11T5__pt__2_cSFPv" "T5<char>::operator delete(void *) static"
 
-    gdb_test_exact "maint demangle h__Fc" "h(char)"
-    gdb_test_exact "maint demangle h__Fd" "h(double)"
-    gdb_test_exact "maint demangle h__Ff" "h(float)"
-    gdb_test_exact "maint demangle h__Fi" "h(int)"
-    gdb_test_exact "maint demangle f__Fi" "f(int)"
-    gdb_test_exact "maint demangle h__Fl" "h(long)"
+    test_demangling_exact "arm: h__Fc" "h(char)"
+    test_demangling_exact "arm: h__Fd" "h(double)"
+    test_demangling_exact "arm: h__Ff" "h(float)"
+    test_demangling_exact "arm: h__Fi" "h(int)"
+    test_demangling_exact "arm: f__Fi" "f(int)"
+    test_demangling_exact "arm: h__Fl" "h(long)"
 
-    gdb_test_exact "maint demangle h__Fs" "h(short)"
-    gdb_test "maint dem __md__FC2T2RC2T2" \
+    test_demangling_exact "arm: h__Fs" "h(short)"
+    test_demangling "arm: __md__FC2T2RC2T2" \
        "operator%\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __dv__FC2T2RC2T2" \
+    test_demangling "arm: __dv__FC2T2RC2T2" \
        "operator/\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __ml__FC2T2RC2T2" \
+    test_demangling "arm: __ml__FC2T2RC2T2" \
        "operator\[*\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __mi__FC2T2RC2T2" \
+    test_demangling "arm: __mi__FC2T2RC2T2" \
        "operator-\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __pl__FC2T2RC2T2" \
+    test_demangling "arm: __pl__FC2T2RC2T2" \
        "operator\[+\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem g__FcRP1cRPC1cT2" \
+    test_demangling "arm: g__FcRP1cRPC1cT2" \
        "g\[(\]+char, c *\[*\]+&, (const c|c const) *\[*\]+&, c *\[*\]+&\[)\]+"
 
-    gdb_test_exact "maint demangle X__11T5__pt__2_c" "T5<char>::X"
+    test_demangling_exact "arm: X__11T5__pt__2_c" "T5<char>::X"
 
-    gdb_test_exact "maint demangle X__11T5__pt__2_i" "T5<int>::X"
+    test_demangling_exact "arm: X__11T5__pt__2_i" "T5<int>::X"
 
-    gdb_test "maint dem g__FdCdT1" \
+    test_demangling "arm: g__FdCdT1" \
        "g\[(\]+double, (const double|double const), double\[)\]+"
-    gdb_test "maint dem g__FfCfT1" \
+    test_demangling "arm: g__FfCfT1" \
        "g\[(\]+float, (const float|float const), float\[)\]+"
-    gdb_test "maint dem g__FlClT1" \
+    test_demangling "arm: g__FlClT1" \
        "g\[(\]+long, (const long|long const), long\[)\]+"
-    gdb_test "maint dem g__FiCiT1" \
+    test_demangling "arm: g__FiCiT1" \
        "g\[(\]+int, (const int|int const), int\[)\]+"
-    gdb_test "maint dem g__FsCsT1" \
+    test_demangling "arm: g__FsCsT1" \
        "g\[(\]+short, (const short|short const), short\[)\]+"
-    gdb_test "maint dem g__FcCcT1" \
+    test_demangling "arm: g__FcCcT1" \
        "g\[(\]+char, (const char|char const), char\[)\]+"
 
-    gdb_test_exact "maint demangle __ct__17T5__pt__8_PFcPv_iFi" "T5<int (*)(char, void *)>::T5(int)"
+    test_demangling_exact "arm: __ct__17T5__pt__8_PFcPv_iFi" "T5<int (*)(char, void *)>::T5(int)"
 
-    gdb_test_exact "maint demangle f__FicdPc" "f(int, char, double, char *)"
-    gdb_test_exact "maint demangle __nw__FUi" "operator new(unsigned int)"
-    gdb_test_exact "maint demangle __ct__Q3_2T11a1bSFi" "T1::a::b::b(int) static"
-    gdb_test_exact "maint demangle __dt__Q3_2T11a1bSFi" "T1::a::b::~b(int) static"
-    gdb_test_exact "maint demangle put__Q3_2T11a1bSFi" "T1::a::b::put(int) static"
-    gdb_test_exact "maint demangle get__Q2_2T11aSFv" "T1::a::get(void) static"
-    gdb_test_exact "maint demangle put__2T1SFi" "T1::put(int) static"
-    gdb_test_exact "maint demangle put__Q5_2T11a1b1c1dSFi" "T1::a::b::c::d::put(int) static"
-    gdb_test_exact "maint demangle get__Q4_2T11a1b1cSFv" "T1::a::b::c::get(void) static"
-    gdb_test_exact "maint demangle put__Q2_2T11aSFi" "T1::a::put(int) static"
-    gdb_test_exact "maint demangle put__Q4_2T11a1b1cSFi" "T1::a::b::c::put(int) static"
-    gdb_test_exact "maint demangle get__Q3_2T11a1bSFv" "T1::a::b::get(void) static"
-    gdb_test_exact "maint demangle get__2T1SFv" "T1::get(void) static"
-    gdb_test_exact "maint demangle get__Q5_2T11a1b1c1dSFv" "T1::a::b::c::d::get(void) static"
+    test_demangling_exact "arm: f__FicdPc" "f(int, char, double, char *)"
+    test_demangling_exact "arm: __nw__FUi" "operator new(unsigned int)"
+    test_demangling_exact "arm: __ct__Q3_2T11a1bSFi" "T1::a::b::b(int) static"
+    test_demangling_exact "arm: __dt__Q3_2T11a1bSFi" "T1::a::b::~b(int) static"
+    test_demangling_exact "arm: put__Q3_2T11a1bSFi" "T1::a::b::put(int) static"
+    test_demangling_exact "arm: get__Q2_2T11aSFv" "T1::a::get(void) static"
+    test_demangling_exact "arm: put__2T1SFi" "T1::put(int) static"
+    test_demangling_exact "arm: put__Q5_2T11a1b1c1dSFi" "T1::a::b::c::d::put(int) static"
+    test_demangling_exact "arm: get__Q4_2T11a1b1cSFv" "T1::a::b::c::get(void) static"
+    test_demangling_exact "arm: put__Q2_2T11aSFi" "T1::a::put(int) static"
+    test_demangling_exact "arm: put__Q4_2T11a1b1cSFi" "T1::a::b::c::put(int) static"
+    test_demangling_exact "arm: get__Q3_2T11a1bSFv" "T1::a::b::get(void) static"
+    test_demangling_exact "arm: get__2T1SFv" "T1::get(void) static"
+    test_demangling_exact "arm: get__Q5_2T11a1b1c1dSFv" "T1::a::b::c::d::get(void) static"
 
-    gdb_test_exact "maint demangle __dt__11T1__pt__2_cFv" "T1<char>::~T1(void)"
+    test_demangling_exact "arm: __dt__11T1__pt__2_cFv" "T1<char>::~T1(void)"
 
-    gdb_test_exact "maint demangle __dt__12T1__pt__3_1tFv" "T1<t>::~T1(void)"
+    test_demangling_exact "arm: __dt__12T1__pt__3_1tFv" "T1<t>::~T1(void)"
 
-    gdb_test_exact "maint demangle __dl__12T1__pt__3_1tSFPv" "T1<t>::operator delete(void *) static"
+    test_demangling_exact "arm: __dl__12T1__pt__3_1tSFPv" "T1<t>::operator delete(void *) static"
 
-    gdb_test_exact "maint demangle __ct__11T1__pt__2_cFi" "T1<char>::T1(int)"
+    test_demangling_exact "arm: __ct__11T1__pt__2_cFi" "T1<char>::T1(int)"
 
-    gdb_test_exact "maint demangle __ct__11T1__pt__2_cFv" "T1<char>::T1(void)"
+    test_demangling_exact "arm: __ct__11T1__pt__2_cFv" "T1<char>::T1(void)"
 
-    gdb_test_exact "maint demangle __ct__12T1__pt__3_1tFi" "T1<t>::T1(int)"
+    test_demangling_exact "arm: __ct__12T1__pt__3_1tFi" "T1<t>::T1(int)"
 
-    gdb_test_exact "maint demangle __ct__12T1__pt__3_1tFv" "T1<t>::T1(void)"
+    test_demangling_exact "arm: __ct__12T1__pt__3_1tFv" "T1<t>::T1(void)"
 
-    gdb_test_exact "maint demangle __dl__11T1__pt__2_cSFPv" "T1<char>::operator delete(void *) static"
+    test_demangling_exact "arm: __dl__11T1__pt__2_cSFPv" "T1<char>::operator delete(void *) static"
 
-    gdb_test_exact "maint demangle bar__3fooFPv"       "foo::bar(void *)"
-    gdb_test "maint dem bar__3fooFPCv" \
+    test_demangling_exact "arm: bar__3fooFPv"       "foo::bar(void *)"
+    test_demangling "arm: bar__3fooFPCv" \
             "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+"
-    gdb_test_exact "maint demangle bar__3fooCFPv"      "foo::bar(void *) const"
-    gdb_test "maint dem bar__3fooCFPCv" \
+    test_demangling_exact "arm: bar__3fooCFPv"      "foo::bar(void *) const"
+    test_demangling "arm: bar__3fooCFPCv" \
            "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+ const"
-    gdb_test_exact "maint demangle __eq__3fooFR3foo"   "foo::operator==(foo &)"
-    gdb_test "maint dem __eq__3fooFRC3foo" \
+    test_demangling_exact "arm: __eq__3fooFR3foo"   "foo::operator==(foo &)"
+    test_demangling "arm: __eq__3fooFRC3foo" \
         "foo::operator==\[(\]+(const foo|foo const) &\[)\]+"
-    gdb_test_exact "maint demangle __eq__3fooCFR3foo"  "foo::operator==(foo &) const"
-    gdb_test "maint dem __eq__3fooCFRC3foo" \
+    test_demangling_exact "arm: __eq__3fooCFR3foo"  "foo::operator==(foo &) const"
+    test_demangling "arm: __eq__3fooCFRC3foo" \
        "foo::operator==\[(\]+(const foo|foo const) &\[)\]+ const"
 
-    gdb_test_exact "maint demangle elem__15vector__pt__2_dFi" "vector<double>::elem(int)"
+    test_demangling_exact "arm: elem__15vector__pt__2_dFi" "vector<double>::elem(int)"
 
-    gdb_test_exact "maint demangle elem__15vector__pt__2_iFi" "vector<int>::elem(int)"
+    test_demangling_exact "arm: elem__15vector__pt__2_iFi" "vector<int>::elem(int)"
 
-    gdb_test_exact "maint demangle __ct__15vector__pt__2_dFi" "vector<double>::vector(int)"
+    test_demangling_exact "arm: __ct__15vector__pt__2_dFi" "vector<double>::vector(int)"
 
-    gdb_test_exact "maint demangle __ct__15vector__pt__2_iFi" "vector<int>::vector(int)"
+    test_demangling_exact "arm: __ct__15vector__pt__2_iFi" "vector<int>::vector(int)"
 
-    gdb_test_exact "maint demangle __ct__25DListNode__pt__9_R6RLabelFR6RLabelP25DListNode__pt__9_R6RLabelT2" \
+    test_demangling_exact "arm: __ct__25DListNode__pt__9_R6RLabelFR6RLabelP25DListNode__pt__9_R6RLabelT2" \
        "DListNode<RLabel &>::DListNode(RLabel &, DListNode<RLabel &> *, DListNode<RLabel &> *)"
 
-    gdb_test_exact "maint demangle bar__3fooFiT16FooBar" "foo::bar(int, int, FooBar)"
+    test_demangling_exact "arm: bar__3fooFiT16FooBar" "foo::bar(int, int, FooBar)"
 
-    gdb_test_exact "maint demangle bar__3fooFPiN51PdN37PcN211T1iN215" \
+    test_demangling_exact "arm: bar__3fooFPiN51PdN37PcN211T1iN215" \
       "foo::bar(int *, int *, int *, int *, int *, int *, double *, double *, double *, double *, char *, char *, char *, int *, int, int, int)"
 
+    test_demangling_exact "arm: _Utf390_1__1_9223372036854775807__9223372036854775" \
+           "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
 }
 
 proc test_hp_style_demangling {} {
-    global gdb_prompt
-
-    # Set the demangling style to "hp" and then check to make sure
-    # it really got set.  Return if the style failed to get set for
-    # some reason.
-
-    send_gdb "set demangle-style hp\n"
-    gdb_expect {
-       -re "set demangle-style hp\[\r\n\]+$gdb_prompt $" {}
-       -re ".*$gdb_prompt $" { fail "set demangle-style hp failed" ; return }
-       timeout { fail "set demangle-style hp failed (timeout)" ; return }
-    }
-
-    send_gdb "show demangle-style\n"
-    gdb_expect {
-       -re "The current C\[+\]+ demangling style is \"hp\".\r\n$gdb_prompt $" {}
-       -re ".*$gdb_prompt $" { fail "demangling style not set to hp" }
-       timeout { fail "show demangle-style timed out (HP)" }
-    }
 
     # HP aCC mangling style is based on ARM for all the basic stuff,
     # so first we use some of the ARM tests here.  Later we have HP-specific
     # tests.
         
-    gdb_test "maint dem g__FP1cPC1cT1" \
+    test_demangling "hp: g__FP1cPC1cT1" \
        "g\[(\]+c *\[*\]+, (const c|c const) *\[*\]+, c *\[*\]+\[)\]+"
-    gdb_test "maint dem g__FPUlPCUlT1" \
+    test_demangling "hp: g__FPUlPCUlT1" \
        "g\[(\]+unsigned long \[*\]+, (const unsigned long|unsigned long const) \[*\]+, unsigned long \[*\]+\[)\]+"
-    gdb_test "maint dem g__FPUiPCUiT1" \
+    test_demangling "hp: g__FPUiPCUiT1" \
        "g\[(\]+unsigned int \[*\]+, (const unsigned int|unsigned int const) \[*\]+, unsigned int \[*\]+\[)\]+"
-    gdb_test "maint dem g__FPUsPCUsT1" \
+    test_demangling "hp: g__FPUsPCUsT1" \
        "g\[(\]+unsigned short \[*\]+, (const unsigned short|unsigned short const) \[*\]+, unsigned short \[*\]+\[)\]+"
-    gdb_test "maint dem g__FPUcPCUcT1" \
+    test_demangling "hp: g__FPUcPCUcT1" \
        "g\[(\]+unsigned char \[*\]+, (const unsigned char|unsigned char const) \[*\]+, unsigned char \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1TPlPClT2" \
+    test_demangling "hp: g__F1TPlPClT2" \
        "g\[(\]+T, long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1RRlRClT2" \
+    test_demangling "hp: g__F1RRlRClT2" \
        "g\[(\]+R, long &, (const long|long const) &, long &\[)\]+"
-    gdb_test "maint dem g__F1TPiPCiT2" \
+    test_demangling "hp: g__F1TPiPCiT2" \
        "g\[(\]+T, int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1RRiRCiT2" \
+    test_demangling "hp: g__F1RRiRCiT2" \
        "g\[(\]+R, int &, (const int|int const) &, int &\[)\]+"
-    gdb_test "maint dem g__F1TPsPCsT2" \
+    test_demangling "hp: g__F1TPsPCsT2" \
        "g\[(\]+T, short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1RRsRCsT2" \
+    test_demangling "hp: g__F1RRsRCsT2" \
        "g\[(\]+R, short &, (const short|short const) &, short &\[)\]+"
-    gdb_test "maint dem g__F1TPcPCcT2" \
+    test_demangling "hp: g__F1TPcPCcT2" \
        "g\[(\]+T, char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1RRcRCcT2" \
+    test_demangling "hp: g__F1RRcRCcT2" \
        "g\[(\]+R, char &, (const char|char const) &, char &\[)\]+"
 
-    gdb_test "maint dem __gt__FRC2T2c" \
+    test_demangling "hp: __gt__FRC2T2c" \
        "operator>\[(\]+(const T2|T2 const) &, char\[)\]+"
-    gdb_test "maint dem __ge__FRC2T2c" \
+    test_demangling "hp: __ge__FRC2T2c" \
        "operator>=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    gdb_test "maint dem __lt__FRC2T2c" \
+    test_demangling "hp: __lt__FRC2T2c" \
        "operator<\[(\]+(const T2|T2 const) &, char\[)\]+"
 
-    gdb_test "maint dem __le__FRC2T2c" \
+    test_demangling "hp: __le__FRC2T2c" \
        "operator<=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    gdb_test "maint dem __ne__FRC2T2c" \
+    test_demangling "hp: __ne__FRC2T2c" \
        "operator!=\[(\]+(const T2|T2 const) &, char\[)\]+"
-    gdb_test "maint dem __eq__FRC2T2c" \
+    test_demangling "hp: __eq__FRC2T2c" \
        "operator==\[(\]+(const T2|T2 const) &, char\[)\]+"
-    gdb_test_exact "maint demangle __amd__FR2T2i" "operator%=(T2 &, int)"
-    gdb_test_exact "maint demangle __adv__FR2T2i" "operator/=(T2 &, int)"
-    gdb_test_exact "maint demangle __amu__FR2T2i" "operator*=(T2 &, int)"
-    gdb_test_exact "maint demangle __ami__FR2T2i" "operator-=(T2 &, int)"
-    gdb_test_exact "maint demangle __apl__FR2T2i" "operator+=(T2 &, int)"
-    gdb_test_exact "maint demangle __nw__2T1SFUi" "T1::operator new(unsigned int) static"
-    gdb_test_exact "maint demangle __dl__2T1SFPv" "T1::operator delete(void *) static"
-    gdb_test_exact "maint demangle put__2T7SFi" "T7::put(int) static"
-
-    gdb_test_exact "maint demangle h__FUc" "h(unsigned char)"
-    gdb_test_exact "maint demangle f__Fic" "f(int, char)"
-    gdb_test_exact "maint demangle h__FUi" "h(unsigned int)"
-    gdb_test_exact "maint demangle h__Fci" "h(char, int)"
-    gdb_test_exact "maint demangle h__FUl" "h(unsigned long)"
-    gdb_test_exact "maint demangle h__Fcl" "h(char, long)"
-    gdb_test_exact "maint demangle h__FUs" "h(unsigned short)"
-    gdb_test_exact "maint demangle h__Fcs" "h(char, short)"
-    gdb_test "maint dem __amd__FR2T2RC2T2" \
+    test_demangling_exact "hp: __amd__FR2T2i" "operator%=(T2 &, int)"
+    test_demangling_exact "hp: __adv__FR2T2i" "operator/=(T2 &, int)"
+    test_demangling_exact "hp: __amu__FR2T2i" "operator*=(T2 &, int)"
+    test_demangling_exact "hp: __ami__FR2T2i" "operator-=(T2 &, int)"
+    test_demangling_exact "hp: __apl__FR2T2i" "operator+=(T2 &, int)"
+    test_demangling_exact "hp: __nw__2T1SFUi" "T1::operator new(unsigned int) static"
+    test_demangling_exact "hp: __dl__2T1SFPv" "T1::operator delete(void *) static"
+    test_demangling_exact "hp: put__2T7SFi" "T7::put(int) static"
+
+    test_demangling_exact "hp: h__FUc" "h(unsigned char)"
+    test_demangling_exact "hp: f__Fic" "f(int, char)"
+    test_demangling_exact "hp: h__FUi" "h(unsigned int)"
+    test_demangling_exact "hp: h__Fci" "h(char, int)"
+    test_demangling_exact "hp: h__FUl" "h(unsigned long)"
+    test_demangling_exact "hp: h__Fcl" "h(char, long)"
+    test_demangling_exact "hp: h__FUs" "h(unsigned short)"
+    test_demangling_exact "hp: h__Fcs" "h(char, short)"
+    test_demangling "hp: __amd__FR2T2RC2T2" \
        "operator%=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __adv__FR2T2RC2T2" \
+    test_demangling "hp: __adv__FR2T2RC2T2" \
        "operator/=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __amu__FR2T2RC2T2" \
+    test_demangling "hp: __amu__FR2T2RC2T2" \
        "operator\[*\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __ami__FR2T2RC2T2" \
+    test_demangling "hp: __ami__FR2T2RC2T2" \
        "operator-=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __apl__FR2T2RC2T2" \
+    test_demangling "hp: __apl__FR2T2RC2T2" \
        "operator\[+\]+=\[(\]+T2 &, (const T2|T2 const) &\[)\]+"
 
-    gdb_test "maint dem g__F1SRPUlRPCUlT2" \
+    test_demangling "hp: g__F1SRPUlRPCUlT2" \
        "g\[(\]+S, unsigned long \[*\]+&, (const unsigned long|unsigned long const) \[*\]+&, unsigned long \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1SRPUiRPCUiT2" \
+    test_demangling "hp: g__F1SRPUiRPCUiT2" \
        "g\[(\]+S, unsigned int \[*\]+&, (const unsigned int|unsigned int const) \[*\]+&, unsigned int \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1SRPUsRPCUsT2" \
+    test_demangling "hp: g__F1SRPUsRPCUsT2" \
        "g\[(\]+S, unsigned short \[*\]+&, (const unsigned short|unsigned short const) \[*\]+&, unsigned short \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1SRPUcRPCUcT2" \
+    test_demangling "hp: g__F1SRPUcRPCUcT2" \
        "g\[(\]+S, unsigned char \[*\]+&, (const unsigned char|unsigned char const) \[*\]+&, unsigned char \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1T1SRPlRPClT3" \
+    test_demangling "hp: g__F1T1SRPlRPClT3" \
        "g\[(\]+T, S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1T1SRPiRPCiT3" \
+    test_demangling "hp: g__F1T1SRPiRPCiT3" \
        "g\[(\]+T, S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1T1SRPcRPCcT3" \
+    test_demangling "hp: g__F1T1SRPcRPCcT3" \
        "g\[(\]+T, S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
 
 
-    gdb_test "maint dem __gt__FRC2T2T1" \
+    test_demangling "hp: __gt__FRC2T2T1" \
        "operator>\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __ge__FRC2T2T1" \
+    test_demangling "hp: __ge__FRC2T2T1" \
        "operator>=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __lt__FRC2T2T1" \
+    test_demangling "hp: __lt__FRC2T2T1" \
        "operator<\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __le__FRC2T2T1" \
+    test_demangling "hp: __le__FRC2T2T1" \
        "operator<=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __ne__FRC2T2T1" \
+    test_demangling "hp: __ne__FRC2T2T1" \
        "operator!=\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __eq__FRC2T2T1" \
+    test_demangling "hp: __eq__FRC2T2T1" \
        "operator==\[(\]+(const T2|T2 const) &, (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem g__FcR1cRC1cT2" \
+    test_demangling "hp: g__FcR1cRC1cT2" \
        "g\[(\]+char, c &, (const c|c const) &, c &\[)\]+"
-    gdb_test "maint dem g__FcRPdRPCdT2" \
+    test_demangling "hp: g__FcRPdRPCdT2" \
        "g\[(\]+char, double *\[*\]+&, (const double|double const) *\[*\]+&, double *\[*\]+&\[)\]+"
-    gdb_test "maint dem g__FcRPfRPCfT2" \
+    test_demangling "hp: g__FcRPfRPCfT2" \
        "g\[(\]+char, float *\[*\]+&, (const float|float const) *\[*\]+&, float *\[*\]+&\[)\]+"
-    gdb_test_exact "maint demangle h__FcT1" "h(char, char)"
-    gdb_test_exact "maint demangle f__Ficd" "f(int, char, double)"
-    gdb_test "maint dem g__F1T1SdRPsRPCsT4" \
+    test_demangling_exact "hp: h__FcT1" "h(char, char)"
+    test_demangling_exact "hp: f__Ficd" "f(int, char, double)"
+    test_demangling "hp: g__F1T1SdRPsRPCsT4" \
        "g\[(\]+T, S, double, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1cC1cT1" \
+    test_demangling "hp: g__F1cC1cT1" \
        "g\[(\]+c, (const c|c const), c\[)\]+"
-    gdb_test "maint dem g__FPdPCdT1" \
+    test_demangling "hp: g__FPdPCdT1" \
        "g\[(\]+double *\[*\]+, (const double|double const) *\[*\]+, double *\[*\]+\[)\]+"
-    gdb_test "maint dem g__FPfPCfT1" \
+    test_demangling "hp: g__FPfPCfT1" \
        "g\[(\]+float *\[*\]+, (const float|float const) *\[*\]+, float *\[*\]+\[)\]+"
 
-    gdb_test "maint dem g__FUlCUlT1" \
+    test_demangling "hp: g__FUlCUlT1" \
        "g\[(\]+unsigned long, (const unsigned long|unsigned long const), unsigned long\[)\]+"
-    gdb_test "maint dem g__FPlPClT1" \
+    test_demangling "hp: g__FPlPClT1" \
        "g\[(\]+long \[*\]+, (const long|long const) \[*\]+, long \[*\]+\[)\]+"
-    gdb_test "maint dem g__FUiCUiT1" \
+    test_demangling "hp: g__FUiCUiT1" \
        "g\[(\]+unsigned int, (const unsigned int|unsigned int const), unsigned int\[)\]+"
-    gdb_test "maint dem g__FPiPCiT1" \
+    test_demangling "hp: g__FPiPCiT1" \
        "g\[(\]+int \[*\]+, (const int|int const) \[*\]+, int \[*\]+\[)\]+"
-    gdb_test "maint dem g__FUsCUsT1" \
+    test_demangling "hp: g__FUsCUsT1" \
        "g\[(\]+unsigned short, (const unsigned short|unsigned short const), unsigned short\[)\]+"
-    gdb_test "maint dem g__FPsPCsT1" \
+    test_demangling "hp: g__FPsPCsT1" \
        "g\[(\]+short \[*\]+, (const short|short const) \[*\]+, short \[*\]+\[)\]+"
-    gdb_test "maint dem g__FUcCUcT1" \
+    test_demangling "hp: g__FUcCUcT1" \
        "g\[(\]+unsigned char, (const unsigned char|unsigned char const), unsigned char\[)\]+"
-    gdb_test "maint dem g__FPcPCcT1" \
+    test_demangling "hp: g__FPcPCcT1" \
        "g\[(\]+char \[*\]+, (const char|char const) \[*\]+, char \[*\]+\[)\]+"
-    gdb_test "maint dem g__F1TlClT2" \
+    test_demangling "hp: g__F1TlClT2" \
        "g\[(\]+T, long, (const long|long const), long\[)\]+"
-    gdb_test "maint dem g__F1TiCiT2" \
+    test_demangling "hp: g__F1TiCiT2" \
        "g\[(\]+T, int, (const int|int const), int\[)\]+"
-    gdb_test "maint dem g__F1TsCsT2" \
+    test_demangling "hp: g__F1TsCsT2" \
        "g\[(\]+T, short, (const short|short const), short\[)\]+"
-    gdb_test "maint dem g__F1TcCcT2" \
+    test_demangling "hp: g__F1TcCcT2" \
        "g\[(\]+T, char, (const char|char const), char\[)\]+"
 
-    gdb_test "maint dem printf__FPCce" \
+    test_demangling "hp: printf__FPCce" \
        "printf\[(\]+(const char|char const) \[*\]+,...\[)\]+"
 
 
-    gdb_test "maint dem g__F1SRUlRCUlT2" \
+    test_demangling "hp: g__F1SRUlRCUlT2" \
        "g\[(\]+S, unsigned long &, (const unsigned long|unsigned long const) &, unsigned long &\[)\]+"
-    gdb_test "maint dem g__F1SRPlRPClT2" \
+    test_demangling "hp: g__F1SRPlRPClT2" \
        "g\[(\]+S, long \[*\]+&, (const long|long const) \[*\]+&, long \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1RRUiRCUiT2" \
+    test_demangling "hp: g__F1RRUiRCUiT2" \
        "g\[(\]+R, unsigned int &, (const unsigned int|unsigned int const) &, unsigned int &\[)\]+"
-    gdb_test "maint dem g__F1SRPiRPCiT2" \
+    test_demangling "hp: g__F1SRPiRPCiT2" \
        "g\[(\]+S, int \[*\]+&, (const int|int const) \[*\]+&, int \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1RRUsRCUsT2" \
+    test_demangling "hp: g__F1RRUsRCUsT2" \
        "g\[(\]+R, unsigned short &, (const unsigned short|unsigned short const) &, unsigned short &\[)\]+"
-    gdb_test "maint dem g__F1SRPsRPCsT2" \
+    test_demangling "hp: g__F1SRPsRPCsT2" \
        "g\[(\]+S, short \[*\]+&, (const short|short const) \[*\]+&, short \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1RRUcRCUcT2" \
+    test_demangling "hp: g__F1RRUcRCUcT2" \
        "g\[(\]+R, unsigned char &, (const unsigned char|unsigned char const) &, unsigned char &\[)\]+"
-    gdb_test "maint dem g__F1SRPcRPCcT2" \
+    test_demangling "hp: g__F1SRPcRPCcT2" \
        "g\[(\]+S, char \[*\]+&, (const char|char const) \[*\]+&, char \[*\]+&\[)\]+"
-    gdb_test "maint dem g__F1T1RRlRClT3" \
+    test_demangling "hp: g__F1T1RRlRClT3" \
        "g\[(\]+T, R, long &, (const long|long const) &, long &\[)\]+"
-    gdb_test "maint dem g__F1T1RRiRCiT3" \
+    test_demangling "hp: g__F1T1RRiRCiT3" \
        "g\[(\]+T, R, int &, (const int|int const) &, int &\[)\]+"
-    gdb_test "maint dem g__F1T1RRsRCsT3" \
+    test_demangling "hp: g__F1T1RRsRCsT3" \
        "g\[(\]+T, R, short &, (const short|short const) &, short &\[)\]+"
-    gdb_test "maint dem g__F1T1RRcRCcT3" \
+    test_demangling "hp: g__F1T1RRcRCcT3" \
        "g\[(\]+T, R, char &, (const char|char const) &, char &\[)\]+"
 
 
-    gdb_test_exact "maint demangle f__FicdPcPFci_v" "f(int, char, double, char *, void (*)(char, int))"
-    gdb_test_exact "maint demangle f__FicdPcPFic_v" "f(int, char, double, char *, void (*)(int, char))"
-    gdb_test_exact "maint demangle get__2T7SFv" "T7::get(void) static"
+    test_demangling_exact "hp: f__FicdPcPFci_v" "f(int, char, double, char *, void (*)(char, int))"
+    test_demangling_exact "hp: f__FicdPcPFic_v" "f(int, char, double, char *, void (*)(int, char))"
+    test_demangling_exact "hp: get__2T7SFv" "T7::get(void) static"
 
 
-    gdb_test "maint dem g__FcRdRCdT2" \
+    test_demangling "hp: g__FcRdRCdT2" \
        "g\[(\]+char, double &, (const double|double const) &, double &\[)\]+"
-    gdb_test "maint dem g__FcRfRCfT2" \
+    test_demangling "hp: g__FcRfRCfT2" \
        "g\[(\]+char, float &, (const float|float const) &, float &\[)\]+"
-    gdb_test "maint dem __md__FC2T2i" \
+    test_demangling "hp: __md__FC2T2i" \
        "operator%\[(\]+(const T2|T2 const), int\[)\]+"
-    gdb_test "maint dem __dv__FC2T2i" \
+    test_demangling "hp: __dv__FC2T2i" \
        "operator/\[(\]+(const T2|T2 const), int\[)\]+"
-    gdb_test "maint dem __ml__FC2T2i" \
+    test_demangling "hp: __ml__FC2T2i" \
        "operator\[*\]+\[(\]+(const T2|T2 const), int\[)\]+"
-    gdb_test "maint dem __mi__FC2T2i" \
+    test_demangling "hp: __mi__FC2T2i" \
        "operator-\[(\]+(const T2|T2 const), int\[)\]+"
-    gdb_test "maint dem __pl__FC2T2i" \
+    test_demangling "hp: __pl__FC2T2i" \
        "operator\[+\]+\[(\]+(const T2|T2 const), int\[)\]+"
 
 
-    gdb_test_exact "maint demangle h__Fc" "h(char)"
-    gdb_test_exact "maint demangle h__Fd" "h(double)"
-    gdb_test_exact "maint demangle h__Ff" "h(float)"
-    gdb_test_exact "maint demangle h__Fi" "h(int)"
-    gdb_test_exact "maint demangle f__Fi" "f(int)"
-    gdb_test_exact "maint demangle h__Fl" "h(long)"
+    test_demangling_exact "hp: h__Fc" "h(char)"
+    test_demangling_exact "hp: h__Fd" "h(double)"
+    test_demangling_exact "hp: h__Ff" "h(float)"
+    test_demangling_exact "hp: h__Fi" "h(int)"
+    test_demangling_exact "hp: f__Fi" "f(int)"
+    test_demangling_exact "hp: h__Fl" "h(long)"
 
-    gdb_test_exact "maint demangle h__Fs" "h(short)"
-    gdb_test "maint dem __md__FC2T2RC2T2" \
+    test_demangling_exact "hp: h__Fs" "h(short)"
+    test_demangling "hp: __md__FC2T2RC2T2" \
        "operator%\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __dv__FC2T2RC2T2" \
+    test_demangling "hp: __dv__FC2T2RC2T2" \
        "operator/\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __ml__FC2T2RC2T2" \
+    test_demangling "hp: __ml__FC2T2RC2T2" \
        "operator\[*\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __mi__FC2T2RC2T2" \
+    test_demangling "hp: __mi__FC2T2RC2T2" \
        "operator-\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem __pl__FC2T2RC2T2" \
+    test_demangling "hp: __pl__FC2T2RC2T2" \
        "operator\[+\]+\[(\]+(const T2|T2 const), (const T2|T2 const) &\[)\]+"
-    gdb_test "maint dem g__FcRP1cRPC1cT2" \
+    test_demangling "hp: g__FcRP1cRPC1cT2" \
        "g\[(\]+char, c *\[*\]+&, (const c|c const) *\[*\]+&, c *\[*\]+&\[)\]+"
 
 
-    gdb_test "maint dem g__FdCdT1" \
+    test_demangling "hp: g__FdCdT1" \
        "g\[(\]+double, (const double|double const), double\[)\]+"
-    gdb_test "maint dem g__FfCfT1" \
+    test_demangling "hp: g__FfCfT1" \
        "g\[(\]+float, (const float|float const), float\[)\]+"
-    gdb_test "maint dem g__FlClT1" \
+    test_demangling "hp: g__FlClT1" \
        "g\[(\]+long, (const long|long const), long\[)\]+"
-    gdb_test "maint dem g__FiCiT1" \
+    test_demangling "hp: g__FiCiT1" \
        "g\[(\]+int, (const int|int const), int\[)\]+"
-    gdb_test "maint dem g__FsCsT1" \
+    test_demangling "hp: g__FsCsT1" \
        "g\[(\]+short, (const short|short const), short\[)\]+"
-    gdb_test "maint dem g__FcCcT1" \
+    test_demangling "hp: g__FcCcT1" \
        "g\[(\]+char, (const char|char const), char\[)\]+"
 
 
-    gdb_test_exact "maint demangle f__FicdPc" "f(int, char, double, char *)"
-    gdb_test_exact "maint demangle __nw__FUi" "operator new(unsigned int)"
-    gdb_test_exact "maint demangle __ct__Q3_2T11a1bSFi" "T1::a::b::b(int) static"
-    gdb_test_exact "maint demangle __dt__Q3_2T11a1bSFi" "T1::a::b::~b(int) static"
-    gdb_test_exact "maint demangle put__Q3_2T11a1bSFi" "T1::a::b::put(int) static"
-    gdb_test_exact "maint demangle get__Q2_2T11aSFv" "T1::a::get(void) static"
-    gdb_test_exact "maint demangle put__2T1SFi" "T1::put(int) static"
-    gdb_test_exact "maint demangle put__Q5_2T11a1b1c1dSFi" "T1::a::b::c::d::put(int) static"
-    gdb_test_exact "maint demangle get__Q4_2T11a1b1cSFv" "T1::a::b::c::get(void) static"
-    gdb_test_exact "maint demangle put__Q2_2T11aSFi" "T1::a::put(int) static"
-    gdb_test_exact "maint demangle put__Q4_2T11a1b1cSFi" "T1::a::b::c::put(int) static"
-    gdb_test_exact "maint demangle get__Q3_2T11a1bSFv" "T1::a::b::get(void) static"
-    gdb_test_exact "maint demangle get__2T1SFv" "T1::get(void) static"
-    gdb_test_exact "maint demangle get__Q5_2T11a1b1c1dSFv" "T1::a::b::c::d::get(void) static"
-
-
-    gdb_test_exact "maint demangle bar__3fooFPv"       "foo::bar(void *)"
-    gdb_test "maint dem bar__3fooFPCv" \
+    test_demangling_exact "hp: f__FicdPc" "f(int, char, double, char *)"
+    test_demangling_exact "hp: __nw__FUi" "operator new(unsigned int)"
+    test_demangling_exact "hp: __ct__Q3_2T11a1bSFi" "T1::a::b::b(int) static"
+    test_demangling_exact "hp: __dt__Q3_2T11a1bSFi" "T1::a::b::~b(int) static"
+    test_demangling_exact "hp: put__Q3_2T11a1bSFi" "T1::a::b::put(int) static"
+    test_demangling_exact "hp: get__Q2_2T11aSFv" "T1::a::get(void) static"
+    test_demangling_exact "hp: put__2T1SFi" "T1::put(int) static"
+    test_demangling_exact "hp: put__Q5_2T11a1b1c1dSFi" "T1::a::b::c::d::put(int) static"
+    test_demangling_exact "hp: get__Q4_2T11a1b1cSFv" "T1::a::b::c::get(void) static"
+    test_demangling_exact "hp: put__Q2_2T11aSFi" "T1::a::put(int) static"
+    test_demangling_exact "hp: put__Q4_2T11a1b1cSFi" "T1::a::b::c::put(int) static"
+    test_demangling_exact "hp: get__Q3_2T11a1bSFv" "T1::a::b::get(void) static"
+    test_demangling_exact "hp: get__2T1SFv" "T1::get(void) static"
+    test_demangling_exact "hp: get__Q5_2T11a1b1c1dSFv" "T1::a::b::c::d::get(void) static"
+
+
+    test_demangling_exact "hp: bar__3fooFPv"       "foo::bar(void *)"
+    test_demangling "hp: bar__3fooFPCv" \
             "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+"
-    gdb_test_exact "maint demangle bar__3fooCFPv"      "foo::bar(void *) const"
-    gdb_test "maint dem bar__3fooCFPCv" \
+    test_demangling_exact "hp: bar__3fooCFPv"      "foo::bar(void *) const"
+    test_demangling "hp: bar__3fooCFPCv" \
            "foo::bar\[(\]+(const void|void const) *\[*\]+\[)\]+ const"
-    gdb_test_exact "maint demangle __eq__3fooFR3foo"   "foo::operator==(foo &)"
-    gdb_test "maint dem __eq__3fooFRC3foo" \
+    test_demangling_exact "hp: __eq__3fooFR3foo"   "foo::operator==(foo &)"
+    test_demangling "hp: __eq__3fooFRC3foo" \
         "foo::operator==\[(\]+(const foo|foo const) &\[)\]+"
-    gdb_test_exact "maint demangle __eq__3fooCFR3foo"  "foo::operator==(foo &) const"
-    gdb_test "maint dem __eq__3fooCFRC3foo" \
+    test_demangling_exact "hp: __eq__3fooCFR3foo"  "foo::operator==(foo &) const"
+    test_demangling "hp: __eq__3fooCFRC3foo" \
        "foo::operator==\[(\]+(const foo|foo const) &\[)\]+ const"
 
-    gdb_test_exact "maint demangle bar__3fooFiT16FooBar" "foo::bar(int, int, FooBar)"
+    test_demangling_exact "hp: bar__3fooFiT16FooBar" "foo::bar(int, int, FooBar)"
 
-    gdb_test_exact "maint demangle bar__3fooFPiN51PdN37PcN211T1iN215" \
+    test_demangling_exact "hp: bar__3fooFPiN51PdN37PcN211T1iN215" \
       "foo::bar(int *, int *, int *, int *, int *, int *, double *, double *, double *, double *, char *, char *, char *, int *, int, int, int)"
 
 
     # HP aCC specific tests. HP aCC demangling does not use __pt__ for
     # template specifications.  There are other differences as well.
 
-    gdb_test_exact "maint demangle __dt__2T5XTPFiPPdPv_i__Fv" "T5<int (*)(int, double **, void *)>::~T5(void)"
+    test_demangling_exact "hp: __dt__2T5XTPFiPPdPv_i__Fv" "T5<int (*)(int, double **, void *)>::~T5(void)"
 
-    gdb_test_exact "maint demangle __ct__1cFi" "c::c(int)"
+    test_demangling_exact "hp: __ct__1cFi" "c::c(int)"
 
-    gdb_test_exact "maint demangle __dt__2T5XTi__Fv" "T5<int>::~T5(void)"
+    test_demangling_exact "hp: __dt__2T5XTi__Fv" "T5<int>::~T5(void)"
 
-    gdb_test_exact "maint demangle __dt__2T5XTc__Fv" "T5<char>::~T5(void)"
+    test_demangling_exact "hp: __dt__2T5XTc__Fv" "T5<char>::~T5(void)"
 
-    gdb_test_exact "maint demangle __ct__2T2Fi" "T2::T2(int)"
-    gdb_test_exact "maint demangle __dt__2T1Fv" "T1::~T1(void)"
+    test_demangling_exact "hp: __ct__2T2Fi" "T2::T2(int)"
+    test_demangling_exact "hp: __dt__2T1Fv" "T1::~T1(void)"
 
-    gdb_test_exact "maint demangle __dt__2T5XT1x__Fv" "T5<x>::~T5(void)"
+    test_demangling_exact "hp: __dt__2T5XT1x__Fv" "T5<x>::~T5(void)"
 
-    gdb_test_exact "maint demangle __dt__2T5XTPFcPv_i__Fv" "T5<int (*)(char, void *)>::~T5(void)"
+    test_demangling_exact "hp: __dt__2T5XTPFcPv_i__Fv" "T5<int (*)(char, void *)>::~T5(void)"
     
-    gdb_test_exact "maint demangle __ct__2T5XTPFiPPdPv_i__Fi" "T5<int (*)(int, double **, void *)>::T5(int)"
+    test_demangling_exact "hp: __ct__2T5XTPFiPPdPv_i__Fi" "T5<int (*)(int, double **, void *)>::T5(int)"
 
-    gdb_test_exact "maint demangle __dl__2T5XT1x__SFPv" "T5<x>::operator delete(void *) static"
+    test_demangling_exact "hp: __dl__2T5XT1x__SFPv" "T5<x>::operator delete(void *) static"
     
-    gdb_test_exact "maint demangle X__2T5XT1x" "T5<x>::X"
+    test_demangling_exact "hp: X__2T5XT1x" "T5<x>::X"
 
-    gdb_test_exact "maint demangle __ct__2T5XTi__Fi" "T5<int>::T5(int)"
+    test_demangling_exact "hp: __ct__2T5XTi__Fi" "T5<int>::T5(int)"
 
-    gdb_test_exact "maint demangle __ct__2T5XTc__Fi" "T5<char>::T5(int)"
+    test_demangling_exact "hp: __ct__2T5XTc__Fi" "T5<char>::T5(int)"
 
-    gdb_test_exact "maint demangle __dl__2T5XTPFcPv_i__SFPv" "T5<int (*)(char, void *)>::operator delete(void *) static"
+    test_demangling_exact "hp: __dl__2T5XTPFcPv_i__SFPv" "T5<int (*)(char, void *)>::operator delete(void *) static"
 
-    gdb_test_exact "maint demangle X__2T5XTPFcPv_i" "T5<int (*)(char, void *)>::X"
+    test_demangling_exact "hp: X__2T5XTPFcPv_i" "T5<int (*)(char, void *)>::X"
 
-    gdb_test_exact "maint demangle __ct__2T5XT1x__Fi" "T5<x>::T5(int)"
+    test_demangling_exact "hp: __ct__2T5XT1x__Fi" "T5<x>::T5(int)"
 
-    gdb_test_exact "maint demangle __dl__2T5XTPFiPPdPv_i__SFPv" "T5<int (*)(int, double **, void *)>::operator delete(void *) static"
-    gdb_test_exact "maint demangle X__2T5XTPFiPPdPv_i" "T5<int (*)(int, double **, void *)>::X"
+    test_demangling_exact "hp: __dl__2T5XTPFiPPdPv_i__SFPv" "T5<int (*)(int, double **, void *)>::operator delete(void *) static"
+    test_demangling_exact "hp: X__2T5XTPFiPPdPv_i" "T5<int (*)(int, double **, void *)>::X"
 
-    gdb_test_exact "maint demangle __dl__2T5XTi__SFPv" "T5<int>::operator delete(void *) static"
+    test_demangling_exact "hp: __dl__2T5XTi__SFPv" "T5<int>::operator delete(void *) static"
 
-    gdb_test_exact "maint demangle __dl__2T5XTc__SFPv" "T5<char>::operator delete(void *) static"
+    test_demangling_exact "hp: __dl__2T5XTc__SFPv" "T5<char>::operator delete(void *) static"
 
-    gdb_test_exact "maint demangle X__2T5XTc" "T5<char>::X"
+    test_demangling_exact "hp: X__2T5XTc" "T5<char>::X"
 
-    gdb_test_exact "maint demangle X__2T5XTi" "T5<int>::X"
+    test_demangling_exact "hp: X__2T5XTi" "T5<int>::X"
 
-    gdb_test_exact "maint demangle __ct__2T5XTPFcPv_i__Fi" "T5<int (*)(char, void *)>::T5(int)"
+    test_demangling_exact "hp: __ct__2T5XTPFcPv_i__Fi" "T5<int (*)(char, void *)>::T5(int)"
     
-    gdb_test_exact "maint demangle __dt__2T1XTc__Fv" "T1<char>::~T1(void)"
+    test_demangling_exact "hp: __dt__2T1XTc__Fv" "T1<char>::~T1(void)"
 
-    gdb_test_exact "maint demangle __dt__2T1XT1t__Fv" "T1<t>::~T1(void)"
+    test_demangling_exact "hp: __dt__2T1XT1t__Fv" "T1<t>::~T1(void)"
 
-    gdb_test_exact "maint demangle __dl__2T1XT1t__SFPv" "T1<t>::operator delete(void *) static"
+    test_demangling_exact "hp: __dl__2T1XT1t__SFPv" "T1<t>::operator delete(void *) static"
 
-    gdb_test_exact "maint demangle __ct__2T1XTc__Fi" "T1<char>::T1(int)"
+    test_demangling_exact "hp: __ct__2T1XTc__Fi" "T1<char>::T1(int)"
 
-    gdb_test_exact "maint demangle __ct__2T1XTc__Fv" "T1<char>::T1(void)"
+    test_demangling_exact "hp: __ct__2T1XTc__Fv" "T1<char>::T1(void)"
 
-    gdb_test_exact "maint demangle __ct__2T1XT1t__Fi" "T1<t>::T1(int)"
+    test_demangling_exact "hp: __ct__2T1XT1t__Fi" "T1<t>::T1(int)"
 
-    gdb_test_exact "maint demangle __ct__2T1XT1t__Fv" "T1<t>::T1(void)"
+    test_demangling_exact "hp: __ct__2T1XT1t__Fv" "T1<t>::T1(void)"
 
-    gdb_test_exact "maint demangle __dl__2T1XTc__SFPv" "T1<char>::operator delete(void *) static"
+    test_demangling_exact "hp: __dl__2T1XTc__SFPv" "T1<char>::operator delete(void *) static"
 
-    gdb_test_exact "maint demangle elem__6vectorXTd__Fi" "vector<double>::elem(int)"
+    test_demangling_exact "hp: elem__6vectorXTd__Fi" "vector<double>::elem(int)"
 
-    gdb_test_exact "maint demangle elem__6vectorXTi__Fi" "vector<int>::elem(int)"
+    test_demangling_exact "hp: elem__6vectorXTi__Fi" "vector<int>::elem(int)"
 
-    gdb_test_exact "maint demangle __ct__6vectorXTd__Fi" "vector<double>::vector(int)"
+    test_demangling_exact "hp: __ct__6vectorXTd__Fi" "vector<double>::vector(int)"
 
-    gdb_test_exact "maint demangle __ct__6vectorXTi__Fi" "vector<int>::vector(int)"
+    test_demangling_exact "hp: __ct__6vectorXTi__Fi" "vector<int>::vector(int)"
 
-    gdb_test_exact "maint demangle __ct__9DListNodeXTR6RLabel__FR6RLabelP9DListNodeXTR6RLabel_T2" \
+    test_demangling_exact "hp: __ct__9DListNodeXTR6RLabel__FR6RLabelP9DListNodeXTR6RLabel_T2" \
        "DListNode<RLabel &>::DListNode(RLabel &, DListNode<RLabel &> *, DListNode<RLabel &> *)"
 
 
     # Absolute integer constants in template args
 
-    gdb_test_exact "maint demangle elem__6vectorXTiUP34__Fi" "vector<int,34U>::elem(int)"
-    gdb_test_exact "maint demangle elem__6vectorXUP2701Td__Fi" "vector<2701U,double>::elem(int)"
-    gdb_test_exact "maint demangle elem__6vectorXTiSP334__Fi" "vector<int,334>::elem(int)"
-    gdb_test_exact "maint demangle elem__6vectorXTiSN67__Fi" "vector<int,-67>::elem(int)"
-    gdb_test_exact "maint demangle elem__6vectorXTiSM__SCFPPd" "vector<int,-2147483648>::elem(double **) static const"
-    gdb_test_exact "maint demangle elem__6vectorXTiSN67UP4000TRs__Fi" "vector<int,-67,4000U,short &>::elem(int)"
-    gdb_test_exact "maint demangle elem__6vectorXTiSN67TRdTFPv_i__Fi" "vector<int,-67,double &,int (void *)>::elem(int)"
-    gdb_test_exact "maint demangle X__6vectorXTiSN67TdTPvUP5TRs" "vector<int,-67,double,void *,5U,short &>::X"
+    test_demangling_exact "hp: elem__6vectorXTiUP34__Fi" "vector<int,34U>::elem(int)"
+    test_demangling_exact "hp: elem__6vectorXUP2701Td__Fi" "vector<2701U,double>::elem(int)"
+    test_demangling_exact "hp: elem__6vectorXTiSP334__Fi" "vector<int,334>::elem(int)"
+    test_demangling_exact "hp: elem__6vectorXTiSN67__Fi" "vector<int,-67>::elem(int)"
+    test_demangling_exact "hp: elem__6vectorXTiSM__SCFPPd" "vector<int,-2147483648>::elem(double **) static const"
+    test_demangling_exact "hp: elem__6vectorXTiSN67UP4000TRs__Fi" "vector<int,-67,4000U,short &>::elem(int)"
+    test_demangling_exact "hp: elem__6vectorXTiSN67TRdTFPv_i__Fi" "vector<int,-67,double &,int (void *)>::elem(int)"
+    test_demangling_exact "hp: X__6vectorXTiSN67TdTPvUP5TRs" "vector<int,-67,double,void *,5U,short &>::X"
 
     # Named constants in template args
 
-    gdb_test_exact "maint demangle elem__6vectorXTiA3foo__Fi" "vector<int,&foo>::elem(int)"
-    gdb_test_exact "maint demangle elem__6vectorXTiA3fooTPvA5Label__FiPPvT2" "vector<int,&foo,void *,&Label>::elem(int, void **, void **)"
-    gdb_test_exact "maint demangle elem__6vectorXTiSN42A3foo__Fi" "vector<int,-42,&foo>::elem(int)"
+    test_demangling_exact "hp: elem__6vectorXTiA3foo__Fi" "vector<int,&foo>::elem(int)"
+    test_demangling_exact "hp: elem__6vectorXTiA3fooTPvA5Label__FiPPvT2" "vector<int,&foo,void *,&Label>::elem(int, void **, void **)"
+    test_demangling_exact "hp: elem__6vectorXTiSN42A3foo__Fi" "vector<int,-42,&foo>::elem(int)"
 
     # Alternate entry points for functions
 
-    gdb_test_exact "maint demangle __ct__2T5XTPFcPv_i__Fi_2" "T5<int (*)(char, void *)>::T5(int)"
-    gdb_test_exact "maint demangle __ct__2T5XTPFcPv_i__Fi_19" "T5<int (*)(char, void *)>::T5(int)"
-    gdb_test_exact "maint demangle f__FicdPcPFci_v_34" "f(int, char, double, char *, void (*)(char, int))"
+    test_demangling_exact "hp: __ct__2T5XTPFcPv_i__Fi_2" "T5<int (*)(char, void *)>::T5(int)"
+    test_demangling_exact "hp: __ct__2T5XTPFcPv_i__Fi_19" "T5<int (*)(char, void *)>::T5(int)"
+    test_demangling_exact "hp: f__FicdPcPFci_v_34" "f(int, char, double, char *, void (*)(char, int))"
 
 
     # Template partial specializations
 
 # FIXME!  The # characters don't go through expect, and backslashes don't seem to work.
-#    gdb_test_exact "maint demangle spec__13Spec<#1,#1.*>XTiTPi_FPi" "Spec<int,int *>::spec(int *)"
-#    gdb_test_exact "maint demangle spec__16Spec<#1,#1.&,#1>XTiTRiTi_FPi" "Spec<int,int &, int>::spec(int *)"
+#    test_demangling_exact "hp: spec__13Spec<#1,#1.*>XTiTPi_FPi" "Spec<int,int *>::spec(int *)"
+#    test_demangling_exact "hp: spec__16Spec<#1,#1.&,#1>XTiTRiTi_FPi" "Spec<int,int &, int>::spec(int *)"
 # Fake test -- replace # with %
-    gdb_test_exact "maint demangle spec__13Spec<%1,%1.*>XTiTPi_FPi" "Spec<int,int *>::spec(int *)"
-    gdb_test_exact "maint demangle spec__16Spec<%1,%1.&,%1>XTiTRiTi_FPi" "Spec<int,int &,int>::spec(int *)"
+    test_demangling_exact "hp: spec__13Spec<%1,%1.*>XTiTPi_FPi" "Spec<int,int *>::spec(int *)"
+    test_demangling_exact "hp: spec__16Spec<%1,%1.&,%1>XTiTRiTi_FPi" "Spec<int,int &,int>::spec(int *)"
 
     # Global template functions
 
-    gdb_test_exact "maint demangle add__XTc_FcT1" "add<char>(char, char)"
-    gdb_test_exact "maint demangle add__XTcSP9A5label_FcPPlT1" "add<char,9,&label>(char, long **, char)"
-    gdb_test_exact "maint demangle add__XTPfTFPd_f_FcT1" "add<float *,float (double *)>(char, char)"
+    test_demangling_exact "hp: add__XTc_FcT1" "add<char>(char, char)"
+    test_demangling_exact "hp: add__XTcSP9A5label_FcPPlT1" "add<char,9,&label>(char, long **, char)"
+    test_demangling_exact "hp: add__XTPfTFPd_f_FcT1" "add<float *,float (double *)>(char, char)"
 
     # Template for template arg
 
-    gdb_test_exact "maint demangle unLink__12basic_stringXTcT18string_char_traitsXTc_T9allocator_Fv" "basic_string<char,string_char_traits<char>,allocator>::unLink(void)"
+    test_demangling_exact "hp: unLink__12basic_stringXTcT18string_char_traitsXTc_T9allocator_Fv" "basic_string<char,string_char_traits<char>,allocator>::unLink(void)"
+
+    test_demangling_exact "hp: _Utf390_1__1_9223372036854775807__9223372036854775" \
+           "Can't demangle \"_Utf390_1__1_9223372036854775807__9223372036854775\""
+}
+
 
+proc catch_demangling_errors {command} {
+    if {[catch $command result]} {
+       puts "ERROR: demangle.exp: while running $command: $result"
+    }
 }
+
 # Test support for different demangling styles.  Note that this does
 # not depend upon running the test program and does not depend upon
 # gdb being able to lookup any C++ symbols.  It simply calls the 
@@ -1507,11 +1547,14 @@ proc do_tests {} {
     gdb_expect -re "$gdb_prompt $"
     send_gdb "set width 0\n"
     gdb_expect -re "$gdb_prompt $"
-    
-    test_lucid_style_demangling
-    test_gnu_style_demangling
-    test_arm_style_demangling
-    test_hp_style_demangling
+
+    # Using catch_demangling_errors this way ensures that, if one of
+    # the functions raises a Tcl error, then it'll get reported, and
+    # the rest of the functions will still run.
+    catch_demangling_errors test_lucid_style_demangling
+    catch_demangling_errors test_gnu_style_demangling
+    catch_demangling_errors test_arm_style_demangling
+    catch_demangling_errors test_hp_style_demangling
 }
 
 do_tests
index ed3cc2cfbcce5fc2049b7c5f0259376f7d4cd9a4..80baf75d2e40513b637c35172f0d6115281d4d0e 100644 (file)
@@ -104,7 +104,8 @@ gdb_expect {
 
 send_gdb "ptype a_instance\n"
 gdb_expect {
-    -re "type = class A \{\r\n\[\t \]*public:\r\n\[\t \]*int a;\r\n\[\t \]*int aa;\[\r\n\t \]+A\\(void\\);\r\n\[\t \]*int afoo\\(void\\);\r\n\[\t \]*int foo\\(void\\);\r\n\}.*$gdb_prompt $"  { pass "ptype a_instance" }
+    -re "type = class A \{\r\n\[\t \]*public:\r\n\[\t \]*int a;\r\n\[\t \]*int aa;\[\r\n\t ]+A & operator=\\(A const &\\);\[\r\n\t ]+A\\(A const &\\);\[\r\n\t ]+A\\(void\\);\r\n\[\t \]*int afoo\\(void\\);\r\n\[\t \]*int foo\\(void\\);\r\n\}.*$gdb_prompt $"  { pass "ptype a_instance (with synth ops)" }
+    -re "type = class A \{\r\n\[\t \]*public:\r\n\[\t \]*int a;\r\n\[\t \]*int aa;\[\r\n\t \]+A\\(void\\);\r\n\[\t \]*int afoo\\(void\\);\r\n\[\t \]*int foo\\(void\\);\r\n\}.*$gdb_prompt $"  { pass "ptype a_instance (no synth ops)" }
     -re ".*$gdb_prompt $"   {  fail "ptype a_instance" }
     timeout             { fail "(timeout) ptype a_instance" }
 }
@@ -125,7 +126,7 @@ gdb_expect {
   if {$gcc_compiled} then {
       send_gdb "ptype d_instance\n"
       gdb_expect {
-         -re "type = class D : private A, public B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int d;\r\n\[\t \]*int dd;\[\r\n\t \]+D\\(void\\);\r\n\[\t \]*int dfoo\\(void\\);\r\n\[\t \]*int foo\\(void\\);\r\n\}.*$gdb_prompt $"  { pass "ptype d_instance" }
+         -re "type = class D : private A, public B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int d;\r\n\[\t \]*int dd;\[\r\n\t ]+D & operator=\\(D const &\\);\[\r\n\t ]+D\\(D const &\\);\[\r\n\t \]+D\\(void\\);\r\n\[\t \]*int dfoo\\(void\\);\r\n\[\t \]*int foo\\(void\\);\r\n\}.*$gdb_prompt $"  { pass "ptype d_instance" }
          -re ".*$gdb_prompt $"   {  fail "ptype d_instance" }
          timeout             { fail "(timeout) ptype d_instance" }
       }
@@ -154,7 +155,7 @@ gdb_expect {
   if {$gcc_compiled} {
       send_gdb "ptype e_instance\n"
       gdb_expect {
-         -re "type = class E : public A, private B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int e;\r\n\[\t \]*int ee;\[\r\n\t \]+E\\(void\\);\r\n\[\t \]*int efoo\\(void\\);\r\n\[\t \]*int foo\\(void\\);\r\n\}.*$gdb_prompt $"  { pass "ptype e_instance" }
+         -re "type = class E : public A, private B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int e;\r\n\[\t \]*int ee;\[\r\n\t ]+E & operator=\\(E const &\\);\[\r\n\t ]+E\\(E const &\\);\[\r\n\t \]+E\\(void\\);\r\n\[\t \]*int efoo\\(void\\);\r\n\[\t \]*int foo\\(void\\);\r\n\}.*$gdb_prompt $"  { pass "ptype e_instance" }
          -re ".*$gdb_prompt $"   {  fail "ptype e_instance" }
          timeout             { fail "(timeout) ptype e_instance" }
       }
@@ -182,6 +183,7 @@ gdb_expect {
 
 send_gdb "ptype f_instance\n"
 gdb_expect {
+    -re "type = class F : private A, public B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int f;\r\n\[\t \]*int ff;\[\r\n\t ]+F & operator=\\(F const &\\);\[\r\n\t ]+F\\(F const &\\);\[\r\n\t \]+F\\(void\\);\r\n\[\t \]*int ffoo\\(void\\);\r\n\[\t \]*int foo\\(void\\);\r\n\}.*$gdb_prompt $"  { pass "ptype f_instance" }
     -re "type = class F : private A, public B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int f;\r\n\[\t \]*int ff;\[\r\n\t \]+F\\(void\\);\r\n\[\t \]*int ffoo\\(void\\);\r\n\[\t \]*int foo\\(void\\);\r\n\}.*$gdb_prompt $"  { pass "ptype f_instance" }
     -re ".*$gdb_prompt $"   {  fail "ptype f_instance" }
     timeout             { fail "(timeout) ptype f_instance" }
index a3939dc0582d7b4b1debdc08a70986e85ecac576..edfa689d90114de6dbb03ccdf46f65910628a3e7 100644 (file)
@@ -197,7 +197,7 @@ gdb_expect {
 
 send_gdb "print res\n"
 gdb_expect {
-   -re "\\$\[0-9\]* = \[0-9\]*\r\n$gdb_prompt $" {
+   -re "\\$\[0-9\]* = .\[0-9\]*\r\n$gdb_prompt $" {
        pass "print res in getFunky"
    }
    -re ".*$gdb_prompt $" { fail "print res in getfunky" }
index ffeb73962fd932d510493a410de4b395f123b283..4cf93180139ff1a0bcd2e0361777f419ab233fe7 100644 (file)
@@ -498,6 +498,8 @@ main()
 
   /* Class with enumeration inside it */ 
   ClassWithEnum obj_with_enum;
+  obj_with_enum.priv_enum = ClassWithEnum::red;
+  obj_with_enum.x = 0;
   obj_with_enum.priv_enum = ClassWithEnum::green;
 
   return foo.*pmi;
index 40feb3b5e844b5b44e490e8970212ffbc82ede50..58d07de930e4c0b0c57357e05d2ee476cb321c35 100644 (file)
@@ -58,7 +58,7 @@ int main ()
     float arg11 =100.0;
     double arg12 = 200.0;
 
-    char *str = "A";
+    char *str = (char *) "A";
     foo foo_instance1(111);
     foo foo_instance2(222, str);
     foo foo_instance3(foo_instance2);
index c90b51d6be31d99de0217f96f22828153877580a..219182b252d2b6882ad81e2a6c5fdfdcc70878c2 100644 (file)
@@ -670,11 +670,4 @@ gdb_test "info break" \
         timeout { fail "(timeout) continue to bp overloaded : double"  }
     }
 
-    send_gdb "cont\n"
-    gdb_expect {
-        -re "Continuing.\r\n\r\nProgram exited normally.\r\n$gdb_prompt $" {
-            pass "finish program"
-        }
-        -re "$gdb_prompt $" { fail "finish program"  }
-        timeout { fail "(timeout) finish program"  }
-    }
+    gdb_continue_to_end "finish program"
index 7f255909575b2e0276c0cf58bfa8ae8eeac4178c..2a9d337cbb99c6d537bf4a07afc491e3dbdc0c0b 100644 (file)
@@ -1,4 +1,5 @@
-# Copyright (C) 1998 Free Software Foundation, Inc.
+# Tests for reference types with short type variables in GDB.
+# Copyright (C) 1998, 1999 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # written by Elena Zannoni (ezannoni@cygnus.com)
 
-# This file is part of the gdb testsuite
-#
-# tests for reference types
-# with short type variables.
-# 
-
 if $tracelevel then {
         strace $tracelevel
         }
@@ -162,6 +157,7 @@ gdb_expect {
 send_gdb "ptype as\n"
 gdb_expect {
     -re "type = short \\\[4\\\].*$gdb_prompt $"  { pass "ptype as" }
+    -re "type = short int \\\[4\\\].*$gdb_prompt $"  { pass "ptype as" }
     -re ".*$gdb_prompt $"   {  fail "ptype as" }
     timeout             { fail "(timeout) ptype as" }
 }
@@ -197,7 +193,10 @@ send_gdb "print rs\n"
 gdb_expect {
     -re ".\[0-9\]* = \\(short &\\) @$hex: -1.*$gdb_prompt $" {
         pass "print value of rs"
-      }
+    }
+    -re ".\[0-9\]* = \\(short int &\\) @$hex: -1.*$gdb_prompt $" {
+        pass "print value of rs"
+    }
     -re ".*$gdb_prompt $" { fail "print value of rs" }
     timeout           { fail "(timeout) print value of rs" }
     eof { fail "print rs ($GDB dumped core) (FIXME)" ; gdb_start_again ; }
@@ -207,6 +206,7 @@ gdb_expect {
 send_gdb "ptype rs\n"
 gdb_expect {
     -re "type = short &.*$gdb_prompt $"  { pass "ptype rs" }
+    -re "type = short int &.*$gdb_prompt $"  { pass "ptype rs" }
     -re ".*$gdb_prompt $"   {  fail "ptype rs" }
     timeout             { fail "(timeout) ptype rs" }
 }
@@ -225,6 +225,7 @@ gdb_expect {
 send_gdb "ptype rps\n"
 gdb_expect {
     -re "type = short \\*&.*$gdb_prompt $"  { pass "ptype rps" }
+    -re "type = short int \\*&.*$gdb_prompt $"  { pass "ptype rps" }
     -re ".*$gdb_prompt $"   {  fail "ptype rps" }
     timeout             { fail "(timeout) ptype rps" }
 }
@@ -244,6 +245,7 @@ gdb_expect {
 send_gdb "ptype ras\n"
 gdb_expect {
     -re "type = short \\\(&\\\)\\\[4\\\].*$gdb_prompt $"  { pass "ptype ras" }
+    -re "type = short int \\\(&\\\)\\\[4\\\].*$gdb_prompt $"  { pass "ptype ras" }
     -re ".*$gdb_prompt $"   {  fail "ptype ras" }
     timeout             { fail "(timeout) ptype ras" }
 }
index 675414754c488dce099a70ddc02c1536511e87fc..555772151e43b4de8500bac78af3b08bae6c0ee7 100644 (file)
@@ -1,4 +1,5 @@
-# Copyright (C) 1998 Free Software Foundation, Inc.
+# Tests for reference types with elementary type variables in GDB.
+# Copyright (C) 1998, 1999 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # written by Elena Zannoni (ezannoni@cygnus.com)
 
-# This file is part of the gdb testsuite
-#
-# tests for reference types
-# with elementary type variables.
-# 
-
 if $tracelevel then {
         strace $tracelevel
         }
@@ -140,6 +135,7 @@ gdb_expect {
 send_gdb "ptype US\n"
 gdb_expect {
     -re "type = unsigned short.*$gdb_prompt $"  { pass "ptype US" }
+    -re "type = short unsigned.*$gdb_prompt $"  { pass "ptype US" }
     -re ".*$gdb_prompt $"   {  fail "ptype US" }
     timeout             { fail "(timeout) ptype US" }
 }
@@ -212,6 +208,7 @@ gdb_expect {
 send_gdb "ptype UL\n"
 gdb_expect {
     -re "type = unsigned long.*$gdb_prompt $"  { pass "ptype UL" }
+    -re "type = long unsigned.*$gdb_prompt $"  { pass "ptype UL" }
     -re ".*$gdb_prompt $"   {  fail "ptype UL" }
     timeout             { fail "(timeout) ptype UL" }
 }
@@ -284,6 +281,7 @@ gdb_expect {
 send_gdb "ptype rS\n"
 gdb_expect {
     -re "type = short &.*$gdb_prompt $"  { pass "ptype rS" }
+    -re "type = short int &.*$gdb_prompt $"  { pass "ptype rS" }
     -re ".*$gdb_prompt $"   {  fail "ptype rS" }
     timeout             { fail "(timeout) ptype rS" }
 }
@@ -293,6 +291,7 @@ gdb_expect {
 send_gdb "ptype rUS\n"
 gdb_expect {
     -re "type = unsigned short &.*$gdb_prompt $"  { pass "ptype rUS" }
+    -re "type = short unsigned int &.*$gdb_prompt $"  { pass "ptype rUS" }
     -re ".*$gdb_prompt $"   {  fail "ptype rUS" }
     timeout             { fail "(timeout) ptype rUS" }
 }
@@ -319,6 +318,7 @@ gdb_expect {
 send_gdb "ptype rL\n"
 gdb_expect {
     -re "type = long &.*$gdb_prompt $"  { pass "ptype rL" }
+    -re "type = long int &.*$gdb_prompt $"  { pass "ptype rL" }
     -re ".*$gdb_prompt $"   {  fail "ptype rL" }
     timeout             { fail "(timeout) ptype rL" }
 }
@@ -327,6 +327,7 @@ gdb_expect {
 send_gdb "ptype rUL\n"
 gdb_expect {
     -re "type = unsigned long &.*$gdb_prompt $"  { pass "ptype rUL" }
+    -re "type = long unsigned int &.*$gdb_prompt $"  { pass "ptype rUL" }
     -re ".*$gdb_prompt $"   {  fail "ptype rUL" }
     timeout             { fail "(timeout) ptype rUL" }
 }
@@ -372,7 +373,10 @@ send_gdb "print rS\n"
 gdb_expect {
     -re ".\[0-9\]* = \\(short &\\) @$hex: -14.*$gdb_prompt $" {
         pass "print value of rS"
-      }
+    }
+    -re ".\[0-9\]* = \\(short int &\\) @$hex: -14.*$gdb_prompt $" {
+        pass "print value of rS"
+    }
     -re ".*$gdb_prompt $" { fail "print value of rS" }
     timeout           { fail "(timeout) print value of rS" }
   }
@@ -382,7 +386,10 @@ send_gdb "print rUS\n"
 gdb_expect {
     -re ".\[0-9\]* = \\(unsigned short &\\) @$hex: 7.*$gdb_prompt $" {
         pass "print value of rUS"
-      }
+    }
+    -re ".\[0-9\]* = \\(short unsigned int &\\) @$hex: 7.*$gdb_prompt $" {
+        pass "print value of rUS"
+    }
     -re ".*$gdb_prompt $" { fail "print value of rUS" }
     timeout           { fail "(timeout) print value of rUS" }
   }
@@ -412,7 +419,10 @@ send_gdb "print rL\n"
 gdb_expect {
     -re ".\[0-9\]* = \\(long &\\) @$hex: -234.*$gdb_prompt $" {
         pass "print value of rL"
-      }
+    }
+    -re ".\[0-9\]* = \\(long int &\\) @$hex: -234.*$gdb_prompt $" {
+        pass "print value of rL"
+    }
     -re ".*$gdb_prompt $" { fail "print value of rL" }
     timeout           { fail "(timeout) print value of rL" }
   }
@@ -423,7 +433,10 @@ send_gdb "print rUL\n"
 gdb_expect {
     -re ".\[0-9\]* = \\(unsigned long &\\) @$hex: 234.*$gdb_prompt $" {
         pass "print value of rUL"
-      }
+    }
+    -re ".\[0-9\]* = \\(long unsigned int &\\) @$hex: 234.*$gdb_prompt $" {
+        pass "print value of rUL"
+    }
     -re ".*$gdb_prompt $" { fail "print value of rUL" }
     timeout           { fail "(timeout) print value of rUL" }
   }
index b545d072a27f31c5814c0375cc71dff757fd24d9..b6e660f5a5f91006c1a97e4de1156d4f4f8a32f5 100644 (file)
@@ -12,7 +12,7 @@
 -- 
 -- You should have received a copy of the GNU General Public License
 -- along with this program; if not, write to the Free Software
--- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+-- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 -- Please email any bugs, comments, and/or additions to this file to:
 -- bug-gdb@prep.ai.mit.edu
index 1596f3b31e827ab142342d752b5758ff35a08671..6d457998c0007761c9333c432fef75d6de8aefb3 100644 (file)
@@ -12,7 +12,7 @@
 -- 
 -- You should have received a copy of the GNU General Public License
 -- along with this program; if not, write to the Free Software
--- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+-- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 -- Please email any bugs, comments, and/or additions to this file to:
 -- bug-gdb@prep.ai.mit.edu
index 46c4821005a3c3e8575696f5d3ffee7c94d01f58..315d767ee18f1b77ee824b34ed2bfaadaca0385f 100644 (file)
@@ -12,7 +12,7 @@
 # 
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
-# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
 
 # Please email any bugs, comments, and/or additions to this file to:
 # bug-gdb@prep.ai.mit.edu
index 5b87af36d791cc18c04e7832da598a47f6b1bc53..0ee3ecb79fd976cc6ff02d788772e6e3a7940a47 100644 (file)
@@ -35,6 +35,8 @@ if $tracelevel then {
 set prms_id 0
 set bug_id 0
 
+if { [skip_hp_tests] } then { continue }
+
 set testfile "ambiguous"
 set srcfile ${testfile}.cc
 set binfile ${objdir}/${subdir}/${testfile}
@@ -42,9 +44,8 @@ set binfile ${objdir}/${subdir}/${testfile}
 if [get_compiler_info ${binfile} "c++"] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+
+if { $gcc_compiled } then { continue }
 
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
      gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
index 372acd05d7ec37172bb5c2c756c91e9b3ec23e43..b76f04c3726a71b3b3a2e3d34f3f1566f84c9a4b 100644 (file)
@@ -34,11 +34,7 @@ if $tracelevel then {
 set prms_id 0
 set bug_id 0
 
-
-# are we on a target board
-if ![isnative] then {
-    return
-}
+if { [skip_hp_tests] } then { continue }
 
 if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } {
     #setup_xfail "*-*-*"
index e298ee93f7a1b2aef44db55fcb46cf71f0051a77..84b0e4a88487f585c56ace2d38d23d343d93bd2f 100644 (file)
@@ -29,6 +29,8 @@ if $tracelevel then {
     strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
+
 # Thread stuff is _slow_; prepare for long waits.
 #
 # Further, this test has some "null" lines designed
index cb22c96e8fc29a56cda0b122913c338aec900134..f67a2af8053f9561e46281857b4bc14e233165fb 100644 (file)
@@ -25,6 +25,7 @@ if $tracelevel then {
        strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
 
 # Check to see if we have an executable to test.  If not, then either we
 # haven't tried to compile one, or the compilation failed for some reason.
@@ -37,9 +38,8 @@ set binfile ${objdir}/${subdir}/${testfile}
 if [get_compiler_info ${binfile} "c++"] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+
+if { $gcc_compiled } then { continue }
 
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
      gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
index e53210dda0bc4014a500a37269b904f51c464a43..7f1fac95e228d0bfa414e10b1e547d55d5781481 100644 (file)
@@ -29,6 +29,7 @@ if $tracelevel then {
         strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
 
 # Check to see if we have an executable to test.  If not, then either we
 # haven't tried to compile one, or the compilation failed for some reason.
@@ -44,9 +45,8 @@ set binfile ${objdir}/${subdir}/${testfile}
 if [get_compiler_info ${binfile} "c++"] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+
+if { $gcc_compiled } then { continue }
 
 #if  { [gdb_compile "${srcdir}/${subdir}/${srcfile} ${srcdir}/${subdir}/${srcfile1} ${srcdir}/${subdir}/${srcfile2} ${srcdir}/${subdir}/${srcfile3}" "${binfile}" executable {debug c++}] != "" } {
 #     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
index 66f24e90a59e1e24ad7dba6546af4a13c912a5ee..340c609d8d835fe1aafd46b2fd0198cbdae58d4a 100644 (file)
@@ -22,6 +22,7 @@ if $tracelevel then {
         strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
 
 set testfile1 "average"
 set testfile2 "sum"
@@ -47,7 +48,7 @@ if  { [gdb_compile "${binfile1}.o ${binfile2}.o" ${binfile} executable {debug}]
 if [get_compiler_info ${binfile}] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+if { $gcc_compiled } then { continue }
 
 proc dbx_reinitialize_dir { subdir } {
     global gdb_prompt
index 4cafbdcd00168753c104a65434bc369c482b7e5b..64ff488f6d516356be88cd243740d082a4c2ef1a 100644 (file)
@@ -50,6 +50,7 @@ if $tracelevel then {
         strace $tracelevel
         }
 
+if { [skip_hp_tests] } then { continue }
 
 #
 # test running programs
@@ -67,7 +68,7 @@ if [get_compiler_info ${binfile} "c++"] {
 }
  
  
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+if { $gcc_compiled } then { continue }
 
 set cmdline "$CXX ${srcdir}/${subdir}/${srcfile} +A -Wl,-a,archive -g -o ${binfile}"
 
index f7d6089931cacc8a5ad3b746025734f54bdd1551..59a4ffcadb09fbb469b1cfa257d7c35e563d73f6 100644 (file)
@@ -24,10 +24,7 @@ if $tracelevel then {
 set prms_id 0
 set bug_id 0
 
-# are we on a target board
-if ![isnative] then {
-    return
-}
+if { [skip_hp_tests] } then { continue }
 
 if {![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"]} {
     #setup_xfail "*-*.*"
index 7231764f3b4b6967a2c3291eba1492cc6fe51b0a..fdfc6edc8f0ad8e5e1292f4105cd27160376efec 100644 (file)
@@ -24,10 +24,7 @@ if $tracelevel then {
 set prms_id 0
 set bug_id 0
 
-# are we on a target board
-if ![isnative] then {
-    return
-}
+if { [skip_hp_tests] } then { continue }
 
 if {![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"]} {
     #setup_xfail "*-*.*"
index 26c6981f974415534b1a164a20db5e30be92ab43..fc5ee4c3569657d94c7972ee4d01c44bf81792e4 100644 (file)
@@ -24,10 +24,7 @@ if $tracelevel then {
 set prms_id 0
 set bug_id 0
 
-# are we on a target board
-if ![isnative] then {
-    return
-}
+if { [skip_hp_tests] } then { continue }
 
 if {![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"]} {
     #setup_xfail "*-*.*"
index d4899a997e2f4b7128cb878f096db235d98a9810..f648e3654bb125c76e95c4d89bc43d9eddea5912 100644 (file)
@@ -24,10 +24,7 @@ if $tracelevel then {
 set prms_id 0
 set bug_id 0
 
-# are we on a target board
-if ![isnative] then {
-    return
-}
+if { [skip_hp_tests] } then { continue }
 
 if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } {
     verbose "HPUX h/w watch test ignored for non-hppa or pre-HP/UX-10.30 targets."
index 645358ec0da86b286e321538a2b8ab23375c9dce..efa4d705be2c824a5af3308788a440636dc20e39 100644 (file)
@@ -25,6 +25,8 @@ if $tracelevel then {
        strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
+
 # Check to see if we have an executable to test.  If not, then either we
 # haven't tried to compile one, or the compilation failed for some reason.
 # In either case, just notify the user and skip the tests in this file.
@@ -39,7 +41,7 @@ if [get_compiler_info ${binfile} "c++"] {
 }
  
  
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+if { $gcc_compiled } then { continue }
 
 
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
index 320a0d688722610a3cbf9ee989d4fbeb4fe53c0f..9972e2df698580026a676841e1a6bb34092f85c0 100644 (file)
@@ -26,6 +26,8 @@ if $tracelevel then {
     strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
+
 #if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } {
 #    verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets."
 #    return 0
index 1708db8ebb0536480c442ac40639a8635c53f97a..1e522373417ba997379f0f8343dcd3b0467f498f 100644 (file)
@@ -31,14 +31,11 @@ if $tracelevel then {
         strace $tracelevel
         }
 
-
-#
-# test running programs
-#
-
 set prms_id 0
 set bug_id 0
 
+if { [skip_hp_tests] } then { continue }
+
 set testfile "namespace"
 set srcfile ${testfile}.cc
 set binfile ${objdir}/${subdir}/${testfile}
@@ -46,9 +43,8 @@ set binfile ${objdir}/${subdir}/${testfile}
 if [get_compiler_info ${binfile}] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+
+if { $gcc_compiled } then { continue }
 
 
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
index 34606eb668f081380fbd3ce0043116b1eea93191..62fe373a4abeb4fa56a9310a734736ad4b0dd7dd 100644 (file)
@@ -29,6 +29,8 @@ if $tracelevel then {
     strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
+
 set testfile optimize
 set srcfile ${testfile}.c
 set binfile ${objdir}/${subdir}/${testfile}
@@ -38,7 +40,7 @@ if [get_compiler_info ${binfile}] {
 }
 
  
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+if { $gcc_compiled } then { continue }
 
 
 # Vanilla -O, which is the same as +O2
index c8b3ace9961ec89797cb7551ca9bca42bf740cdc..ef34557377f1662fc63bb037692ab48add153a1e 100644 (file)
@@ -31,6 +31,8 @@ if $tracelevel then {
 set prms_id 0
 set bug_id 0
 
+if { [skip_hp_tests] } then { continue }
+
 set testfile pxdb
 set srcfile ${testfile}.c
 set objfile ${objdir}/${subdir}/${testfile}.o
@@ -39,9 +41,8 @@ set binfile ${objdir}/${subdir}/${testfile}
 if [get_compiler_info ${binfile} "c++"] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+
+if { $gcc_compiled } then { continue }
 
 # To build a non-pxdb-ed file, use
 #
index 4bdc3069293310c23744ae9311376fdf677c7a50..d8b0f16f63cbdb053939dea79286497e6e643bfd 100644 (file)
@@ -26,12 +26,9 @@ if $tracelevel then {
        strace $tracelevel
        }
 
-if ![istarget "hppa*-*-*"] {
-    verbose "Wide register test ignored for non-hppa targets."
-    return
-}
+if { [skip_hp_tests] } then { continue }
 
-set testfile "reg_test"
+set testfile "reg-test"
 set srcfile ${testfile}.s
 set binfile ${objdir}/${subdir}/${testfile}
 
index 191050ada4c5b6b3a868b861e4d06b1942c93e79..5588559773c1128cf014784f1cdad9f8ea36de9f 100644 (file)
@@ -36,6 +36,8 @@ if $tracelevel then {
 set prms_id 0
 set bug_id 0
 
+if { [skip_hp_tests] } then { continue }
+
 set testfile "sized-enum"
 set srcfile ${testfile}.c
 set binfile ${objdir}/${subdir}/${testfile}
@@ -44,7 +46,7 @@ if [get_compiler_info ${binfile}] {
     return -1
 }
 
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+if { $gcc_compiled } then { continue }
 
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
      gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
index 1977e92a7d946e21965ffb9af342e20a38f8b51c..17804164244e38ea2408f655693bc8b2a44dc1a3 100644 (file)
@@ -24,10 +24,7 @@ if $tracelevel then {
 set prms_id 0
 set bug_id 0
 
-# are we on a target board
-if ![isnative] then {
-    return
-}
+if { [skip_hp_tests] } then { continue }
 
 set testfile "so-thresh"
 set srcfile ${testfile}.c
index 4f70f51cedecee0a6a7c451e71b42094e87778e0..cb64aa64f65d9a3f1128638885672996eac1ea79 100644 (file)
@@ -54,6 +54,8 @@ if $tracelevel then {
     strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
+
 if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } {
     verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets."
     return 0
index 64ca53daf76d606563f7396e5764072a74eb0fe3..5cdf0a14496b8b2f77df5615995f743ec693d03c 100644 (file)
@@ -33,6 +33,8 @@ if $tracelevel then {
        strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
+
 set testfile "templ-hp"
 set srcfile ${testfile}.cc
 set binfile ${objdir}/${subdir}/${testfile}
@@ -46,7 +48,7 @@ if [get_compiler_info ${binfile} "c++"] {
     return -1;
 }
 
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+if { $gcc_compiled } then { continue }
 
 
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
index 53bf466874971b5dcc9fbab4c9f67fcf94f36332..e40b469c2dee4e660d69798a11299777025d5bdf 100644 (file)
@@ -50,6 +50,8 @@ if $tracelevel then {
     strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
+
 if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } {
     verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets."
     return 0
index 19d69ee929778b4618ac89485ae07583014a920a..7fc7a93462d86c7e5448ae2b548ddcb31063e86f 100644 (file)
@@ -50,6 +50,8 @@ if $tracelevel then {
     strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
+
 if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } {
     verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets."
     return 0
index f5b3637508200587d2288ad826ee40f29a661f7a..2b3ee59583dcccdc2e85498484473adc50866fda 100644 (file)
@@ -25,6 +25,8 @@ if $tracelevel then {
        strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
+
 set testfile "virtfun-hp"
 set srcfile ${testfile}.cc
 set binfile ${objdir}/${subdir}/${testfile}
@@ -32,9 +34,8 @@ set binfile ${objdir}/${subdir}/${testfile}
 if [get_compiler_info ${binfile} "c++"] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+
+if { $gcc_compiled } then { continue }
 
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
      gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
index a7e3b5c513253ebd0869e8883b2036f80f54c425..236af71f7a2c30bb9045d1c9faa630d06684b65d 100644 (file)
@@ -27,6 +27,8 @@ if $tracelevel then {
 set prms_id 0
 set bug_id 0
 
+if { [skip_hp_tests] } then { continue }
+
 set testfile "run-hp"
 set srcfile ${testfile}.c
 set binfile ${objdir}/${subdir}/${testfile}
@@ -35,11 +37,6 @@ if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {deb
 
 }
 
-# are we on a target board
-if ![isnative] then {
-    return
-}
-
 if {![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"]} {
     #setup_xfail "*-*.*"
     return 0
@@ -48,7 +45,7 @@ if {![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"]} {
 if [get_compiler_info ${binfile}] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+if { $gcc_compiled } then { continue }
 
 
 gdb_exit
index a1c3fc823f77a3862c0520dfca7c0775869af4a9..068c1b7b97830d36ce25f400c19856e56b7f9be0 100644 (file)
@@ -23,6 +23,8 @@ if $tracelevel then {
     strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
+
 set prms_id 0
 set bug_id 0
 
@@ -36,7 +38,7 @@ if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {deb
 if [get_compiler_info ${binfile}] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+if { $gcc_compiled } then { continue }
 
 # Prepare for watchpoint tests by setting up two breakpoints and one
 # watchpoint.
index 88ab2fc586400d7ad0971330f074bf408a3d7179..f371852c78dfa2d435f0aa07bcc68594e9d3110b 100644 (file)
@@ -23,6 +23,7 @@ if $tracelevel then {
         strace $tracelevel
         }
 
+if { [skip_hp_tests] } then { continue }
 
 global usestubs
 
@@ -42,7 +43,7 @@ if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {deb
 if [get_compiler_info ${binfile}] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+if { $gcc_compiled } then { continue }
 
 global GDBFLAGS
 set saved_gdbflags $GDBFLAGS
index 4cc7b341e09babf20dcad0ce479260a74c1e999d..9bcdf589df8fb276ebd00b8effd823d9e1d08051 100644 (file)
@@ -23,6 +23,8 @@ if $tracelevel then {
         strace $tracelevel
         }
 
+if { [skip_hp_tests] } then { continue }
+
 global message
 
 #
@@ -49,12 +51,11 @@ if  { [gdb_compile "${binfile}0.o ${binfile}1.o" ${binfile} executable {debug}]
     return -1
 }
 
-
 if [get_compiler_info ${binfile}] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
 
+if { $gcc_compiled } then { continue }
 
 global GDBFLAGS
 set saved_gdbflags $GDBFLAGS
index cf569e9511c0c9f85b40218db37e3cab33fde4d2..36c3ec9376c97cf6cdffbcab9166a4d0c1729aeb 100644 (file)
@@ -22,6 +22,7 @@ if $tracelevel then {
         strace $tracelevel
 }
 
+if { [skip_hp_tests] } then { continue }
 
 set testfile1 "average"
 set testfile2 "sum"
@@ -45,7 +46,7 @@ if  { [gdb_compile "${binfile1}.o ${binfile2}.o" ${binfile} executable {debug}]
 if [get_compiler_info ${binfile}] {
     return -1;
 }
-if {[skip_hp_tests $gcc_compiled]} then { continue }
+if { $gcc_compiled } then { continue }
 
 
 proc xdb_reinitialize_dir { subdir } {
index 86ac7a6bca65ffccaabba21e520fe83d50d78b2a..51573ccfe3ea96dbfc76e52e7959927e19a1fd64 100644 (file)
@@ -277,6 +277,12 @@ if { [lindex $exec_output 0] != 0 } {
     return -1
 }
 
+# HP's assembler has no idea of what to do with .stab directives; detect the
+# use of HP compilers and escape from here.  (No doubt a better heuristic
+# could be devised.)
+
+if { [ info exists CC ] && [ string first "/opt/ansic/bin/cc" "$CC" ] >= 0 } then { continue }
+
 if  { [gdb_compile "${srcfile}" "${binfile}" object ""] != "" } {
      gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
 }
index c61abb6f592b1ee146f0d4a4f661efb1cf222179..0e9bd2957a7554bb94031433d728d4e64a0d094f 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (C) 1992, 1994, 1995, 1997 Free Software Foundation, Inc.
+# Copyright (C) 1992, 1994, 1995, 1997, 1999 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -313,6 +313,7 @@ proc runto_main { } {
     return 1
 }
 
+
 # gdb_test COMMAND PATTERN MESSAGE -- send a command to gdb; test the result.
 #
 # COMMAND is the command to execute, send to GDB with send_gdb.  If
@@ -834,13 +835,11 @@ proc skip_chill_tests {} {
     return $skip_chill
 }
 
-# skip all the tests in the file if you are not on an hppa running hpux target.
-# and you compiled with gcc
-proc skip_hp_tests {gcc_used} {
-  #  if ![info exists do_hp_tests] {
-  #    return 1;
-  #  }
-    eval set skip_hp [expr ![isnative] || ![istarget "hppa*-*-hpux*"] || $gcc_used!=0 ]
+# Skip all the tests in the file if you are not on an hppa running
+# hpux target.
+
+proc skip_hp_tests {} {
+    eval set skip_hp [ expr ![isnative] || ![istarget "hppa*-*-hpux*"] ]
     verbose "Skip hp tests is $skip_hp"
     return $skip_hp
 }
@@ -1160,6 +1159,7 @@ proc gdb_finish { } {
 }
 
 global debug_format
+set debug_format "unknown"
 
 # Run the gdb command "info source" and extract the debugging format
 # information from the output and save it in debug_format.
@@ -1331,4 +1331,51 @@ proc gdb_get_line_number {text {file /omitted/}} {
     return $result;
 }
 
+# gdb_continue_to_end:
+#      The case where the target uses stubs has to be handled specially. If a
+#       stub is used, we set a breakpoint at exit because we cannot rely on
+#       exit() behavior of a remote target.
+# 
+# mssg is the error message that gets printed.
+
+proc gdb_continue_to_end {mssg} {
+  if [target_info exists use_gdb_stub] {
+    if {![gdb_breakpoint "exit"]} {
+      return 0
+    }
+    gdb_test "continue" "Continuing..*Breakpoint .*exit.*" \
+      "continue until exit at $mssg"
+  } else {
+    # Continue until we exit.  Should not stop again.
+    # Don't bother to check the output of the program, that may be
+    # extremely tough for some remote systems.
+    gdb_test "continue"\
+      "Continuing.\[\r\n0-9\]+Program exited normally\\..*"\
+      "continue until exit at $mssg"
+  }
+}
+
+proc rerun_to_main {} {
+  global gdb_prompt
+
+  if [target_info exists use_gdb_stub] {
+    gdb_run_cmd
+    gdb_expect {
+      -re ".*Breakpoint .*main .*$gdb_prompt $"\
+             {pass "rerun to main" ; return 0}
+      -re "$gdb_prompt $"\
+             {fail "rerun to main" ; return 0}
+      timeout {fail "(timeout) rerun to main" ; return 0}
+    }
+  } else {
+    send_gdb "run\n"
+    gdb_expect {
+      -re "Starting program.*$gdb_prompt $"\
+             {pass "rerun to main" ; return 0}
+      -re "$gdb_prompt $"\
+             {fail "rerun to main" ; return 0}
+      timeout {fail "(timeout) rerun to main" ; return 0}
+    }
+  }
+}
 
index 6a7ab092d7caf0e2aef44c2744a5f55adf3cb378..d11a2e92fada985f98de184083a6e1e8aa225ce2 100644 (file)
@@ -104,7 +104,9 @@ static void prune_threads PARAMS ((void));
 
 static struct target_thread_vector *target_thread_functions;
 
-int
+static int target_find_new_threads PARAMS ((void));
+
+static int
 target_find_new_threads ()
 {
   int retval = 0;
@@ -698,7 +700,6 @@ void
 _initialize_thread ()
 {
   static struct cmd_list_element *thread_apply_list = NULL;
-  extern struct cmd_list_element *cmdlist;
 
   add_info ("threads", info_threads_command,
            "IDs of currently known threads.");
index 189e3c395ef65fb15919724676078d2b3c8276eb..2cc4b5062e2421d6b8ed49d1e5aa8eb3f4a71815 100644 (file)
--- a/gdb/top.c
+++ b/gdb/top.c
@@ -32,7 +32,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "language.h"
 #include "terminal.h" /* For job_control.  */
 #include "annotate.h"
-#include <setjmp.h>
 #include "top.h"
 
 /* readline include files */
@@ -245,21 +244,15 @@ struct cmd_list_element *unsethistlist;
 
 /* Chain containing all defined maintenance subcommands. */
 
-#if MAINTENANCE_CMDS
 struct cmd_list_element *maintenancelist;
-#endif
 
 /* Chain containing all defined "maintenance info" subcommands. */
 
-#if MAINTENANCE_CMDS
 struct cmd_list_element *maintenanceinfolist;
-#endif
 
 /* Chain containing all defined "maintenance print" subcommands. */
 
-#if MAINTENANCE_CMDS
 struct cmd_list_element *maintenanceprintlist;
-#endif
 
 struct cmd_list_element *setprintlist;
 
@@ -367,9 +360,12 @@ static void stop_sig PARAMS ((int));
    command file.  */
 
 void (*init_ui_hook) PARAMS ((char *argv0));
-#ifdef __CYGWIN32__
-void (*ui_loop_hook) PARAMS ((int));
-#endif
+
+/* This hook is called from within gdb's many mini-event loops which could
+   steal control from a real user interface's event loop. It returns
+   non-zero if the user is requesting a detach, zero otherwise. */
+
+int (*ui_loop_hook) PARAMS ((int));
 
 /* Called instead of command_loop at top level.  Can be invoked via
    return_to_top_level.  */
@@ -2471,6 +2467,7 @@ int from_tty;
   enum command_control_type ret;
   enum misc_command_type val;
 
+  control_level = 0; 
   if (readline_begin_hook)
     {
       /* Note - intentional to merge messages with no newline */
@@ -2769,7 +2766,6 @@ define_command (comname, from_tty)
   for (tem = comname; *tem; tem++)
     if (isupper(*tem)) *tem = tolower(*tem);
 
-  control_level = 0;
   sprintf (tmpbuf, "Type commands for definition of \"%s\".", comname);
   cmds = read_command_lines (tmpbuf, from_tty);
 
@@ -3151,10 +3147,12 @@ source_command (args, from_tty)
 
   stream = fopen (file, FOPEN_RT);
   if (!stream)
-    if (from_tty)
-      perror_with_name (file);
-    else
-      return;
+    {
+      if (from_tty)
+       perror_with_name (file);
+      else
+       return;
+    }
 
   make_cleanup ((make_cleanup_func) fclose, stream);
 
@@ -3405,11 +3403,9 @@ init_cmd_lists ()
   sethistlist = NULL;
   showhistlist = NULL;
   unsethistlist = NULL;
-#if MAINTENANCE_CMDS
   maintenancelist = NULL;
   maintenanceinfolist = NULL;
   maintenanceprintlist = NULL;
-#endif
   setprintlist = NULL;
   showprintlist = NULL;
   setchecklist = NULL;
index fe7002b6091a569e7ffd88f6eb904ad5123c7da0..3564169b9af39f4e649bb4cb21740fa3d8d7145a 100644 (file)
--- a/gdb/top.h
+++ b/gdb/top.h
@@ -18,6 +18,8 @@ You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
+#include <setjmp.h>
+
 /* From top.c.  */
 extern char *line;
 extern int linesize;
index 9f036178bd1c9e18949ef25e215ddcd31a7abe5a..65ce851dcc2bc4773e5176034585c364c7554e03 100644 (file)
@@ -641,7 +641,8 @@ map_args_over_tracepoints (args, from_tty, opcode)
     while (*args)
       {
        QUIT;           /* give user option to bail out with ^C */
-       if (t = get_tracepoint_by_number (&args))
+       t = get_tracepoint_by_number (&args);
+       if (t)
          tracepoint_operation (t, from_tty, opcode);
        while (*args == ' ' || *args == '\t')
          args++;
@@ -783,7 +784,8 @@ trace_actions_command (args, from_tty)
   char tmpbuf[128];
   char *end_msg = "End with a line saying just \"end\".";
 
-  if (t = get_tracepoint_by_number (&args))
+  t = get_tracepoint_by_number (&args);
+  if (t)
     {
       sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
               t->number);
@@ -865,28 +867,32 @@ read_actions (t)
        }
 
       if (linetype == STEPPING)        /* begin "while-stepping" */
-       if (prompt == prompt2)
-         {
-           warning ("Already processing 'while-stepping'");
-           continue;
-         }
-       else
-         prompt = prompt2;     /* change prompt for stepping actions */
+       {
+         if (prompt == prompt2)
+           {
+             warning ("Already processing 'while-stepping'");
+             continue;
+           }
+         else
+           prompt = prompt2;   /* change prompt for stepping actions */
+       }
       else if (linetype == END)
-       if (prompt == prompt2)
-         {
-           prompt = prompt1;   /* end of single-stepping actions */
-         }
-       else
-         { /* end of actions */
-           if (t->actions->next == NULL)
-             {
-               /* an "end" all by itself with no other actions means
-                  this tracepoint has no actions.  Discard empty list. */
-               free_actions (t);
-             }
-           break;
-         }
+       {
+         if (prompt == prompt2)
+           {
+             prompt = prompt1; /* end of single-stepping actions */
+           }
+         else
+           { /* end of actions */
+             if (t->actions->next == NULL)
+               {
+                 /* an "end" all by itself with no other actions means
+                    this tracepoint has no actions.  Discard empty list. */
+                 free_actions (t);
+               }
+             break;
+           }
+       }
     }
 #ifdef STOP_SIGNAL
   if (job_control)
@@ -954,19 +960,21 @@ validate_actionline (line, t)
                                   &exp);
 
        if (exp->elts[0].opcode == OP_VAR_VALUE)
-         if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
-           {
-             warning ("%s is constant (value %d): will not be collected.",
-                      SYMBOL_NAME (exp->elts[2].symbol),
-                      SYMBOL_VALUE (exp->elts[2].symbol));
-             return BADLINE;
-           }
-         else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
-           {
-             warning ("%s is optimized away and cannot be collected.",
-                      SYMBOL_NAME (exp->elts[2].symbol));
-             return BADLINE;
-           }
+         {
+           if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
+             {
+               warning ("%s is constant (value %d): will not be collected.",
+                        SYMBOL_NAME (exp->elts[2].symbol),
+                        SYMBOL_VALUE (exp->elts[2].symbol));
+               return BADLINE;
+             }
+           else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
+             {
+               warning ("%s is optimized away and cannot be collected.",
+                        SYMBOL_NAME (exp->elts[2].symbol));
+               return BADLINE;
+             }
+         }
 
        /* we have something to collect, make sure that the expr to
           bytecode translator can handle it and that it's not too long */
index 1a4877befb3a191c6fb70e009c47527877248246..3ace7beeef3a5c6d40ec98ceeafe115d03ae6235 100644 (file)
@@ -262,8 +262,6 @@ print_type_scalar (type, val, stream)
   gdb_flush (stream);
 }
 
-#if MAINTENANCE_CMDS
-
 /* Dump details of a type specified either directly or indirectly.
    Uses the same sort of type lookup mechanism as ptype_command()
    and whatis_command(). */
@@ -302,8 +300,6 @@ maintenance_print_type (typename, from_tty)
   }
 }
 
-#endif /* MAINTENANCE_CMDS */
-
 \f
 void
 _initialize_typeprint ()
index d54519e63846ab75586cc358231d008772ba2b2c..ad2d3e49dba4ca55ad2e10954cbb1c68c2abfe4c 100644 (file)
@@ -44,7 +44,6 @@ core_file_command (filename, from_tty)
      int from_tty;
 {
   int val;
-  extern char registers[];
 
   /* Discard all vestiges of any previous core file
      and mark data and stack spaces as empty.  */
index 08b801b97598d2ec328832493030246a945d2d2e..400210bc5be454c5a30ec4859c7b5742699c30c4 100644 (file)
@@ -166,6 +166,7 @@ make_final_cleanup (function, arg)
 {
     return make_my_cleanup (&final_cleanup_chain, function, arg);
 }
+
 struct cleanup *
 make_run_cleanup (function, arg)
      void (*function) PARAMS ((PTR));
@@ -173,6 +174,21 @@ make_run_cleanup (function, arg)
 {
     return make_my_cleanup (&run_cleanup_chain, function, arg);
 }
+
+static void
+do_freeargv (arg)
+     void *arg;
+{
+  freeargv ((char**) arg);
+}
+
+struct cleanup *
+make_cleanup_freeargv (arg)
+     char **arg;
+{
+  return make_my_cleanup (&cleanup_chain, do_freeargv, arg);
+}
+
 struct cleanup *
 make_my_cleanup (pmy_chain, function, arg)
      struct cleanup **pmy_chain;
@@ -1714,7 +1730,7 @@ fputs_maybe_filtered (linebuffer, stream, filter)
     return;
 
   /* Don't do any filtering if it is disabled.  */
-  if (stream != gdb_stdout
+  if ((stream != gdb_stdout) || !pagination_enabled
    || (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX))
     {
       fputs_unfiltered (linebuffer, stream);
@@ -2300,42 +2316,40 @@ strcmp_iw (string1, string2)
 
 \f
 /*
-** subsetCompare()
-**    Answer whether stringToCompare is a full or partial match to
-**    templateString.  The partial match must be in sequence starting
+** subset_compare()
+**    Answer whether string_to_compare is a full or partial match to
+**    template_string.  The partial match must be in sequence starting
 **    at index 0.
 */
 int
-#ifdef _STDC__
-subsetCompare(
-    char *stringToCompare,
-    char *templateString)
-#else
-subsetCompare(stringToCompare, templateString)
-    char *stringToCompare;
-    char *templateString;
-#endif
-{
-    int    match = 0;
-
-    if (templateString != (char *)NULL && stringToCompare != (char *)NULL &&
-       strlen(stringToCompare) <= strlen(templateString))
-      match = (strncmp(templateString,
-                      stringToCompare,
-                      strlen(stringToCompare)) == 0);
-
-    return match;
-} /* subsetCompare */
+subset_compare (string_to_compare, template_string)
+    char *string_to_compare;
+    char *template_string;
+{
+  int match;
+  if (template_string != (char *)NULL && string_to_compare != (char *)NULL &&
+      strlen(string_to_compare) <= strlen(template_string))
+    match = (strncmp(template_string,
+                    string_to_compare,
+                    strlen(string_to_compare)) == 0);
+  else
+    match = 0;
+  return match;
+}
 
 
-void pagination_on_command(arg, from_tty)
+static void pagination_on_command PARAMS ((char *arg, int from_tty));
+static void
+pagination_on_command (arg, from_tty)
   char *arg;
   int from_tty;
 {
   pagination_enabled = 1;
 }
 
-void pagination_off_command(arg, from_tty)
+static void pagination_on_command PARAMS ((char *arg, int from_tty));
+static void
+pagination_off_command (arg, from_tty)
   char *arg;
   int from_tty;
 {
@@ -2560,10 +2574,12 @@ floatformat_to_doublest (fmt, from, to)
    increment the exponent by one to account for the integer bit.  */
 
   if (!special_exponent)
-    if (fmt->intbit == floatformat_intbit_no)
-      dto = ldexp (1.0, exponent);
-    else
-      exponent++;
+    {
+      if (fmt->intbit == floatformat_intbit_no)
+       dto = ldexp (1.0, exponent);
+      else
+       exponent++;
+    }
 
   while (mant_bits_left > 0)
     {
index b98a4bdb200a087f8265343190f46fdcd9655174..6bb8a70474e68fc2088c4d794176593b66622ed8 100644 (file)
@@ -811,19 +811,6 @@ v850_frame_saved_pc (fi)
     return v850_find_callers_reg (fi, RP_REGNUM);
 }
 
-void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
-     char *raw_buffer;
-     int *optimized;
-     CORE_ADDR *addrp;
-     struct frame_info *frame;
-     int regnum;
-     enum lval_type *lval;
-{
-  generic_get_saved_register (raw_buffer, optimized, addrp, 
-                             frame, regnum, lval);
-}
-
 
 /* Function: fix_call_dummy
    Pokes the callee function's address into the CALL_DUMMY assembly stub.
index 77d2396aa1a21a7fc6d60c1fc0b82fc5afb4162c..643db86abb7f42d12dd7bbc0473d0157df0cffc6 100644 (file)
@@ -51,10 +51,8 @@ extern int hp_som_som_object_present;
 
 static int typecmp PARAMS ((int staticp, struct type *t1[], value_ptr t2[]));
 
-#ifdef CALL_DUMMY
 static CORE_ADDR find_function_addr PARAMS ((value_ptr, struct type **));
 static value_ptr value_arg_coerce PARAMS ((value_ptr, struct type *, int));
-#endif
 
 
 #ifndef PUSH_ARGUMENTS
@@ -78,6 +76,8 @@ static CORE_ADDR allocate_space_in_inferior PARAMS ((int));
 
 static value_ptr cast_into_complex PARAMS ((struct type *, value_ptr));
 
+static struct fn_field *find_method_list PARAMS ((value_ptr *argp, char * method, int offset, int * static_memfuncp, struct type * type, int * num_fns, struct type ** basetype, int * boffset));
+
 void _initialize_valops PARAMS ((void));
 
 #define VALUE_SUBSTRING_START(VAL) VALUE_FRAME(VAL)
@@ -443,8 +443,8 @@ value_at (type, addr, sect)
 
   val = allocate_value (type);
 
-#ifdef GDB_TARGET_IS_D10V
-  if (TYPE_CODE (type) == TYPE_CODE_PTR
+  if (GDB_TARGET_IS_D10V
+      && TYPE_CODE (type) == TYPE_CODE_PTR
       && TYPE_TARGET_TYPE (type)
       && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
     {
@@ -452,20 +452,20 @@ value_at (type, addr, sect)
       unsigned long num;
       unsigned short snum;
       snum = read_memory_unsigned_integer (addr, 2);
-      num = D10V_MAKE_IADDR(snum);
-      store_address ( VALUE_CONTENTS_RAW (val), 4, num);
+      num = D10V_MAKE_IADDR (snum);
+      store_address (VALUE_CONTENTS_RAW (val), 4, num);
     }
-  else if (TYPE_CODE(type) == TYPE_CODE_PTR)
+  else if (GDB_TARGET_IS_D10V
+          && TYPE_CODE(type) == TYPE_CODE_PTR)
     {
       /* pointer to data */
       unsigned long num;
       unsigned short snum;
       snum = read_memory_unsigned_integer (addr, 2);
-      num = D10V_MAKE_DADDR(snum);
-      store_address ( VALUE_CONTENTS_RAW (val), 4, num); 
+      num = D10V_MAKE_DADDR (snum);
+      store_address (VALUE_CONTENTS_RAW (val), 4, num); 
     }
   else
-#endif
     read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type), sect);
 
   VALUE_LVAL (val) = lval_memory;
@@ -517,9 +517,9 @@ value_fetch_lazy (val)
   CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
   int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
 
-#ifdef GDB_TARGET_IS_D10V
   struct type *type = VALUE_TYPE(val);
-  if (TYPE_CODE (type) == TYPE_CODE_PTR
+  if (GDB_TARGET_IS_D10V
+      && TYPE_CODE (type) == TYPE_CODE_PTR
       && TYPE_TARGET_TYPE (type)
       && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
     {
@@ -530,7 +530,8 @@ value_fetch_lazy (val)
       num = D10V_MAKE_IADDR(snum);
       store_address ( VALUE_CONTENTS_RAW (val), 4, num);
     }
-  else if (TYPE_CODE(type) == TYPE_CODE_PTR)
+  else if (GDB_TARGET_IS_D10V
+          && TYPE_CODE(type) == TYPE_CODE_PTR)
     {
       /* pointer to data */
       unsigned long num;
@@ -539,10 +540,7 @@ value_fetch_lazy (val)
       num = D10V_MAKE_DADDR(snum);
       store_address ( VALUE_CONTENTS_RAW (val), 4, num); 
     }
-  else
-#endif
-
-  if (length)
+  else if (length)
     read_memory_section (addr, VALUE_CONTENTS_ALL_RAW (val), length,
                         VALUE_BFD_SECTION (val));
   VALUE_LAZY (val) = 0;
@@ -1101,7 +1099,6 @@ value_push (sp, arg)
 
 #endif /* !PUSH_ARGUMENTS */
 
-#ifdef CALL_DUMMY
 /* Perform the standard coercions that are specified
    for arguments to be passed to C functions.
 
@@ -1261,8 +1258,9 @@ find_function_addr (function, retval_type)
 
    ARGS is modified to contain coerced values. */
 
-value_ptr
-call_function_by_hand (function, nargs, args)
+static value_ptr hand_function_call PARAMS ((value_ptr function, int nargs, value_ptr *args));
+static value_ptr
+hand_function_call (function, nargs, args)
      value_ptr function;
      int nargs;
      value_ptr *args;
@@ -1279,15 +1277,19 @@ call_function_by_hand (function, nargs, args)
            sequence of instructions.  But CISC machines will have
            to pack the instructions into REGISTER_SIZE units (and
            so will RISC machines for which INSTRUCTION_SIZE is not
-           REGISTER_SIZE). */
+           REGISTER_SIZE).
+
+     NOTE: This is pretty stupid.  CALL_DUMMY should be in strict
+           target byte order. */
 
-  static ULONGEST dummy[] = CALL_DUMMY;
-  char dummy1[REGISTER_SIZE * sizeof dummy / sizeof (ULONGEST)];
+  static ULONGEST *dummy;
+  int sizeof_dummy1;
+  char *dummy1;
   CORE_ADDR old_sp;
   struct type *value_type;
   unsigned char struct_return;
   CORE_ADDR struct_addr = 0;
-  struct inferior_status inf_status;
+  struct inferior_status *inf_status;
   struct cleanup *old_chain;
   CORE_ADDR funaddr;
   int using_gcc;       /* Set to version of gcc in use, or zero if not gcc */
@@ -1295,12 +1297,17 @@ call_function_by_hand (function, nargs, args)
   struct type *param_type = NULL;
   struct type *ftype = check_typedef (SYMBOL_TYPE (function));
 
+  dummy = alloca (SIZEOF_CALL_DUMMY_WORDS);
+  sizeof_dummy1 = REGISTER_SIZE * SIZEOF_CALL_DUMMY_WORDS / sizeof (ULONGEST);
+  dummy1 = alloca (sizeof_dummy1);
+  memcpy (dummy, CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS);
+
   if (!target_has_execution)
     noprocess();
 
-  save_inferior_status (&inf_status, 1);
+  inf_status = save_inferior_status (1);
   old_chain = make_cleanup ((make_cleanup_func) restore_inferior_status, 
-                            &inf_status);
+                            inf_status);
 
   /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
      (and POP_FRAME for restoring them).  (At least on most machines)
@@ -1312,14 +1319,14 @@ call_function_by_hand (function, nargs, args)
   if (INNER_THAN (1, 2))
     {
       /* Stack grows down */
-      sp -= sizeof dummy1;
+      sp -= sizeof_dummy1;
       start_sp = sp;
     }
   else
     {
       /* Stack grows up */
       start_sp = sp;
-      sp += sizeof dummy1;
+      sp += sizeof_dummy1;
     }
 
   funaddr = find_function_addr (function, &value_type);
@@ -1339,7 +1346,7 @@ call_function_by_hand (function, nargs, args)
 
   /* Create a call sequence customized for this function
      and the number of arguments for it.  */
-  for (i = 0; i < (int) (sizeof (dummy) / sizeof (dummy[0])); i++)
+  for (i = 0; i < (int) (SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0])); i++)
     store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
                            REGISTER_SIZE,
                            (ULONGEST)dummy[i]);
@@ -1353,42 +1360,42 @@ call_function_by_hand (function, nargs, args)
   real_pc = start_sp;
 #endif
 
-#if CALL_DUMMY_LOCATION == ON_STACK
-  write_memory (start_sp, (char *)dummy1, sizeof dummy1);
-#endif /* On stack.  */
-
-#if CALL_DUMMY_LOCATION == BEFORE_TEXT_END
-  /* Convex Unix prohibits executing in the stack segment. */
-  /* Hope there is empty room at the top of the text segment. */
-  {
-    extern CORE_ADDR text_end;
-    static checked = 0;
-    if (!checked)
-      for (start_sp = text_end - sizeof dummy1; start_sp < text_end; ++start_sp)
-       if (read_memory_integer (start_sp, 1) != 0)
-         error ("text segment full -- no place to put call");
-    checked = 1;
-    sp = old_sp;
-    real_pc = text_end - sizeof dummy1;
-    write_memory (real_pc, (char *)dummy1, sizeof dummy1);
-  }
-#endif /* Before text_end.  */
+  if (CALL_DUMMY_LOCATION == ON_STACK)
+    {
+      write_memory (start_sp, (char *)dummy1, sizeof_dummy1);
+    }
 
-#if CALL_DUMMY_LOCATION == AFTER_TEXT_END
-  {
-    extern CORE_ADDR text_end;
-    int errcode;
-    sp = old_sp;
-    real_pc = text_end;
-    errcode = target_write_memory (real_pc, (char *)dummy1, sizeof dummy1);
-    if (errcode != 0)
-      error ("Cannot write text segment -- call_function failed");
-  }
-#endif /* After text_end.  */
+  if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END)
+    {
+      /* Convex Unix prohibits executing in the stack segment. */
+      /* Hope there is empty room at the top of the text segment. */
+      extern CORE_ADDR text_end;
+      static checked = 0;
+      if (!checked)
+       for (start_sp = text_end - sizeof_dummy1; start_sp < text_end; ++start_sp)
+         if (read_memory_integer (start_sp, 1) != 0)
+           error ("text segment full -- no place to put call");
+      checked = 1;
+      sp = old_sp;
+      real_pc = text_end - sizeof_dummy1;
+      write_memory (real_pc, (char *)dummy1, sizeof_dummy1);
+    }
+  
+  if (CALL_DUMMY_LOCATION == AFTER_TEXT_END)
+    {
+      extern CORE_ADDR text_end;
+      int errcode;
+      sp = old_sp;
+      real_pc = text_end;
+      errcode = target_write_memory (real_pc, (char *)dummy1, sizeof_dummy1);
+      if (errcode != 0)
+       error ("Cannot write text segment -- call_function failed");
+    }
 
-#if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
-  real_pc = funaddr;
-#endif /* At entry point.  */
+  if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
+    {
+      real_pc = funaddr;
+    }
 
 #ifdef lint
   sp = old_sp;         /* It really is used, for some ifdef's... */
@@ -1555,9 +1562,8 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
 
       for (i = nargs - 1; i >= 0; i--)
        len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
-#ifdef CALL_DUMMY_STACK_ADJUST
-      len += CALL_DUMMY_STACK_ADJUST;
-#endif
+      if (CALL_DUMMY_STACK_ADJUST_P)
+       len += CALL_DUMMY_STACK_ADJUST;
       sp -= STACK_ALIGN (len) - len;
     }
 #endif /* STACK_ALIGN */
@@ -1588,9 +1594,8 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
     {
       /* If stack grows up, we must leave a hole at the bottom, note
         that sp already has been advanced for the arguments!  */
-#ifdef CALL_DUMMY_STACK_ADJUST
-      sp += CALL_DUMMY_STACK_ADJUST;
-#endif
+      if (CALL_DUMMY_STACK_ADJUST_P)
+       sp += CALL_DUMMY_STACK_ADJUST;
       sp = STACK_ALIGN (sp);
     }
 #endif /* STACK_ALIGN */
@@ -1600,13 +1605,12 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
   /* MVS 11/22/96: I think at least some of this stack_align code is
      really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
      a target-defined manner.  */
-#ifdef CALL_DUMMY_STACK_ADJUST
-  if (INNER_THAN (1, 2))
-    {
-      /* stack grows downward */
-      sp -= CALL_DUMMY_STACK_ADJUST;
-    }
-#endif /* CALL_DUMMY_STACK_ADJUST */
+  if (CALL_DUMMY_STACK_ADJUST_P)
+    if (INNER_THAN (1, 2))
+      {
+       /* stack grows downward */
+       sp -= CALL_DUMMY_STACK_ADJUST;
+      }
 
   /* Store the address at which the structure is supposed to be
      written.  Note that this (and the code which reserved the space
@@ -1663,13 +1667,12 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
       {
        /* We stopped somewhere besides the call dummy.  */
 
-       /* If we did the cleanups, we would print a spurious error message
-          (Unable to restore previously selected frame), would write the
-          registers from the inf_status (which is wrong), and would do other
-          wrong things (like set stop_bpstat to the wrong thing).  */
+       /* If we did the cleanups, we would print a spurious error
+          message (Unable to restore previously selected frame),
+          would write the registers from the inf_status (which is
+          wrong), and would do other wrong things.  */
        discard_cleanups (old_chain);
-       /* Prevent memory leak.  */
-       bpstat_clear (&inf_status.stop_bpstat);
+       discard_inferior_status (inf_status);
 
        /* The following error message used to say "The expression
           which contained the function call has been discarded."  It
@@ -1706,16 +1709,23 @@ the function call).", name);
     return value_being_returned (value_type, retbuf, struct_return);
   }
 }
-#else /* no CALL_DUMMY.  */
+
 value_ptr
 call_function_by_hand (function, nargs, args)
      value_ptr function;
      int nargs;
      value_ptr *args;
 {
-  error ("Cannot invoke functions on this machine.");
+  if (CALL_DUMMY_P)
+    {
+      return hand_function_call (function, nargs, args);
+    }
+  else
+    {
+      error ("Cannot invoke functions on this machine.");
+    }
 }
-#endif /* no CALL_DUMMY.  */
+
 
 \f
 /* Create a value for an array by allocating space in the inferior, copying
@@ -2420,16 +2430,16 @@ value_struct_elt (argp, args, name, static_memfuncp, err)
  * BASETYPE is set to the actual type of the subobject where the method is found
  * BOFFSET is the offset of the base subobject where the method is found */
 
-struct fn_field *
+static struct fn_field *
 find_method_list (argp, method, offset, static_memfuncp, type, num_fns, basetype, boffset)
-  value_ptr *argp;
-  char * method;
-  int offset;
-  int * static_memfuncp;
-  struct type * type;
-  int * num_fns;
-  struct type ** basetype;
-  int * boffset;
+     value_ptr *argp;
+     char * method;
+     int offset;
+     int * static_memfuncp;
+     struct type * type;
+     int * num_fns;
+     struct type ** basetype;
+     int * boffset;
 {
   int i;
   struct fn_field * f;
index b09da9b3145d81929a82097eea0fa92017cf0173..ddbbebbc21b53e9fef601dc087100b75fe9bb213 100644 (file)
@@ -236,6 +236,7 @@ val_print_type_code_int (type, valaddr, stream)
    */
 
 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
+static void print_decimal PARAMS ((GDB_FILE *stream, char *sign, int use_local, ULONGEST val_ulong));
 static void
 print_decimal (stream, sign, use_local, val_ulong)
      GDB_FILE *stream;
@@ -425,6 +426,7 @@ print_longest (stream, format, use_local, val_long)
 #endif /* CC_HAS_LONG_LONG || PRINTF_HAS_LONG_LONG */
 }
 
+#if 0
 void
 strcat_longest (format, use_local, val_long, buf, buflen)
      int format;
@@ -528,6 +530,7 @@ strcat_longest (format, use_local, val_long, buf, buflen)
     
 #endif /* !PRINTF_HAS_LONG_LONG */
 }
+#endif
 
 /* This used to be a macro, but I don't think it is called often enough
    to merit such treatment.  */
index 44c70dec22bc2252ca47315879658c7f0f0a02f5..d3d262a20a87cb31b2c7855ca81dc6eba56bea26 100644 (file)
@@ -345,8 +345,9 @@ extern value_ptr value_struct_elt_for_reference PARAMS ((struct type *domain,
 
 extern value_ptr value_static_field PARAMS ((struct type *type, int fieldno));
 
-extern struct fn_field *
-value_find_oload_method_list PARAMS ((value_ptr *, char *, int, int *, int *, struct type **, int *));
+extern struct fn_field *value_find_oload_method_list PARAMS ((value_ptr *, char *, int, int *, int *, struct type **, int *));
+
+extern int find_overload_match PARAMS ((struct type ** arg_types, int nargs, char * name, int method, int lax, value_ptr obj, struct symbol *fsym, value_ptr *valp, struct symbol **symp, int *staticp));
 
 extern value_ptr value_field PARAMS ((value_ptr arg1, int fieldno));
 
@@ -375,7 +376,7 @@ extern value_ptr value_from_vtable_info PARAMS ((value_ptr arg,
                                                 struct type *type));
 
 extern value_ptr value_being_returned PARAMS ((struct type *valtype, 
-                                              char retbuf[REGISTER_BYTES],
+                                              char *retbuf,
                                               int struct_return));
 
 extern value_ptr value_in PARAMS ((value_ptr element, value_ptr set));
@@ -484,10 +485,10 @@ write_register_pid PARAMS ((int regno, CORE_ADDR val, int pid));
 extern void
 supply_register PARAMS ((int regno, char *val));
 
-extern void
-get_saved_register PARAMS ((char *raw_buffer, int *optimized,
-                           CORE_ADDR *addrp, struct frame_info *frame,
-                           int regnum, enum lval_type *lval));
+extern void get_saved_register PARAMS ((char *raw_buffer, int *optimized,
+                                       CORE_ADDR *addrp,
+                                       struct frame_info *frame,
+                                       int regnum, enum lval_type *lval));
 
 extern void
 modify_field PARAMS ((char *addr, LONGEST fieldval, int bitpos, int bitsize));
index c7053b8df789a72bb8fb8d3114d50cd4252fbc30..c7c4d80463c6be25d2aa3e793608937f94b6b6fc 100644 (file)
@@ -645,10 +645,9 @@ unpack_long (type, valaddr)
     case TYPE_CODE_REF:
       /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
         whether we want this to be true eventually.  */
-#ifdef GDB_TARGET_IS_D10V
-      if (len == 2)
-         return D10V_MAKE_DADDR(extract_address (valaddr, len));
-#endif
+      if (GDB_TARGET_IS_D10V
+         && len == 2)
+         return D10V_MAKE_DADDR (extract_address (valaddr, len));
       return extract_address (valaddr, len);
 
     case TYPE_CODE_MEMBER:
@@ -1492,7 +1491,7 @@ value_from_double (type, num)
 value_ptr
 value_being_returned (valtype, retbuf, struct_return)
      register struct type *valtype;
-     char retbuf[REGISTER_BYTES];
+     char *retbuf;
      int struct_return;
      /*ARGSUSED*/
 {
index 87e96bd23ac96bf45c1d644985ed58720beca268..fa19797a6b001e4ff66921be3e0aaa0929ba51e3 100644 (file)
 #include <sys/param.h>
 #include <unistd.h>
 
+/* The ui's event loop. */
+extern int (*ui_loop_hook) PARAMS ((int signo));
+
+/* If we're not using the old Cygwin header file set, define the
+   following which never should have been in the generic Win32 API
+   headers in the first place since they were our own invention... */
+#ifndef _GNU_H_WINDOWS_H
+#define FLAG_TRACE_BIT 0x100
+#define CONTEXT_DEBUGGER (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
+#endif
+
 /* The string sent by cygwin when it processes a signal.
    FIXME: This should be in a cygwin include file. */
 #define CYGWIN_SIGNAL_STRING "cygwin: signal"
@@ -65,6 +76,7 @@ extern struct target_ops child_ops;
 
 static void child_stop PARAMS ((void));
 static int win32_child_thread_alive PARAMS ((int));
+void child_kill_inferior PARAMS ((void));
 
 static int last_sig = 0;       /* Set if a signal was received from the
                                   debugged process */
@@ -453,7 +465,9 @@ handle_output_debug_string (struct target_waitstatus *ourstatus)
     {
       char *p;
       /*last_sig = */strtol(s + sizeof(CYGWIN_SIGNAL_STRING) - 1, &p, 0);
-      if (gotasig = (ourstatus->value.sig = target_signal_from_host (last_sig)))
+      gotasig = target_signal_from_host (last_sig);
+      ourstatus->value.sig = gotasig;
+      if (gotasig)
        ourstatus->kind = TARGET_WAITKIND_STOPPED;
     }
 
@@ -530,9 +544,10 @@ child_continue (DWORD continue_status, int id)
 
   DEBUG_EVENTS (("ContinueDebugEvent (cpid=%d, ctid=%d, DBG_CONTINUE);\n",
                 current_event.dwProcessId, current_event.dwThreadId));
-  if (res = ContinueDebugEvent (current_event.dwProcessId,
-                               current_event.dwThreadId,
-                               continue_status))
+  res = ContinueDebugEvent (current_event.dwProcessId,
+                           current_event.dwThreadId,
+                           continue_status);
+  if (res)
     for (th = &thread_head; (th = th->next) != NULL; )
       if (((id == -1) || (id == th->id)) && th->suspend_count)
        {
@@ -556,98 +571,111 @@ child_wait (int pid, struct target_waitstatus *ourstatus)
   while (1)
     {
       DWORD continue_status;
-      BOOL t = WaitForDebugEvent (&current_event, INFINITE);
+      BOOL debug_event = WaitForDebugEvent (&current_event, 20);
       char *p;
       thread_info *th;
       int sig;
 
-      event_count++;
-
-      continue_status = DBG_CONTINUE;
-
-      switch (current_event.dwDebugEventCode)
+      if (debug_event)
        {
-       case CREATE_THREAD_DEBUG_EVENT:
-         DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
-                       current_event.dwProcessId, current_event.dwThreadId,
-                       "CREATE_THREAD_DEBUG_EVENT"));
-         /* Record the existence of this thread */
-         child_add_thread (current_event.dwThreadId,
-                           current_event.u.CreateThread.hThread);
-         if (info_verbose)
-             printf_unfiltered ("[New %s]\n",
-                              target_pid_to_str (current_event.dwThreadId));
-         break;
-
-       case EXIT_THREAD_DEBUG_EVENT:
-         DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-                       current_event.dwProcessId, current_event.dwThreadId,
-                       "EXIT_THREAD_DEBUG_EVENT"));
-         child_delete_thread (current_event.dwThreadId);
-         break;
-
-       case CREATE_PROCESS_DEBUG_EVENT:
-         DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-                       current_event.dwProcessId, current_event.dwThreadId,
-                       "CREATE_PROCESS_DEBUG_EVENT"));
-         current_process_handle = current_event.u.CreateProcessInfo.hProcess;
-
-         main_thread_id = inferior_pid = current_event.dwThreadId;
-         /* Add the main thread */
-         current_thread = child_add_thread (inferior_pid,
-                               current_event.u.CreateProcessInfo.hThread);
-         break;
-
-       case EXIT_PROCESS_DEBUG_EVENT:
-         DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-                       current_event.dwProcessId, current_event.dwThreadId,
-                       "EXIT_PROCESS_DEBUG_EVENT"));
-         ourstatus->kind = TARGET_WAITKIND_EXITED;
-         ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
-         CloseHandle (current_process_handle);
-         return current_event.dwProcessId;
-         break;
-
-       case LOAD_DLL_DEBUG_EVENT:
-         DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-                       current_event.dwProcessId, current_event.dwThreadId,
-                       "LOAD_DLL_DEBUG_EVENT"));
-          catch_errors (handle_load_dll, NULL, "", RETURN_MASK_ALL);
-         registers_changed();          /* mark all regs invalid */
-         break;
-
-       case UNLOAD_DLL_DEBUG_EVENT:
-         DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-                       current_event.dwProcessId, current_event.dwThreadId,
-                       "UNLOAD_DLL_DEBUG_EVENT"));
-         break;        /* FIXME: don't know what to do here */
-
-       case EXCEPTION_DEBUG_EVENT:
-         DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-                       current_event.dwProcessId, current_event.dwThreadId,
-                       "EXCEPTION_DEBUG_EVENT"));
-         if (handle_exception (ourstatus))
-           return current_event.dwThreadId;
-         continue_status = DBG_EXCEPTION_NOT_HANDLED;
-         break;
-
-       case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
-         DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
-                       current_event.dwProcessId, current_event.dwThreadId,
-                       "OUTPUT_DEBUG_STRING_EVENT"));
-         if (handle_output_debug_string (ourstatus))
-           return main_thread_id;
-         break;
-       default:
-         printf_unfiltered ("gdb: kernel event for pid=%d tid=%d\n",
-                            current_event.dwProcessId,
-                            current_event.dwThreadId);
-         printf_unfiltered ("                 unknown event code %d\n",
-                            current_event.dwDebugEventCode);
-         break;
+         event_count++;
+
+         continue_status = DBG_CONTINUE;
+
+         switch (current_event.dwDebugEventCode)
+           {
+           case CREATE_THREAD_DEBUG_EVENT:
+             DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%x code=%s)\n",
+                            current_event.dwProcessId, current_event.dwThreadId,
+                            "CREATE_THREAD_DEBUG_EVENT"));
+             /* Record the existence of this thread */
+             child_add_thread (current_event.dwThreadId,
+                               current_event.u.CreateThread.hThread);
+             if (info_verbose)
+               printf_unfiltered ("[New %s]\n",
+                                  target_pid_to_str (current_event.dwThreadId));
+             break;
+
+           case EXIT_THREAD_DEBUG_EVENT:
+             DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+                            current_event.dwProcessId, current_event.dwThreadId,
+                            "EXIT_THREAD_DEBUG_EVENT"));
+             child_delete_thread (current_event.dwThreadId);
+             break;
+
+           case CREATE_PROCESS_DEBUG_EVENT:
+             DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+                            current_event.dwProcessId, current_event.dwThreadId,
+                            "CREATE_PROCESS_DEBUG_EVENT"));
+             current_process_handle = current_event.u.CreateProcessInfo.hProcess;
+
+             main_thread_id = inferior_pid = current_event.dwThreadId;
+             /* Add the main thread */
+             current_thread = child_add_thread (inferior_pid,
+                                                current_event.u.CreateProcessInfo.hThread);
+             break;
+
+           case EXIT_PROCESS_DEBUG_EVENT:
+             DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+                            current_event.dwProcessId, current_event.dwThreadId,
+                            "EXIT_PROCESS_DEBUG_EVENT"));
+             ourstatus->kind = TARGET_WAITKIND_EXITED;
+             ourstatus->value.integer = current_event.u.ExitProcess.dwExitCode;
+             CloseHandle (current_process_handle);
+             return current_event.dwProcessId;
+             break;
+
+           case LOAD_DLL_DEBUG_EVENT:
+             DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+                            current_event.dwProcessId, current_event.dwThreadId,
+                            "LOAD_DLL_DEBUG_EVENT"));
+             catch_errors (handle_load_dll, NULL, "", RETURN_MASK_ALL);
+             registers_changed();          /* mark all regs invalid */
+             break;
+
+           case UNLOAD_DLL_DEBUG_EVENT:
+             DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+                            current_event.dwProcessId, current_event.dwThreadId,
+                            "UNLOAD_DLL_DEBUG_EVENT"));
+             break;    /* FIXME: don't know what to do here */
+
+           case EXCEPTION_DEBUG_EVENT:
+             DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+                            current_event.dwProcessId, current_event.dwThreadId,
+                            "EXCEPTION_DEBUG_EVENT"));
+             if (handle_exception (ourstatus))
+               return current_event.dwThreadId;
+             continue_status = DBG_EXCEPTION_NOT_HANDLED;
+             break;
+
+           case OUTPUT_DEBUG_STRING_EVENT: /* message from the kernel */
+             DEBUG_EVENTS (("gdb: kernel event for pid=%d tid=%d code=%s)\n",
+                            current_event.dwProcessId, current_event.dwThreadId,
+                            "OUTPUT_DEBUG_STRING_EVENT"));
+             if (handle_output_debug_string (ourstatus))
+               return main_thread_id;
+             break;
+           default:
+             printf_unfiltered ("gdb: kernel event for pid=%d tid=%d\n",
+                                current_event.dwProcessId,
+                                current_event.dwThreadId);
+             printf_unfiltered ("                 unknown event code %d\n",
+                                current_event.dwDebugEventCode);
+             break;
+           }
+
+         CHECK (child_continue (continue_status, -1));
        }
+      else
+       {
+         int detach = 0;
 
-      CHECK (child_continue (continue_status, -1));
+         if (ui_loop_hook != NULL)
+           detach = ui_loop_hook (0);
+
+         if (detach)
+           child_kill_inferior ();
+       }
     }
 }
 
index 75ea09dc1df299177d5ee2a0bec71b9f27e5bc05..b38fcf354b55952b93a9666d022f9ee0ec8da791 100644 (file)
@@ -1,3 +1,24 @@
+1999-04-22  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+       * Makefile.in (install): Make comment about this change more explicit.
+
+1999-04-22  Jason Molenda  (jsm@bugshack.cygnus.com)
+
+        * Makefile.in (install): Don't install the final libreadline.a
+        or .h files.
+
+Tue Mar 23 10:56:08 1999  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
+
+       Patches from Robert Hoehne <robert.hoehne@gmx.net>:
+       
+       * display.c: Change some terminal calls to work on DJGPP.
+       * terminal.c: Likewise.
+       * Makefile.in: Remove . from the VPATH directive.
+       
+Tue Mar  9 14:58:13 1999  Geoffrey Noer  <noer@cygnus.com>
+
+       * support/config.sub: Recognize cygwin*, not just cygwin32.
+
 Tue Feb  9 10:38:57 1999  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
 
        * configure.in: Do not use the ./support directory.
index c73709fbca728349a847317c2963c9e3d95e33a2..7c44a9b6c3665ce6bc7529cea503eea67fd388f0 100644 (file)
@@ -1,24 +1,18 @@
+1999-04-08  Nick Clifton  <nickc@cygnus.com>
+
+       * configure.in: Add support for MCore target.
+       * configure: Regenerate.
+
 1999-03-14  Stan Shebs  <shebs@andros.cygnus.com>
 
        * Makefile.in (FLAGS_TO_PASS, TARGET_FLAGS_TO_PASS): Remove
        RUNTEST instead of commenting out, fixes portability problem.
 
-1999-02-10  Doug Evans  <devans@casey.cygnus.com>
-
-       * configure.in (sparc*): Configure sparc subdir if --with-cgen or
-       --with-cgen-sim.
-       * configure: Rebuild.
-
 1999-02-08  Nick Clifton  <nickc@cygnus.com>
 
        * configure.in: Add support for StrongARM target.
        * configure: Regenerate.
 
-1999-02-02  Doug Evans  <devans@casey.cygnus.com>
-
-       * configure.in (sparc*): Configure sparc subdir if --with-cgen.
-       * configure: Rebuild.
-
 1999-01-04  Jason Molenda  (jsm@bugshack.cygnus.com)
 
        * configure.in: Require autoconf 2.12.1 or higher.
@@ -40,8 +34,8 @@ Fri Sep 25 10:12:19 1998  Christopher Faylor <cgf@cygnus.com>
 
 Thu May 28 14:59:46 1998 Jillian Ye <jillian@cygnus.com>
 
-        * Makefile.in: Take RUNTEST out of FLAG_TO_PASS
-                       so that make check can be invoked recursively.
+        * Makefile.in: Take RUNTEST out of FLAGS_TO_PASS so that make
+       check can be invoked recursively.
 
 Wed Apr 29 12:38:53 1998  Mark Alexander  <marka@cygnus.com>
 
index 4149366ee41f7cc9bc83d86eeed9dbe0d5abbdb1..9f6adf4424e077592fb8677dc018ff68bc2f2ec1 100644 (file)
@@ -1,3 +1,25 @@
+1999-04-06  Keith Seitz  <keiths@cygnus.com>
+
+       * wrapper.c (stop_simulator): New global.
+       (sim_stop): Set sim state to STOP and set
+       stop_simulator.
+       (sim_resume): Reset stop_simulator.
+       (sim_stop_reason): If stop_simulator is set, tell gdb
+       that the we took SIGINT.
+       * armemu.c (ARMul_Emulate26): Don't loop forever. Stop if
+       stop_simulator is set.
+
+1999-04-02  Keith Seitz  <keiths@cygnus.com>
+
+       * armemu.c (ARMul_Emulate26): If NEED_UI_LOOP_HOOK, call ui_loop_hook
+       whenever the counter expires.
+       * Makefile.in (SIM_EXTRA_CFLAGS): Include define NEED_UI_LOOP_HOOK.
+
+1999-03-24  Nick Clifton  <nickc@cygnus.com>
+
+       * armemu.c (ARMul_Emulate26): Handle new breakpoint value.
+       * thumbemu.c (ARMul_ThumbDecode): Handle new breakpoint value.
+
 Mon Sep 14 09:00:05 1998  Nick Clifton  <nickc@cygnus.com>
 
        * wrapper.c (sim_open): Set endianness according to BFD or command
index b6ae2af0e7125b22e928a6e752d2eafee7dcbd68..e2f2b3c5f0a2869f0fe6a502f83942fdfde305b7 100644 (file)
@@ -18,7 +18,7 @@
 
 ## COMMON_PRE_CONFIG_FRAG
 
-SIM_EXTRA_CFLAGS = -DMODET
+SIM_EXTRA_CFLAGS = -DMODET -DNEED_UI_LOOP_HOOK
 
 SIM_OBJS = armcopro.o armemu26.o armemu32.o arminit.o armos.o armsupp.o \
        armvirt.o bag.o thumbemu.o wrapper.o sim-load.o
index 171f1c8c0c8438a59f0731b3828e8c617145d3a0..36b7bba4d106aca41cf76a719149fba939a7c4ab 100644 (file)
@@ -18,6 +18,7 @@
 
 #include "armdefs.h"
 #include "armemu.h"
+#include "armos.h"
 
 static ARMword GetDPRegRHS(ARMul_State *state, ARMword instr) ;
 static ARMword GetDPSRegRHS(ARMul_State *state, ARMword instr) ;
@@ -43,6 +44,19 @@ static unsigned MultiplyAdd64(ARMul_State *state, ARMword instr,int signextend,i
 #define LDEFAULT  (0)   /* default : do nothing */
 #define LSCC      (1)   /* set condition codes on result */
 
+#ifdef NEED_UI_LOOP_HOOK
+/* How often to run the ui_loop update, when in use */
+#define UI_LOOP_POLL_INTERVAL 0x32000
+
+/* Counter for the ui_loop_hook update */
+static long ui_loop_hook_counter = UI_LOOP_POLL_INTERVAL;
+
+/* Actual hook to call to run through gdb's gui event loop */
+extern int (*ui_loop_hook) (int);
+#endif /* NEED_UI_LOOP_HOOK */
+
+extern int stop_simulator;
+
 /***************************************************************************\
 *               short-hand macros for LDR/STR                               *
 \***************************************************************************/
@@ -2166,10 +2180,20 @@ mainswitch:
              break ;
 
           case 0x7f : /* Load Byte, WriteBack, Pre Inc, Reg */
-             if (BIT(4)) {
-                ARMul_UndefInstr(state,instr) ;
-                break ;
-                }
+             if (BIT(4))
+              {
+                /* Check for the special breakpoint opcode.
+                   This value should correspond to the value defined
+                   as ARM_BE_BREAKPOINT in gdb/arm-tdep.c.  */
+                if (BITS (0,19) == 0xfdefe)
+                  {
+                    if (! ARMul_OSHandleSWI (state, SWI_Breakpoint))
+                      ARMul_Abort (state, ARMul_SWIV);
+                  }
+                else
+                  ARMul_UndefInstr(state,instr) ;
+                break ;
+              }
              UNDEF_LSRBaseEQOffWb ;
              UNDEF_LSRBaseEQDestWb ;
              UNDEF_LSRPCBaseWb ;
@@ -2549,11 +2573,19 @@ mainswitch:
 donext:
 #endif
 
+#ifdef NEED_UI_LOOP_HOOK
+    if (ui_loop_hook != NULL && ui_loop_hook_counter-- < 0)
+      {
+       ui_loop_hook_counter = UI_LOOP_POLL_INTERVAL;
+       ui_loop_hook (0);
+      }
+#endif /* NEED_UI_LOOP_HOOK */
+
     if (state->Emulate == ONCE)
         state->Emulate = STOP;
     else if (state->Emulate != RUN)
         break;
-    } while (1) ; /* do loop */
+    } while (!stop_simulator) ; /* do loop */
 
  state->decoded = decoded ;
  state->loaded = loaded ;
index eaf6e0cca651ad2339d3aad81728539056519fb2..c610b97c55b1117e75f0c3dc6a1ace3ff4ca8651 100644 (file)
@@ -29,6 +29,7 @@ existing ARM simulator.  */
 
 #include "armdefs.h"
 #include "armemu.h"
+#include "armos.h"
 
 /* Decode a 16bit Thumb instruction.  The instruction is in the low
    16-bits of the tinstr field, with the following Thumb instruction
@@ -356,6 +357,9 @@ ARMul_ThumbDecode (state,pc,tinstr,ainstr)
          /* Breakpoint must be handled specially.  */
          if ((tinstr & 0x00FF) == 0x18)
            *ainstr |= ((tinstr & 0x00FF) << 16);
+         /* New breakpoint value.  See gdb/arm-tdep.c  */
+         else if ((tinstr & 0x00FF) == 0xFE)
+           * ainstr |= SWI_Breakpoint;
          else
            *ainstr |= (tinstr & 0x00FF);
         }
index 40380040a01d1ea47783688e5a12327e24f5a25f..7d725b823e7e16a4002f8f759b1cd35d25cdb2dd 100644 (file)
@@ -50,6 +50,8 @@ static int verbosity;
 /* Non-zero to set big endian mode.  */
 static int big_endian;
 
+int stop_simulator;
+
 static void 
 init ()
 {
@@ -154,7 +156,9 @@ int
 sim_stop (sd)
      SIM_DESC sd;
 {
-  return 0;
+  state->Emulate = STOP;
+  stop_simulator = 1;
+  return 1;
 }
 
 void
@@ -163,6 +167,7 @@ sim_resume (sd, step, siggnal)
      int step, siggnal;
 {
   state->EndCondition = 0;
+  stop_simulator = 0;
 
   if (step)
     {
@@ -435,7 +440,12 @@ sim_stop_reason (sd, reason, sigrc)
      enum sim_stop *reason;
      int *sigrc;
 {
-  if (state->EndCondition == 0)
+  if (stop_simulator)
+    {
+      *reason = sim_stopped;
+      *sigrc = SIGINT;
+    }
+  else if (state->EndCondition == 0)
     {
       *reason = sim_exited;
       *sigrc = state->Reg[0] & 255;
index bde07108db9cbf82bddc3b12e1421385c4985068..ed3c6016c6dfcfe9b809d3b53312d2a21df9065a 100644 (file)
@@ -1,3 +1,56 @@
+Fri Apr 16 16:43:22 1999  Doug Evans  <devans@charmed.cygnus.com>
+
+       * sim-core.c (device_error,device_io_read_buffer,
+       device_io_write_buffer): Delete decls.
+       * sim-core.h: Put them here.
+
+       * sim-core.c (sim_core_read_buffer): Pass sd to device_io_read_buffer.
+       (sim_core_write_buffer): Pass sd to device_io_write_buffer.
+       * sim-n-core.h (sim_core_read_aligned_N): Ditto.
+       (sim_core_write_aligned_N): Ditto.
+
+1999-04-14  Stephane Carrez  <stcarrez@worldnet.fr>
+
+       * sim-memopt.c (sim_memory_uninstall): Don't look into
+       free()d memory.
+
+1999-04-14  Doug Evans  <devans@casey.cygnus.com>
+
+       * cgen-utils.scm (virtual_insn_entries): Update attribute definition.
+
+1999-04-13  Doug Evans  <devans@casey.cygnus.com>
+
+       * sim-core.c (sim_core_read_buffer): Handle NULL cpu when WITH_DEVICES.
+       (sim_core_write_buffer): Ditto.
+
+1999-04-02  Keith Seitz  <keiths@cygnus.com>
+
+       * sim-io.c (sim_io_poll_quit): Only call the poll_quit callback
+       after the interval counter has expired.
+       (POLL_QUIT_INTERVAL): Define. Used to tweak the frequency of
+       poll_quit callbacks. May be overridden by Makefile.
+       (poll_quit_counter): New global.
+       * sim-events.c: Remove all mentions of ui_loop_hook. The
+       host callback "poll_quit" will serve the purpose.
+       * run.c: Add definition of ui_loop_hook when NEED_UI_LOOP_HOOK
+       is defined.
+       * nrun.c: Remove declaration of ui_loop_hook.
+
+Wed Mar 31 18:55:41 1999  Doug Evans  <devans@canuck.cygnus.com>
+
+       * cgen-run.c (sim_resume): Don't tell main loop to run "forever"
+       if being used by gdb.
+
+1999-03-22  Doug Evans  <devans@casey.cygnus.com>
+
+       * cgen-types.h (XF,TF): Tweak.
+       * cgen-ops.h: Redo inline support.  Delete DI_FN_SUPPORT,
+       in cgen-types.h.
+       (SUBWORD*,JOIN*): Define.
+       * cgen-trace.c (sim_cgen_disassemble_insn): Update, base_insn_bitsize
+       moved into cpu descriptor.
+       * sim-model.h (MACH): New member `num'.
+
 1999-02-09  Doug Evans  <devans@casey.cygnus.com>
 
        * Make-common.in (CGEN_READ_SCM): Renamed from CGEN_MAIN_SCM.
index 1ec0e6c20194a4101ff7192360787174e661efa3..6b89859160ac8cbc190c8d02890c88d1f2a72bfa 100644 (file)
@@ -1,5 +1,5 @@
 /* Semantics ops support for CGEN-based simulators.
-   Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
    Contributed by Cygnus Solutions.
 
 This file is part of the GNU Simulators.
@@ -23,6 +23,13 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #ifndef CGEN_SEM_OPS_H
 #define CGEN_SEM_OPS_H
 
+#if defined (__GNUC__) && ! defined (SEMOPS_DEFINE_INLINE)
+#define SEMOPS_DEFINE_INLINE
+#define SEMOPS_INLINE extern inline
+#else
+#define SEMOPS_INLINE
+#endif
+
 /* Semantic operations.
    At one point this file was machine generated.  Maybe it will be again.  */
 
@@ -357,6 +364,7 @@ extern DI EXTSIDI PARAMS ((SI));
 #else
 #define EXTSIDI(x) ((DI) (SI) (x))
 #endif
+
 #if defined (SF_FN_SUPPORT) || defined (DF_FN_SUPPORT)
 extern DF EXTSFDF PARAMS ((SF));
 #else
@@ -387,6 +395,7 @@ extern TF EXTXFTF PARAMS ((XF));
 #else
 #define EXTXFTF(x) ((TF) (XF) (x))
 #endif
+
 #define ZEXTBIQI(x) ((QI) (BI) (x))
 #define ZEXTBIHI(x) ((HI) (BI) (x))
 #define ZEXTBISI(x) ((SI) (BI) (x))
@@ -413,6 +422,7 @@ extern DI ZEXTSIDI PARAMS ((SI));
 #else
 #define ZEXTSIDI(x) ((DI) (USI) (x))
 #endif
+
 #define TRUNCQIBI(x) ((BI) (QI) (x))
 #define TRUNCHIBI(x) ((BI) (HI) (x))
 #define TRUNCHIQI(x) ((QI) (HI) (x))
@@ -439,6 +449,7 @@ extern SI TRUNCDISI PARAMS ((DI));
 #else
 #define TRUNCDISI(x) ((SI) (DI) (x))
 #endif
+
 #if defined (DF_FN_SUPPORT) || defined (SF_FN_SUPPORT)
 extern SF TRUNCDFSF PARAMS ((DF));
 #else
@@ -469,6 +480,7 @@ extern XF TRUNCTFXF PARAMS ((TF));
 #else
 #define TRUNCTFXF(x) ((XF) (TF) (x))
 #endif
+
 #if defined (SF_FN_SUPPORT)
 extern SF FLOATQISF PARAMS ((QI));
 #else
@@ -549,6 +561,7 @@ extern TF FLOATDITF PARAMS ((DI));
 #else
 #define FLOATDITF(x) ((TF) (DI) (x))
 #endif
+
 #if defined (SF_FN_SUPPORT)
 extern SF UFLOATQISF PARAMS ((QI));
 #else
@@ -629,6 +642,7 @@ extern TF UFLOATDITF PARAMS ((DI));
 #else
 #define UFLOATDITF(x) ((TF) (UDI) (x))
 #endif
+
 #if defined (SF_FN_SUPPORT)
 extern BI FIXSFBI PARAMS ((SF));
 #else
@@ -729,6 +743,7 @@ extern DI FIXTFDI PARAMS ((TF));
 #else
 #define FIXTFDI(x) ((DI) (TF) (x))
 #endif
+
 #if defined (SF_FN_SUPPORT)
 extern QI UFIXSFQI PARAMS ((SF));
 #else
@@ -810,15 +825,118 @@ extern DI UFIXTFDI PARAMS ((TF));
 #define UFIXTFDI(x) ((UDI) (TF) (x))
 #endif
 \f
-/* Semantic support utilities.  */
-
-#ifdef __GNUC__
+/* Composing/decomposing the various types.  */
 
 #ifdef SEMOPS_DEFINE_INLINE
-#define SEMOPS_INLINE
+
+SEMOPS_INLINE SF
+SUBWORDSISF (SIM_CPU *cpu, SI in)
+{
+  union { SI in; SF out; } x;
+  x.in = in;
+  return x.out;
+}
+
+SEMOPS_INLINE SI
+SUBWORDSFSI (SIM_CPU *cpu, SF in)
+{
+  union { SF in; SI out; } x;
+  x.in = in;
+  return x.out;
+}
+
+SEMOPS_INLINE SI
+SUBWORDDISI (SIM_CPU *cpu, DI in, int word)
+{
+  /* ??? endianness issues undecided */
+  if (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN)
+    {
+      if (word == 0)
+       return (UDI) in >> 32;
+      else
+       return in;
+    }
+  else
+    {
+      if (word == 1)
+       return (UDI) in >> 32;
+      else
+       return in;
+    }
+}
+
+SEMOPS_INLINE SI
+SUBWORDDFSI (SIM_CPU *cpu, DF in, int word)
+{
+  /* ??? endianness issues undecided */
+  union { DF in; SI out[2]; } x;
+  x.in = in;
+  if (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN)
+    return x.out[word];
+  else
+    return x.out[!word];
+}
+
+SEMOPS_INLINE SI
+SUBWORDTFSI (SIM_CPU *cpu, TF in, int word)
+{
+  /* ??? endianness issues undecided */
+  union { TF in; SI out[4]; } x;
+  x.in = in;
+  if (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN)
+    return x.out[word];
+  else
+    return x.out[word ^ 3];
+}
+
+SEMOPS_INLINE DI
+JOINSIDI (SIM_CPU *cpu, SI x0, SI x1)
+{
+  if (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN)
+    return MAKEDI (x0, x1);
+  else
+    return MAKEDI (x1, x0);
+}
+
+SEMOPS_INLINE DF
+JOINSIDF (SIM_CPU *cpu, SI x0, SI x1)
+{
+  union { SI in[2]; DF out; } x;
+  if (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN)
+    x.in[0] = x0, x.in[1] = x1;
+  else
+    x.in[1] = x0, x.in[0] = x1;
+  return x.out;
+}
+
+SEMOPS_INLINE TF
+JOINSITF (SIM_CPU *cpu, SI x0, SI x1, SI x2, SI x3)
+{
+  union { SI in[4]; TF out; } x;
+  if (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN)
+    x.in[0] = x0, x.in[1] = x1, x.in[2] = x2, x.in[3] = x3;
+  else
+    x.in[3] = x0, x.in[2] = x1, x.in[1] = x2, x.in[0] = x3;
+  return x.out;
+}
+
 #else
-#define SEMOPS_INLINE extern inline
-#endif
+
+SF SUBWORDSISF (SIM_CPU *, SI);
+SI SUBWORDSFSI (SIM_CPU *, SF);
+SI SUBWORDDISI (SIM_CPU *, DI, int);
+SI SUBWORDDFSI (SIM_CPU *, DF, int);
+SI SUBWORDTFSI (SIM_CPU *, TF, int);
+
+DI JOINSIDI (SIM_CPU *, SI, SI);
+DF JOINSIDF (SIM_CPU *, SI, SI);
+TF JOINSITF (SIM_CPU *, SI, SI, SI, SI);
+
+#endif /* SUBWORD,JOIN */
+\f
+/* Semantic support utilities.  */
+
+#ifdef SEMOPS_DEFINE_INLINE
 
 SEMOPS_INLINE SI
 ADDCSI (SI a, SI b, BI c)
@@ -877,21 +995,5 @@ UBI SUBCFSI (SI, SI, BI);
 UBI SUBOFSI (SI, SI, BI);
 
 #endif
-\f
-/* DI mode support if "long long" doesn't exist.
-   At one point CGEN supported K&R C compilers, and ANSI C compilers without
-   "long long".  One can argue the various merits of keeping this in or
-   throwing it out.  I went to the trouble of adding it so for the time being
-   I'm leaving it in.  */
-
-#ifdef DI_FN_SUPPORT
-
-DI make_struct_di (SI, SI);
-/* FIXME: needed? */
-DI CONVHIDI (HI);
-DI CONVSIDI (SI);
-SI CONVDISI (DI);
-
-#endif /* DI_FN_SUPPORT */
 
 #endif /* CGEN_SEM_OPS_H */
index 07ee19197d73d7dc0215c3bb2390d9e6f1e70c68..031bc1c69ea8fda7bceb50a9c8e4dc6e447b5f3c 100644 (file)
@@ -93,9 +93,13 @@ sim_resume (SIM_DESC sd, int step, int siggnal)
         way to identify this case.  */
       int max_insns = (step
                       ? 1
-                      : (nr_cpus == 1 /*&& wip:no-events*/)
+                      : (nr_cpus == 1
+                         /*&& wip:no-events*/
+                         /* Don't do this if running under gdb, need to
+                            poll ui for events.  */
+                         && STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE)
                       ? 0
-                      : 4); /*FIXME: magic number*/
+                      : 8); /*FIXME: magic number*/
       int fast_p = STATE_RUN_FAST_P (sd);
 
       sim_events_preprocess (sd, last_cpu_nr >= nr_cpus, next_cpu_nr >= nr_cpus);
index 9b7d1faf5d4f04101536b7bad6aee8a6d08b74e3..db852d5306c60c5b2339f7a2c02456a96b1766d9 100644 (file)
@@ -380,12 +380,12 @@ sim_cgen_disassemble_insn (SIM_CPU *cpu, const CGEN_INSN *insn,
   length = sim_core_read_buffer (sd, cpu, read_map, &insn_buf, pc,
                                 insn_length);
 
-  switch (min (CGEN_BASE_INSN_SIZE, insn_length))
+  switch (min (cd->base_insn_bitsize, insn_bit_length))
     {
     case 0 : return; /* fake insn, typically "compile" (aka "invalid") */
-    case 1 : insn_value = insn_buf.bytes[0]; break;
-    case 2 : insn_value = T2H_2 (insn_buf.shorts[0]); break;
-    case 4 : insn_value = T2H_4 (insn_buf.words[0]); break;
+    case 8 : insn_value = insn_buf.bytes[0]; break;
+    case 16 : insn_value = T2H_2 (insn_buf.shorts[0]); break;
+    case 32 : insn_value = T2H_4 (insn_buf.words[0]); break;
     default: abort ();
     }
 
index e57e601ef556f95e1f28af9398d3a5298a79d691..28c7205ad6059d5c6d09e900e0e3686ee3d7e740 100644 (file)
@@ -100,10 +100,10 @@ extern DI make_struct_di (SI, SI);
 
 /* FIXME: Need to provide libraries if these aren't appropriate for target,
    or user's needs.  */
-typedef float SF;
-typedef double DF;
-typedef double XF; /* FIXME: configure, provide library */
-typedef double TF; /* FIXME: configure, provide library */
+typedef float SF;  /* FIXME: struct */
+typedef double DF; /* FIXME: struct */
+typedef struct { SI parts[3]; } XF; /* FIXME: configure, provide library */
+typedef struct { SI parts[4]; } TF; /* FIXME: configure, provide library */
 
 /* These are used to record extracted raw data from an instruction, among other
    things.  It must be a host data type, and not a target one.  */
index 2faff5c2948d47b55977a37bf47fd2055b643c52..b1c9f02eb7e18d2d2827abbde71132ddf430c18c 100644 (file)
@@ -59,28 +59,22 @@ const char *mode_names[] = {
 static const CGEN_IBASE virtual_insn_entries[] =
 {
   {
-    VIRTUAL_INSN_X_INVALID, "--invalid--", NULL, 0,
-    { CGEN_INSN_NBOOL_ATTRS, V, { 0 } }
+    VIRTUAL_INSN_X_INVALID, "--invalid--", NULL, 0, { V, { 0 } }
   },
   {
-    VIRTUAL_INSN_X_BEFORE, "--before--", NULL, 0,
-    { CGEN_INSN_NBOOL_ATTRS, V, { 0 } }
+    VIRTUAL_INSN_X_BEFORE, "--before--", NULL, 0, { V, { 0 } }
   },
   {
-    VIRTUAL_INSN_X_AFTER, "--after--", NULL, 0,
-    { CGEN_INSN_NBOOL_ATTRS, V, { 0 } }
+    VIRTUAL_INSN_X_AFTER, "--after--", NULL, 0, { V, { 0 } }
   },
   {
-    VIRTUAL_INSN_X_BEGIN, "--begin--", NULL, 0,
-    { CGEN_INSN_NBOOL_ATTRS, V, { 0 } }
+    VIRTUAL_INSN_X_BEGIN, "--begin--", NULL, 0, { V, { 0 } }
   },
   {
-    VIRTUAL_INSN_X_CHAIN, "--chain--", NULL, 0,
-    { CGEN_INSN_NBOOL_ATTRS, V, { 0 } }
+    VIRTUAL_INSN_X_CHAIN, "--chain--", NULL, 0, { V, { 0 } }
   },
   {
-    VIRTUAL_INSN_X_CTI_CHAIN, "--cti-chain--", NULL, 0,
-    { CGEN_INSN_NBOOL_ATTRS, V, { 0 } }
+    VIRTUAL_INSN_X_CTI_CHAIN, "--cti-chain--", NULL, 0, { V, { 0 } }
   }
 };
 
index 42be33ef65550768c67053d2f1c7f8a41a2b3d12..2f13b1f91bbf2f164bf996984677355855575525 100644 (file)
@@ -206,9 +206,3 @@ usage ()
   fprintf (stderr, "Run `%s --help' for full list of options.\n", myname);
   exit (1);
 }
-
-
-#ifdef __CYGWIN32__
-/* no-op GUI update hook for standalone sim */
-void (*ui_loop_hook) PARAMS ((int)) = NULL;
-#endif
index 2a701bc4900c3396846f7c52f2b94a00a77de3ed..72d7509d721cf733e09cda6d160f7f317e472ce6 100644 (file)
@@ -56,12 +56,16 @@ extern host_callback default_callback;
 
 static char *myname;
 
-
 /* NOTE: sim_size() and sim_trace() are going away */
 extern int sim_trace PARAMS ((SIM_DESC sd));
 
 extern int getopt ();
 
+#ifdef NEED_UI_LOOP_HOOK
+/* Gdb foolery. This is only needed for gdb using a gui. */
+int (*ui_loop_hook) PARAMS ((int signo));
+#endif
+
 static SIM_DESC sd;
 
 static RETSIGTYPE
index 36627a20350b0d9a803ea15d8ebc81acce4f721d..f7579c40a980f5d031ee90b0d936d21626e766ba 100644 (file)
 #include "sim-hw.h"
 #endif
 
-#if (WITH_DEVICES)
-/* TODO: create sim/common/device.h */
-void device_error (device *me, char* message, ...);
-int device_io_read_buffer(device *me, void *dest, int space, address_word addr, unsigned nr_bytes, sim_cpu *processor, sim_cia cia);
-int device_io_write_buffer(device *me, const void *source, int space, address_word addr, unsigned nr_bytes, sim_cpu *processor, sim_cia cia);
-#endif
-
 /* "core" module install handler.
 
    This is called via sim_module_install to install the "core"
@@ -534,6 +527,7 @@ sim_core_read_buffer (SIM_DESC sd,
     if (mapping->device != NULL)
       {
        int nr_bytes = len - count;
+       sim_cia cia = cpu ? CIA_GET (cpu) : NULL_CIA;
        if (raddr + nr_bytes - 1> mapping->bound)
          nr_bytes = mapping->bound - raddr + 1;
        if (device_io_read_buffer (mapping->device,
@@ -541,8 +535,9 @@ sim_core_read_buffer (SIM_DESC sd,
                                   mapping->space,
                                   raddr,
                                   nr_bytes, 
+                                  sd,
                                   cpu, 
-                                  CIA_GET (cpu)) != nr_bytes)
+                                  cia) != nr_bytes)
          break;
        count += nr_bytes;
        continue;
@@ -599,6 +594,7 @@ sim_core_write_buffer (SIM_DESC sd,
          && mapping->device != NULL)
        {
          int nr_bytes = len - count;
+         sim_cia cia = cpu ? CIA_GET (cpu) : NULL_CIA;
          if (raddr + nr_bytes - 1 > mapping->bound)
            nr_bytes = mapping->bound - raddr + 1;
          if (device_io_write_buffer (mapping->device,
@@ -606,8 +602,9 @@ sim_core_write_buffer (SIM_DESC sd,
                                      mapping->space,
                                      raddr,
                                      nr_bytes,
+                                     sd,
                                      cpu, 
-                                     CIA_GET(cpu)) != nr_bytes)
+                                     cia) != nr_bytes)
            break;
          count += nr_bytes;
          continue;
index 7bf15a3b48db495935f3b4559b287d941303c465..182569e5aead844a5e24733a359c5f823cccab60 100644 (file)
@@ -340,4 +340,13 @@ DECLARE_SIM_CORE_READ_N(misaligned,7,8)
 #undef DECLARE_SIM_CORE_READ_N
 
 
+#if (WITH_DEVICES)
+/* TODO: create sim/common/device.h */
+/* These are defined with each particular cpu.  */
+void device_error (device *me, char* message, ...);
+int device_io_read_buffer(device *me, void *dest, int space, address_word addr, unsigned nr_bytes, SIM_DESC sd, sim_cpu *processor, sim_cia cia);
+int device_io_write_buffer(device *me, const void *source, int space, address_word addr, unsigned nr_bytes, SIM_DESC sd, sim_cpu *processor, sim_cia cia);
+#endif
+
+
 #endif
index 4b7d9b4b6be2c6c175f601b1887bcb3fc8a97c2b..fc211644e85acbbb10c68c078556996dff99b5c6 100644 (file)
 
 #include <signal.h> /* For SIGPROCMASK et.al. */
 
-#if __CYGWIN32__
-/* The ui_loop_hook is called to keep the GUI alive while the simulator
-   is running.  The counter is to make sure we do not wake it too often.
-*/
-
-extern void (*ui_loop_hook) PARAMS ((int));
-static unsigned int ui_loop_hook_counter = 0;
-#endif
-
 typedef enum {
   watch_invalid,
 
@@ -1171,18 +1162,6 @@ sim_events_process (SIM_DESC sd)
 
   /* this round of processing complete */
   events->nr_ticks_to_process = 0;
-
-#if __CYGWIN32__
-  /* Now call the ui_loop_hook to give the gui a chance to
-     process events. */
-  
-  if (ui_loop_hook != NULL)
-    {
-      /* attempt to limit calls to 1-10 per second */
-      if (! (ui_loop_hook_counter++ & 0xf))
-       (*ui_loop_hook) (-2); /* magic */
-    }
-#endif
 }
 
 #endif
index f3d2f674a64e3c397d6eb32ad641856d68db54b3..26f44451a30fb606a0e94740098ef6a044cb84f2 100644 (file)
 #include <unistd.h>
 #endif
 
+/* Define the rate at which the simulator should poll the host
+   for a quit. */
+#ifndef POLL_QUIT_INTERVAL
+#define POLL_QUIT_INTERVAL 0x10
+#endif
+
+static int poll_quit_count = POLL_QUIT_INTERVAL;
 
 /* See the file include/callbacks.h for a description */
 
@@ -304,9 +311,12 @@ sim_io_error(SIM_DESC sd,
 void
 sim_io_poll_quit(SIM_DESC sd)
 {
-  if (STATE_CALLBACK (sd)->poll_quit != NULL)
-    if (STATE_CALLBACK (sd)->poll_quit (STATE_CALLBACK (sd)))
-      sim_stop (sd);
+  if (STATE_CALLBACK (sd)->poll_quit != NULL && poll_quit_count-- < 0)
+    {
+      poll_quit_count = POLL_QUIT_INTERVAL;
+      if (STATE_CALLBACK (sd)->poll_quit (STATE_CALLBACK (sd)))
+       sim_stop (sd);
+    }
 }
 
 
index be52a6648f2bfcd51cede00b14fa494005e97497..6e12a4555295a4c3a2af833396e75cdeb74a2b20 100644 (file)
@@ -449,6 +449,10 @@ sim_memory_uninstall (SIM_DESC sd)
 
       /* delete it and its aliases */
       alias = *entry;
+
+      /* next victim */
+      *entry = (*entry)->next;
+
       while (alias != NULL)
        {
          sim_memopt *dead = alias;
@@ -456,9 +460,6 @@ sim_memory_uninstall (SIM_DESC sd)
          sim_core_detach (sd, NULL, dead->level, dead->space, dead->addr);
          zfree (dead);
        }
-
-      /* next victim */
-      *entry = (*entry)->next;
     }
 }
 
index 6f7769af78788af0ef786bf0020ed3ae21d860e7..52728152e14a27479ad1f4aadb059d5f8fab43a6 100644 (file)
@@ -79,6 +79,9 @@ typedef struct {
   /* This is the argument to bfd_scan_arch.  */
   const char *bfd_name;
 #define MACH_BFD_NAME(m) ((m)->bfd_name)
+  enum mach_attr num;
+#define MACH_NUM(m) ((m)->num)
+
   int word_bitsize;
 #define MACH_WORD_BITSIZE(m) ((m)->word_bitsize)
   int addr_bitsize;
index 46eca0355fd87ad3252e24e3f8f07ed5deefc45c..7a04a9fb4bc1d65ef66b16f82da80f40c44eff60 100644 (file)
@@ -167,7 +167,7 @@ sim_core_read_aligned_N(sim_cpu *cpu,
       if (WITH_CALLBACK_MEMORY && mapping->device != NULL)
        {
          unsigned_M data;
-         if (device_io_read_buffer (mapping->device, &data, mapping->space, addr, N, cpu, cia) != N)
+         if (device_io_read_buffer (mapping->device, &data, mapping->space, addr, N, CPU_STATE (cpu), cpu, cia) != N)
            device_error (mapping->device, "internal error - %s - io_read_buffer should not fail",
                          XSTRING (sim_core_read_aligned_N));
          val = T2H_M (data);
@@ -298,7 +298,7 @@ sim_core_write_aligned_N(sim_cpu *cpu,
       if (WITH_CALLBACK_MEMORY && mapping->device != NULL)
        {
          unsigned_M data = H2T_M (val);
-         if (device_io_write_buffer (mapping->device, &data, mapping->space, addr, N, cpu, cia) != N)
+         if (device_io_write_buffer (mapping->device, &data, mapping->space, addr, N, CPU_STATE (cpu), cpu, cia) != N)
            device_error (mapping->device, "internal error - %s - io_write_buffer should not fail",
                          XSTRING (sim_core_write_aligned_N));
          break;
index 9257de97d74e5e44bfe1f562da31d53f7ce82bb2..4d0232e54113c56fb3dd6a7d9467cec52546b523 100755 (executable)
@@ -1413,6 +1413,7 @@ case "${target}" in
   h8500-*-*)           sim_target=h8500 ;;
   i960-*-*)            sim_target=i960 ;;
   m32r-*-*)            sim_target=m32r ;;
+  mcore-*-*)           sim_target=mcore ;;
   mips*-*-*)
        # The MIPS simulator can only be compiled by gcc.
        sim_target=mips
@@ -1463,35 +1464,20 @@ case "${target}" in
   z8k*-*-*)            sim_target=z8k ;;
   sparc64-*-*)
        only_if_gcc=yes
-       if test "x${with_cgen}" = xyes -o "x${with_cgen_sim}" = xyes ; then
-               sim_target=sparc
-               extra_subdirs="${extra_subdirs} testsuite"
-       else
-               sim_target=none # Don't build erc32 if sparc64.
-       fi
+       sim_target=none # Don't build erc32 if sparc64.
        ;;
   sparclite*-*-* | sparc86x*-*-*)
        # The SPARC simulator can only be compiled by gcc.
        only_if_gcc=yes
-       if test "x${with_cgen}" = xyes -o "x${with_cgen_sim}" = xyes ; then
-               sim_target=sparc
-               extra_subdirs="${extra_subdirs} testsuite"
-       else
-               sim_target=erc32
-       fi
+       sim_target=erc32
        ;;
   sparc*-*-*)
        # The SPARC simulator can only be compiled by gcc.
        only_if_gcc=yes
-       if test "x${with_cgen}" = xyes -o "x${with_cgen_sim}" = xyes ; then
-               sim_target=sparc
-               extra_subdirs="${extra_subdirs} testsuite"
-       else
-               # Unfortunately erc32 won't build on many hosts, so only enable
-               # it if the user really really wants it.
-               only_if_enabled=yes
-               sim_target=erc32
-       fi
+       # Unfortunately erc32 won't build on many hosts, so only enable
+       # it if the user really really wants it.
+       only_if_enabled=yes
+       sim_target=erc32
        ;;
   *)                   sim_target=none ;;
 esac
index 5e316da9ecebe209f3401e2fe788c4be8e2d03a6..c37304990f0fc65efae890630f259906d8a2add0 100644 (file)
@@ -61,6 +61,7 @@ case "${target}" in
   h8500-*-*)           sim_target=h8500 ;;
   i960-*-*)            sim_target=i960 ;;
   m32r-*-*)            sim_target=m32r ;;
+  mcore-*-*)           sim_target=mcore ;;
   mips*-*-*)
        # The MIPS simulator can only be compiled by gcc.
        sim_target=mips
@@ -111,35 +112,20 @@ case "${target}" in
   z8k*-*-*)            sim_target=z8k ;;
   sparc64-*-*)
        only_if_gcc=yes
-       if test "x${with_cgen}" = xyes -o "x${with_cgen_sim}" = xyes ; then
-               sim_target=sparc
-               extra_subdirs="${extra_subdirs} testsuite"
-       else
-               sim_target=none # Don't build erc32 if sparc64.
-       fi
+       sim_target=none # Don't build erc32 if sparc64.
        ;;
   sparclite*-*-* | sparc86x*-*-*)
        # The SPARC simulator can only be compiled by gcc.
        only_if_gcc=yes
-       if test "x${with_cgen}" = xyes -o "x${with_cgen_sim}" = xyes ; then
-               sim_target=sparc
-               extra_subdirs="${extra_subdirs} testsuite"
-       else
-               sim_target=erc32
-       fi
+       sim_target=erc32
        ;;
   sparc*-*-*)
        # The SPARC simulator can only be compiled by gcc.
        only_if_gcc=yes
-       if test "x${with_cgen}" = xyes -o "x${with_cgen_sim}" = xyes ; then
-               sim_target=sparc
-               extra_subdirs="${extra_subdirs} testsuite"
-       else
-               # Unfortunately erc32 won't build on many hosts, so only enable
-               # it if the user really really wants it.
-               only_if_enabled=yes
-               sim_target=erc32
-       fi
+       # Unfortunately erc32 won't build on many hosts, so only enable
+       # it if the user really really wants it.
+       only_if_enabled=yes
+       sim_target=erc32
        ;;
   *)                   sim_target=none ;;
 esac
index 73b8c9287a6d7aa2e9af0524eeefef008895ade5..2c0297a6cf88557d6b27efea01f5638eb23f1e88 100644 (file)
@@ -1,3 +1,24 @@
+1999-04-02  Keith Seitz  <keiths@cygnus.com>
+
+       * interp.c (ui_loop_hook_counter): New global (when NEED_UI_LOOP_HOOK
+       defined).
+       (sim_resume): If the counter has expired, call the ui_loop_hook,
+       if defined.
+       (UI_LOOP_POLL_INTERVAL): Define. Used to tweak the frequency of
+       ui_loop_hook calls.
+       * Makefile.in (SIM_EXTRA_CFLAGS): Include NEED_UI_LOOP_HOOK.
+
+Wed Mar 10 19:32:13 1999  Nick Clifton  <nickc@cygnus.com>
+
+       * simops.c: If load instruction with auto increment/decrement
+       addressing is used when the destination register is the same as
+       the address register, then ignore the auto increment/decrement.
+
+Wed Mar 10 19:32:13 1999  Martin M. Hunt  <hunt@cygnus.com>
+
+       * simops.c (OP_5F00): Ifdef SYS_stat case because
+       not all systems have it defined.
+
 1999-01-26  Jason Molenda  (jsm@bugshack.cygnus.com)
 
        * simops.c (OP_5607): Correct saturation comparison/assignment.
index 07323275dec7f4506185c5b0d9dc66e9ba6725bc..602ffff0c99becc3530a65bbe0689a55244d4494 100644 (file)
@@ -20,6 +20,7 @@
 
 SIM_OBJS = interp.o table.o simops.o endian.o sim-load.o
 SIM_EXTRA_CLEAN = clean-extra
+SIM_EXTRA_CFLAGS = -DNEED_UI_LOOP_HOOK
 
 INCLUDE = d10v_sim.h $(srcroot)/include/callback.h targ-vals.h endian.c
 
index 17c964f8d556b9fcdf2ad68c3112d905657cdd4f..4602ed2b58c530a87145abf839b0cc6e55f4128b 100644 (file)
@@ -39,6 +39,17 @@ static char *add_commas PARAMS ((char *buf, int sizeof_buf, unsigned long value)
 extern void sim_set_profile PARAMS ((int n));
 extern void sim_set_profile_size PARAMS ((int n));
 
+#ifdef NEED_UI_LOOP_HOOK
+/* How often to run the ui_loop update, when in use */
+#define UI_LOOP_POLL_INTERVAL 0x14000
+
+/* Counter for the ui_loop_hook update */
+static long ui_loop_hook_counter = UI_LOOP_POLL_INTERVAL;
+
+/* Actual hook to call to run through gdb's gui event loop */
+extern int (*ui_loop_hook) PARAMS ((int signo));
+#endif /* NEED_UI_LOOP_HOOK */
+
 #ifndef INLINE
 #if defined(__GNUC__) && defined(__OPTIMIZE__)
 #define INLINE __inline__
@@ -784,6 +795,13 @@ sim_resume (sd, step, siggnal)
       /* Writeback all the DATA / PC changes */
       SLOT_FLUSH ();
 
+#ifdef NEED_UI_LOOP_HOOK
+      if (ui_loop_hook != NULL && ui_loop_hook_counter-- < 0)
+       {
+         ui_loop_hook_counter = UI_LOOP_POLL_INTERVAL;
+         ui_loop_hook (0);
+       }
+#endif /* NEED_UI_LOOP_HOOK */
     }
   while ( !State.exception && !stop_simulator);
   
index c64ba425d1680846c715b6a4c6b4def784155cae..0614c9feda31fc93725643ef2e2e5105e0b1f3a7 100644 (file)
@@ -1333,7 +1333,8 @@ OP_6601 ()
   trace_input ("ld2w", OP_REG_OUTPUT, OP_POSTDEC, OP_VOID);
   tmp = RLW (addr);
   SET_GPR32 (OP[0], tmp);
-  INC_ADDR (OP[1], -4);
+  if (OP[0] != OP[1])
+    INC_ADDR (OP[1], -4);
   trace_output_32 (tmp);
 }
 
@@ -1346,7 +1347,8 @@ OP_6201 ()
   trace_input ("ld2w", OP_REG_OUTPUT, OP_POSTINC, OP_VOID);
   tmp = RLW (addr);
   SET_GPR32 (OP[0], tmp);
-  INC_ADDR (OP[1], 4);
+  if (OP[0] != OP[1])
+    INC_ADDR (OP[1], 4);
   trace_output_32 (tmp);
 }
 
@@ -3124,6 +3126,7 @@ OP_5F00 ()
            trace_output_void ();
            break;
 
+#ifdef TARGET_SYS_stat
          case TARGET_SYS_stat:
            trace_input ("<stat>", OP_R0, OP_R1, OP_VOID);
            /* stat system call */
@@ -3152,6 +3155,7 @@ OP_5F00 ()
            }
            trace_output_16 (result);
            break;
+#endif
 
          case TARGET_SYS_chown:
            trace_input ("<chown>", OP_R0, OP_R1, OP_R2);
index 668d89e67501289409823ec3b40644cdf629987c..7687595c04bb11fe24aca4951bdf54b6cb3a1b39 100644 (file)
@@ -1,3 +1,16 @@
+1999-03-16  Martin Hunt  <hunt@cygnus.com>
+       From Frank Ch. Eigler  <fche@cygnus.com>
+
+        * cpu.h (mvtsys_left_p): New flag for MVTSYS instruction history.
+        * d30v-insns (mvtsys): Set this flag instead of left_kills_right_p.
+        (do_sath): Detect MVTSYS by new flag.
+        * engine.c (unqueue_writes): Detect MVTSYS by new flag.
+        (do_2_short, do_parallel): Initialize new flag.
+       
+1999-02-26  Frank Ch. Eigler  <fche@cygnus.com>
+
+       * tconfig.in (SIM_HANDLES_LMA): Make it so.
+
 1999-01-12  Frank Ch. Eigler  <fche@cygnus.com>
 
        * engine.c (unqueue_writes): Make PSW conflict resolution code
index 6190e61f0a0dbdd18ac422b711cb47e4d09d28bf..d24a4acf7ad9eaf4d7b7eebac300956d60ade130 100644 (file)
@@ -115,6 +115,7 @@ struct _sim_cpu {
   int trace_trap_p;                    /* If unknown traps dump out the regs */
   int trace_action;                    /* trace bits at end of instructions */
   int left_kills_right_p;               /* left insn kills insn in right slot of -> */
+  int mvtsys_left_p;                   /* left insn was mvtsys */
   int did_trap;                                /* we did a trap & need to finish it */
   struct _write32 write32;             /* queued up 32-bit writes */
   struct _write64 write64;             /* queued up 64-bit writes */
index 6dc4f6bec224ff522748e48968afae5056355e29..5b34e807bd508300d0d32f055b897154715dc9e4 100644 (file)
@@ -1520,11 +1520,11 @@ _BRA,01110,00,6.CR,6.RB,6.ID:BRA:short:mu:MVTSYS
          else
            {
              unsigned32 value = Rb;
+             CPU->mvtsys_left_p = 1;
              if (CR == processor_status_word_cr)
                {
                  unsigned32 ds = PSW & BIT32 (PSW_DS); /* preserve ds */
                  value = ds | (value & PSW_VALID);
-                 CPU->left_kills_right_p = 1;
                }
              else if (CR == backup_processor_status_word_cr
                       || CR == debug_backup_processor_status_word_cr)
@@ -1537,19 +1537,16 @@ _BRA,01110,00,6.CR,6.RB,6.ID:BRA:short:mu:MVTSYS
        case 1:                 /* PSWL */
          WRITE32_QUEUE_MASK (&PSW, EXTRACTED32(Rb, 16, 31),
                              PSW_VALID & 0x0000ffff);
-         CPU->left_kills_right_p = 1;
          break;
        case 2:                 /* PSWH */
          {
            unsigned32 ds = PSW & BIT32 (PSW_DS);       /* preserve ds */
            WRITE32_QUEUE_MASK (&PSW, (EXTRACTED32(Rb, 16, 31) << 16) | ds,
                                (PSW_VALID | ds) & 0xffff0000);
-           CPU->left_kills_right_p = 1;
          }
          break;
        case 3:                 /* FLAG */
          PSW_FLAG_SET_QUEUE(CR, Rb & 1);
-         CPU->left_kills_right_p = 1;
          break;
        default:
          sim_engine_abort (SD, CPU, cia, "FIXME - illegal ID");
@@ -1745,7 +1742,7 @@ void::function::do_sath:signed32 *ra, signed32 rb, signed32 src, int high, int u
        if (updates_f4)
          {
            /* if MU instruction was a MVTSYS (lkr), unqueue register writes now */
-           if(STATE_CPU (sd, 0)->left_kills_right_p)
+           if(STATE_CPU (sd, 0)->mvtsys_left_p)
              unqueue_writes (sd, STATE_CPU (sd, 0), cia);
            PSW_FLAG_SET_QUEUE(PSW_S_FLAG, PSW_FLAG_VAL(PSW_S_FLAG) ^ (value & 1));
          }
index 402a2f5bd5f1ae78bf6d1797fe56c64be1e51eb1..2bbaad16a16cf82db5531612e5fa3f20d1ce04b7 100644 (file)
@@ -134,9 +134,9 @@ unqueue_writes (SIM_DESC sd,
 
       if (ptr == psw_addr)
        {
-         /* If MU instruction was not a MVTSYS (lkr), resolve PSW
+        /* If MU instruction was not a MVTSYS, resolve PSW
              contention in favour of IU. */
-         if(! STATE_CPU (sd, 0)->left_kills_right_p)
+         if(! STATE_CPU (sd, 0)->mvtsys_left_p)
            {
              /* Detect contention in parallel writes to the same PSW flags.
                 The hardware allows the updates from IU to prevail over
@@ -249,6 +249,7 @@ do_2_short (SIM_DESC sd,
   /* run the first instruction */
   STATE_CPU (sd, 0)->unit = unit;
   STATE_CPU (sd, 0)->left_kills_right_p = 0;
+  STATE_CPU (sd, 0)->mvtsys_left_p = 0;
   nia = s_idecode_issue(sd,
                        insn1,
                        cia);
@@ -267,6 +268,7 @@ do_2_short (SIM_DESC sd,
   }
 
   STATE_CPU (sd, 0)->left_kills_right_p = 0;
+  STATE_CPU (sd, 0)->mvtsys_left_p = 0;
   return nia;
 }
 
@@ -283,6 +285,7 @@ do_parallel (SIM_DESC sd,
   /* run the first instruction */
   STATE_CPU (sd, 0)->unit = memory_unit;
   STATE_CPU (sd, 0)->left_kills_right_p = 0;
+  STATE_CPU (sd, 0)->mvtsys_left_p = 0;
   nia_left = s_idecode_issue(sd,
                             left_insn,
                             cia);
index c742b3601d414be3236177eebc5c4b7902751470..4efbb915212f99c609dd1d162fbdbc1edf3fd217 100644 (file)
@@ -2,3 +2,7 @@
 
 /* Define this to enable the intrinsic breakpoint mechanism. */
 #define SIM_HAVE_BREAKPOINTS
+
+/* See sim-hload.c.  We properly handle LMA. */
+#define SIM_HANDLES_LMA 1
+
index b908a501bb992b296c8e531c968fed7452e0e42e..4375a585c3d1c7b4c96984bcd611de50baa7757c 100644 (file)
@@ -1,3 +1,8 @@
+1999-03-03  DJ Delorie  <dj@cygnus.com>
+
+       * configure.in: add termcap and -luser32 for host=cygwin
+       * configure: regenerate
+       
 1999-02-11  Hugo Tyson  <hmt@cygnus.co.uk>
 
        * exec.c (dispatch_instruction): 
index 793acef5f69896b8d71a8d38d995929ff18d3692..d08ac331110f3eac90663e52b1a59b9938f7c76d 100755 (executable)
@@ -132,8 +132,10 @@ sim_inline="-DDEFAULT_INLINE=0"
 
 
 
+
+
 # Guess values for system-dependent variables and create Makefiles.
-# Generated automatically using autoconf version 2.12.2 
+# Generated automatically using autoconf version 2.13 
 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
 #
 # This configure script is free software; the Free Software Foundation
@@ -483,7 +485,7 @@ EOF
     verbose=yes ;;
 
   -version | --version | --versio | --versi | --vers)
-    echo "configure generated by autoconf version 2.12.2"
+    echo "configure generated by autoconf version 2.13"
     exit 0 ;;
 
   -with-* | --with-*)
@@ -673,7 +675,7 @@ fi
 
 
 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
-echo "configure:677: checking how to run the C preprocessor" >&5
+echo "configure:679: checking how to run the C preprocessor" >&5
 # On Suns, sometimes $CPP names a directory.
 if test -n "$CPP" && test -d "$CPP"; then
   CPP=
@@ -688,13 +690,13 @@ else
   # On the NeXT, cc -E runs the code through the compiler's parser,
   # not just through cpp.
   cat > conftest.$ac_ext <<EOF
-#line 692 "configure"
+#line 694 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:698: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:700: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -705,13 +707,13 @@ else
   rm -rf conftest*
   CPP="${CC-cc} -E -traditional-cpp"
   cat > conftest.$ac_ext <<EOF
-#line 709 "configure"
+#line 711 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:715: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:717: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -722,13 +724,13 @@ else
   rm -rf conftest*
   CPP="${CC-cc} -nologo -E"
   cat > conftest.$ac_ext <<EOF
-#line 726 "configure"
+#line 728 "configure"
 #include "confdefs.h"
 #include <assert.h>
 Syntax Error
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:732: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:734: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   :
@@ -753,7 +755,7 @@ fi
 echo "$ac_t""$CPP" 1>&6
 
 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
-echo "configure:757: checking whether ${MAKE-make} sets \${MAKE}" >&5
+echo "configure:759: checking whether ${MAKE-make} sets \${MAKE}" >&5
 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -780,7 +782,7 @@ else
 fi
 
 echo $ac_n "checking for POSIXized ISC""... $ac_c" 1>&6
-echo "configure:784: checking for POSIXized ISC" >&5
+echo "configure:786: checking for POSIXized ISC" >&5
 if test -d /etc/conf/kconfig.d &&
   grep _POSIX_VERSION /usr/include/sys/unistd.h >/dev/null 2>&1
 then
@@ -801,12 +803,12 @@ else
 fi
 
 echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6
-echo "configure:805: checking for ANSI C header files" >&5
+echo "configure:807: checking for ANSI C header files" >&5
 if eval "test \"`echo '$''{'ac_cv_header_stdc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 810 "configure"
+#line 812 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 #include <stdarg.h>
@@ -814,7 +816,7 @@ else
 #include <float.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:818: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:820: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -831,7 +833,7 @@ rm -f conftest*
 if test $ac_cv_header_stdc = yes; then
   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 835 "configure"
+#line 837 "configure"
 #include "confdefs.h"
 #include <string.h>
 EOF
@@ -849,7 +851,7 @@ fi
 if test $ac_cv_header_stdc = yes; then
   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 853 "configure"
+#line 855 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
 EOF
@@ -870,7 +872,7 @@ if test "$cross_compiling" = yes; then
   :
 else
   cat > conftest.$ac_ext <<EOF
-#line 874 "configure"
+#line 876 "configure"
 #include "confdefs.h"
 #include <ctype.h>
 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
@@ -881,7 +883,7 @@ if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) exit(2);
 exit (0); }
 
 EOF
-if { (eval echo configure:885: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:887: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   :
 else
@@ -905,12 +907,12 @@ EOF
 fi
 
 echo $ac_n "checking for working const""... $ac_c" 1>&6
-echo "configure:909: checking for working const" >&5
+echo "configure:911: checking for working const" >&5
 if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 914 "configure"
+#line 916 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -959,7 +961,7 @@ ccp = (char const *const *) p;
 
 ; return 0; }
 EOF
-if { (eval echo configure:963: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:965: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_const=yes
 else
@@ -980,21 +982,21 @@ EOF
 fi
 
 echo $ac_n "checking for inline""... $ac_c" 1>&6
-echo "configure:984: checking for inline" >&5
+echo "configure:986: checking for inline" >&5
 if eval "test \"`echo '$''{'ac_cv_c_inline'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   ac_cv_c_inline=no
 for ac_kw in inline __inline__ __inline; do
   cat > conftest.$ac_ext <<EOF
-#line 991 "configure"
+#line 993 "configure"
 #include "confdefs.h"
 
 int main() {
 } $ac_kw foo() {
 ; return 0; }
 EOF
-if { (eval echo configure:998: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:1000: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_inline=$ac_kw; break
 else
@@ -1020,12 +1022,12 @@ EOF
 esac
 
 echo $ac_n "checking for off_t""... $ac_c" 1>&6
-echo "configure:1024: checking for off_t" >&5
+echo "configure:1026: checking for off_t" >&5
 if eval "test \"`echo '$''{'ac_cv_type_off_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1029 "configure"
+#line 1031 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -1034,7 +1036,7 @@ else
 #endif
 EOF
 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  egrep "off_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
+  egrep "(^|[^a-zA-Z_0-9])off_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
   rm -rf conftest*
   ac_cv_type_off_t=yes
 else
@@ -1053,12 +1055,12 @@ EOF
 fi
 
 echo $ac_n "checking for size_t""... $ac_c" 1>&6
-echo "configure:1057: checking for size_t" >&5
+echo "configure:1059: checking for size_t" >&5
 if eval "test \"`echo '$''{'ac_cv_type_size_t'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1062 "configure"
+#line 1064 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #if STDC_HEADERS
@@ -1067,7 +1069,7 @@ else
 #endif
 EOF
 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  egrep "size_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
+  egrep "(^|[^a-zA-Z_0-9])size_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
   rm -rf conftest*
   ac_cv_type_size_t=yes
 else
@@ -1088,19 +1090,19 @@ fi
 # The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
 # for constant arguments.  Useless!
 echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6
-echo "configure:1092: checking for working alloca.h" >&5
+echo "configure:1094: checking for working alloca.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_alloca_h'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1097 "configure"
+#line 1099 "configure"
 #include "confdefs.h"
 #include <alloca.h>
 int main() {
 char *p = alloca(2 * sizeof(int));
 ; return 0; }
 EOF
-if { (eval echo configure:1104: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1106: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_header_alloca_h=yes
 else
@@ -1121,12 +1123,12 @@ EOF
 fi
 
 echo $ac_n "checking for alloca""... $ac_c" 1>&6
-echo "configure:1125: checking for alloca" >&5
+echo "configure:1127: checking for alloca" >&5
 if eval "test \"`echo '$''{'ac_cv_func_alloca_works'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1130 "configure"
+#line 1132 "configure"
 #include "confdefs.h"
 
 #ifdef __GNUC__
@@ -1154,7 +1156,7 @@ int main() {
 char *p = (char *) alloca(1);
 ; return 0; }
 EOF
-if { (eval echo configure:1158: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1160: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   ac_cv_func_alloca_works=yes
 else
@@ -1186,12 +1188,12 @@ EOF
 
 
 echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6
-echo "configure:1190: checking whether alloca needs Cray hooks" >&5
+echo "configure:1192: checking whether alloca needs Cray hooks" >&5
 if eval "test \"`echo '$''{'ac_cv_os_cray'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1195 "configure"
+#line 1197 "configure"
 #include "confdefs.h"
 #if defined(CRAY) && ! defined(CRAY2)
 webecray
@@ -1216,12 +1218,12 @@ echo "$ac_t""$ac_cv_os_cray" 1>&6
 if test $ac_cv_os_cray = yes; then
 for ac_func in _getb67 GETB67 getb67; do
   echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:1220: checking for $ac_func" >&5
+echo "configure:1222: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1225 "configure"
+#line 1227 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -1244,7 +1246,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:1248: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1250: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -1271,7 +1273,7 @@ done
 fi
 
 echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6
-echo "configure:1275: checking stack direction for C alloca" >&5
+echo "configure:1277: checking stack direction for C alloca" >&5
 if eval "test \"`echo '$''{'ac_cv_c_stack_direction'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1279,7 +1281,7 @@ else
   ac_cv_c_stack_direction=0
 else
   cat > conftest.$ac_ext <<EOF
-#line 1283 "configure"
+#line 1285 "configure"
 #include "confdefs.h"
 find_stack_direction ()
 {
@@ -1298,7 +1300,7 @@ main ()
   exit (find_stack_direction() < 0);
 }
 EOF
-if { (eval echo configure:1302: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:1304: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_c_stack_direction=1
 else
@@ -1323,17 +1325,17 @@ for ac_hdr in unistd.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:1327: checking for $ac_hdr" >&5
+echo "configure:1329: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1332 "configure"
+#line 1334 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:1337: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:1339: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -1362,12 +1364,12 @@ done
 for ac_func in getpagesize
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:1366: checking for $ac_func" >&5
+echo "configure:1368: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 1371 "configure"
+#line 1373 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -1390,7 +1392,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:1394: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1396: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -1415,7 +1417,7 @@ fi
 done
 
 echo $ac_n "checking for working mmap""... $ac_c" 1>&6
-echo "configure:1419: checking for working mmap" >&5
+echo "configure:1421: checking for working mmap" >&5
 if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1423,7 +1425,7 @@ else
   ac_cv_func_mmap_fixed_mapped=no
 else
   cat > conftest.$ac_ext <<EOF
-#line 1427 "configure"
+#line 1429 "configure"
 #include "confdefs.h"
 
 /* Thanks to Mike Haertel and Jim Avera for this test.
@@ -1563,7 +1565,7 @@ main()
 }
 
 EOF
-if { (eval echo configure:1567: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:1569: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_func_mmap_fixed_mapped=yes
 else
@@ -1636,7 +1638,7 @@ else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 fi
 
 echo $ac_n "checking host system type""... $ac_c" 1>&6
-echo "configure:1640: checking host system type" >&5
+echo "configure:1642: checking host system type" >&5
 
 host_alias=$host
 case "$host_alias" in
@@ -1657,7 +1659,7 @@ host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$host" 1>&6
 
 echo $ac_n "checking target system type""... $ac_c" 1>&6
-echo "configure:1661: checking target system type" >&5
+echo "configure:1663: checking target system type" >&5
 
 target_alias=$target
 case "$target_alias" in
@@ -1675,7 +1677,7 @@ target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 echo "$ac_t""$target" 1>&6
 
 echo $ac_n "checking build system type""... $ac_c" 1>&6
-echo "configure:1679: checking build system type" >&5
+echo "configure:1681: checking build system type" >&5
 
 build_alias=$build
 case "$build_alias" in
@@ -1719,7 +1721,7 @@ test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 # Extract the first word of "gcc", so it can be a program name with args.
 set dummy gcc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1723: checking for $ac_word" >&5
+echo "configure:1725: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1727,7 +1729,8 @@ else
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       ac_cv_prog_CC="gcc"
@@ -1748,7 +1751,7 @@ if test -z "$CC"; then
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1752: checking for $ac_word" >&5
+echo "configure:1755: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1757,7 +1760,8 @@ else
 else
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
   ac_prog_rejected=no
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
@@ -1798,7 +1802,7 @@ fi
       # Extract the first word of "cl", so it can be a program name with args.
 set dummy cl; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1802: checking for $ac_word" >&5
+echo "configure:1806: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1806,7 +1810,8 @@ else
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       ac_cv_prog_CC="cl"
@@ -1829,7 +1834,7 @@ fi
 fi
 
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
-echo "configure:1833: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+echo "configure:1838: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
 
 ac_ext=c
 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
@@ -1838,12 +1843,14 @@ ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 cross_compiling=$ac_cv_prog_cc_cross
 
-cat > conftest.$ac_ext <<EOF
-#line 1843 "configure"
+cat > conftest.$ac_ext << EOF
+
+#line 1849 "configure"
 #include "confdefs.h"
+
 main(){return(0);}
 EOF
-if { (eval echo configure:1847: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1854: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   ac_cv_prog_cc_works=yes
   # If we can't run a trivial program, we are probably using a cross compiler.
   if (./conftest; exit) 2>/dev/null; then
@@ -1857,18 +1864,24 @@ else
   ac_cv_prog_cc_works=no
 fi
 rm -fr conftest*
+ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
 
 echo "$ac_t""$ac_cv_prog_cc_works" 1>&6
 if test $ac_cv_prog_cc_works = no; then
   { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
 fi
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
-echo "configure:1867: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "configure:1880: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
 echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
 cross_compiling=$ac_cv_prog_cc_cross
 
 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:1872: checking whether we are using GNU C" >&5
+echo "configure:1885: checking whether we are using GNU C" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1877,7 +1890,7 @@ else
   yes;
 #endif
 EOF
-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1881: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1894: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
   ac_cv_prog_gcc=yes
 else
   ac_cv_prog_gcc=no
@@ -1896,7 +1909,7 @@ ac_test_CFLAGS="${CFLAGS+set}"
 ac_save_CFLAGS="$CFLAGS"
 CFLAGS=
 echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
-echo "configure:1900: checking whether ${CC-cc} accepts -g" >&5
+echo "configure:1913: checking whether ${CC-cc} accepts -g" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1939,7 +1952,7 @@ fi
 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 # ./install, which can be erroneously created by make from ./install.sh.
 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
-echo "configure:1943: checking for a BSD compatible install" >&5
+echo "configure:1956: checking for a BSD compatible install" >&5
 if test -z "$INSTALL"; then
 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1987,6 +2000,8 @@ echo "$ac_t""$INSTALL" 1>&6
 # It thinks the first close brace ends the variable substitution.
 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
+
 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 
 
@@ -2005,7 +2020,7 @@ AR=${AR-ar}
 # Extract the first word of "ranlib", so it can be a program name with args.
 set dummy ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2009: checking for $ac_word" >&5
+echo "configure:2024: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2013,7 +2028,8 @@ else
   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
 else
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       ac_cv_prog_RANLIB="ranlib"
@@ -2039,17 +2055,17 @@ unistd.h values.h sys/param.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2043: checking for $ac_hdr" >&5
+echo "configure:2059: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2048 "configure"
+#line 2064 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2053: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2069: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2079,12 +2095,12 @@ done
 __argz_count __argz_stringify __argz_next
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2083: checking for $ac_func" >&5
+echo "configure:2099: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2088 "configure"
+#line 2104 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -2107,7 +2123,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2111: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2127: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -2136,12 +2152,12 @@ done
      for ac_func in stpcpy
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2140: checking for $ac_func" >&5
+echo "configure:2156: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2145 "configure"
+#line 2161 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -2164,7 +2180,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2168: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2184: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -2198,19 +2214,19 @@ EOF
 
    if test $ac_cv_header_locale_h = yes; then
     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
-echo "configure:2202: checking for LC_MESSAGES" >&5
+echo "configure:2218: checking for LC_MESSAGES" >&5
 if eval "test \"`echo '$''{'am_cv_val_LC_MESSAGES'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2207 "configure"
+#line 2223 "configure"
 #include "confdefs.h"
 #include <locale.h>
 int main() {
 return LC_MESSAGES
 ; return 0; }
 EOF
-if { (eval echo configure:2214: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2230: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   am_cv_val_LC_MESSAGES=yes
 else
@@ -2231,7 +2247,7 @@ EOF
     fi
   fi
    echo $ac_n "checking whether NLS is requested""... $ac_c" 1>&6
-echo "configure:2235: checking whether NLS is requested" >&5
+echo "configure:2251: checking whether NLS is requested" >&5
         # Check whether --enable-nls or --disable-nls was given.
 if test "${enable_nls+set}" = set; then
   enableval="$enable_nls"
@@ -2251,7 +2267,7 @@ fi
 EOF
 
       echo $ac_n "checking whether included gettext is requested""... $ac_c" 1>&6
-echo "configure:2255: checking whether included gettext is requested" >&5
+echo "configure:2271: checking whether included gettext is requested" >&5
       # Check whether --with-included-gettext or --without-included-gettext was given.
 if test "${with_included_gettext+set}" = set; then
   withval="$with_included_gettext"
@@ -2270,17 +2286,17 @@ fi
 
        ac_safe=`echo "libintl.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for libintl.h""... $ac_c" 1>&6
-echo "configure:2274: checking for libintl.h" >&5
+echo "configure:2290: checking for libintl.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2279 "configure"
+#line 2295 "configure"
 #include "confdefs.h"
 #include <libintl.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2284: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2300: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2297,19 +2313,19 @@ fi
 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
   echo "$ac_t""yes" 1>&6
   echo $ac_n "checking for gettext in libc""... $ac_c" 1>&6
-echo "configure:2301: checking for gettext in libc" >&5
+echo "configure:2317: checking for gettext in libc" >&5
 if eval "test \"`echo '$''{'gt_cv_func_gettext_libc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2306 "configure"
+#line 2322 "configure"
 #include "confdefs.h"
 #include <libintl.h>
 int main() {
 return (int) gettext ("")
 ; return 0; }
 EOF
-if { (eval echo configure:2313: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2329: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   gt_cv_func_gettext_libc=yes
 else
@@ -2325,7 +2341,7 @@ echo "$ac_t""$gt_cv_func_gettext_libc" 1>&6
 
           if test "$gt_cv_func_gettext_libc" != "yes"; then
             echo $ac_n "checking for bindtextdomain in -lintl""... $ac_c" 1>&6
-echo "configure:2329: checking for bindtextdomain in -lintl" >&5
+echo "configure:2345: checking for bindtextdomain in -lintl" >&5
 ac_lib_var=`echo intl'_'bindtextdomain | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2333,7 +2349,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lintl  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 2337 "configure"
+#line 2353 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -2344,7 +2360,7 @@ int main() {
 bindtextdomain()
 ; return 0; }
 EOF
-if { (eval echo configure:2348: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2364: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -2360,19 +2376,19 @@ fi
 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
   echo "$ac_t""yes" 1>&6
   echo $ac_n "checking for gettext in libintl""... $ac_c" 1>&6
-echo "configure:2364: checking for gettext in libintl" >&5
+echo "configure:2380: checking for gettext in libintl" >&5
 if eval "test \"`echo '$''{'gt_cv_func_gettext_libintl'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2369 "configure"
+#line 2385 "configure"
 #include "confdefs.h"
 
 int main() {
 return (int) gettext ("")
 ; return 0; }
 EOF
-if { (eval echo configure:2376: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2392: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   gt_cv_func_gettext_libintl=yes
 else
@@ -2400,7 +2416,7 @@ EOF
              # Extract the first word of "msgfmt", so it can be a program name with args.
 set dummy msgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2404: checking for $ac_word" >&5
+echo "configure:2420: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2434,12 +2450,12 @@ fi
                for ac_func in dcgettext
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2438: checking for $ac_func" >&5
+echo "configure:2454: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2443 "configure"
+#line 2459 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -2462,7 +2478,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2466: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2482: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -2489,7 +2505,7 @@ done
                # Extract the first word of "gmsgfmt", so it can be a program name with args.
 set dummy gmsgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2493: checking for $ac_word" >&5
+echo "configure:2509: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2502,7 +2518,8 @@ else
   ;;
   *)
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do 
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       ac_cv_path_GMSGFMT="$ac_dir/$ac_word"
@@ -2524,7 +2541,7 @@ fi
                # Extract the first word of "xgettext", so it can be a program name with args.
 set dummy xgettext; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2528: checking for $ac_word" >&5
+echo "configure:2545: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2556,7 +2573,7 @@ else
 fi
 
                cat > conftest.$ac_ext <<EOF
-#line 2560 "configure"
+#line 2577 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -2564,7 +2581,7 @@ extern int _nl_msg_cat_cntr;
                               return _nl_msg_cat_cntr
 ; return 0; }
 EOF
-if { (eval echo configure:2568: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2585: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   CATOBJEXT=.gmo
                   DATADIRNAME=share
@@ -2596,7 +2613,7 @@ fi
         # Extract the first word of "msgfmt", so it can be a program name with args.
 set dummy msgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2600: checking for $ac_word" >&5
+echo "configure:2617: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2630,7 +2647,7 @@ fi
         # Extract the first word of "gmsgfmt", so it can be a program name with args.
 set dummy gmsgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2634: checking for $ac_word" >&5
+echo "configure:2651: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2643,7 +2660,8 @@ else
   ;;
   *)
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do 
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       ac_cv_path_GMSGFMT="$ac_dir/$ac_word"
@@ -2665,7 +2683,7 @@ fi
         # Extract the first word of "xgettext", so it can be a program name with args.
 set dummy xgettext; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2669: checking for $ac_word" >&5
+echo "configure:2687: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2755,7 +2773,7 @@ fi
        LINGUAS=
      else
        echo $ac_n "checking for catalogs to be installed""... $ac_c" 1>&6
-echo "configure:2759: checking for catalogs to be installed" >&5
+echo "configure:2777: checking for catalogs to be installed" >&5
        NEW_LINGUAS=
        for lang in ${LINGUAS=$ALL_LINGUAS}; do
          case "$ALL_LINGUAS" in
@@ -2783,17 +2801,17 @@ echo "configure:2759: checking for catalogs to be installed" >&5
       if test "$CATOBJEXT" = ".cat"; then
         ac_safe=`echo "linux/version.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for linux/version.h""... $ac_c" 1>&6
-echo "configure:2787: checking for linux/version.h" >&5
+echo "configure:2805: checking for linux/version.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2792 "configure"
+#line 2810 "configure"
 #include "confdefs.h"
 #include <linux/version.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2797: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2815: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2862,17 +2880,17 @@ for ac_hdr in stdlib.h string.h strings.h unistd.h time.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2866: checking for $ac_hdr" >&5
+echo "configure:2884: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2871 "configure"
+#line 2889 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2876: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2894: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2902,17 +2920,17 @@ for ac_hdr in sys/time.h sys/resource.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2906: checking for $ac_hdr" >&5
+echo "configure:2924: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2911 "configure"
+#line 2929 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2916: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2934: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2942,17 +2960,57 @@ for ac_hdr in fcntl.h fpu_control.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2946: checking for $ac_hdr" >&5
+echo "configure:2964: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2951 "configure"
+#line 2969 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2956: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2974: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
+if test -z "$ac_err"; then
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=yes"
+else
+  echo "$ac_err" >&5
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  eval "ac_cv_header_$ac_safe=no"
+fi
+rm -f conftest*
+fi
+if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
+  echo "$ac_t""yes" 1>&6
+    ac_tr_hdr=HAVE_`echo $ac_hdr | sed 'y%abcdefghijklmnopqrstuvwxyz./-%ABCDEFGHIJKLMNOPQRSTUVWXYZ___%'`
+  cat >> confdefs.h <<EOF
+#define $ac_tr_hdr 1
+EOF
+else
+  echo "$ac_t""no" 1>&6
+fi
+done
+
+for ac_hdr in dlfcn.h errno.h sys/stat.h
+do
+ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
+echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
+echo "configure:3004: checking for $ac_hdr" >&5
+if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 3009 "configure"
+#include "confdefs.h"
+#include <$ac_hdr>
+EOF
+ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
+{ (eval echo configure:3014: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2981,12 +3039,12 @@ done
 for ac_func in getrusage time sigaction __setfpucw
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2985: checking for $ac_func" >&5
+echo "configure:3043: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2990 "configure"
+#line 3048 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3009,7 +3067,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3013: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3071: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3036,7 +3094,7 @@ done
 
 # Check for socket libraries
 echo $ac_n "checking for bind in -lsocket""... $ac_c" 1>&6
-echo "configure:3040: checking for bind in -lsocket" >&5
+echo "configure:3098: checking for bind in -lsocket" >&5
 ac_lib_var=`echo socket'_'bind | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -3044,7 +3102,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lsocket  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 3048 "configure"
+#line 3106 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -3055,7 +3113,7 @@ int main() {
 bind()
 ; return 0; }
 EOF
-if { (eval echo configure:3059: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3117: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -3083,7 +3141,7 @@ else
 fi
 
 echo $ac_n "checking for gethostbyname in -lnsl""... $ac_c" 1>&6
-echo "configure:3087: checking for gethostbyname in -lnsl" >&5
+echo "configure:3145: checking for gethostbyname in -lnsl" >&5
 ac_lib_var=`echo nsl'_'gethostbyname | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -3091,7 +3149,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lnsl  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 3095 "configure"
+#line 3153 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -3102,7 +3160,7 @@ int main() {
 gethostbyname()
 ; return 0; }
 EOF
-if { (eval echo configure:3106: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3164: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -3278,12 +3336,12 @@ fi
 
 
 echo $ac_n "checking return type of signal handlers""... $ac_c" 1>&6
-echo "configure:3282: checking return type of signal handlers" >&5
+echo "configure:3340: checking return type of signal handlers" >&5
 if eval "test \"`echo '$''{'ac_cv_type_signal'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3287 "configure"
+#line 3345 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <signal.h>
@@ -3300,7 +3358,7 @@ int main() {
 int i;
 ; return 0; }
 EOF
-if { (eval echo configure:3304: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3362: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_type_signal=void
 else
@@ -3320,7 +3378,7 @@ EOF
 
 
 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
-echo "configure:3324: checking for executable suffix" >&5
+echo "configure:3382: checking for executable suffix" >&5
 if eval "test \"`echo '$''{'am_cv_exeext'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -3368,17 +3426,17 @@ for ac_hdr in stdlib.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:3372: checking for $ac_hdr" >&5
+echo "configure:3430: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3377 "configure"
+#line 3435 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3382: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:3440: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3405,8 +3463,39 @@ fi
 done
 
 
-echo $ac_n "checking for main in -ltermcap""... $ac_c" 1>&6
-echo "configure:3410: checking for main in -ltermcap" >&5
+# In the Cygwin environment, we need some additional flags.
+echo $ac_n "checking for cygwin""... $ac_c" 1>&6
+echo "configure:3469: checking for cygwin" >&5
+if eval "test \"`echo '$''{'sim_cv_os_cygwin'+set}'`\" = set"; then
+  echo $ac_n "(cached) $ac_c" 1>&6
+else
+  cat > conftest.$ac_ext <<EOF
+#line 3474 "configure"
+#include "confdefs.h"
+
+#ifdef __CYGWIN__
+lose
+#endif
+EOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  egrep "lose" >/dev/null 2>&1; then
+  rm -rf conftest*
+  sim_cv_os_cygwin=yes
+else
+  rm -rf conftest*
+  sim_cv_os_cygwin=no
+fi
+rm -f conftest*
+
+fi
+
+echo "$ac_t""$sim_cv_os_cygwin" 1>&6
+
+if test x$sim_cv_os_cygwin = xyes; then
+  TERMCAP='`if test -r ../../libtermcap/libtermcap.a; then echo ../../libtermcap/libtermcap.a; else echo -ltermcap; fi` -luser32'
+else
+  echo $ac_n "checking for main in -ltermcap""... $ac_c" 1>&6
+echo "configure:3499: checking for main in -ltermcap" >&5
 ac_lib_var=`echo termcap'_'main | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -3414,14 +3503,14 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-ltermcap  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 3418 "configure"
+#line 3507 "configure"
 #include "confdefs.h"
 
 int main() {
 main()
 ; return 0; }
 EOF
-if { (eval echo configure:3425: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3514: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -3442,6 +3531,7 @@ else
 TERMCAP=""
 fi
 
+fi
 
 
 
@@ -3469,7 +3559,7 @@ EOF
 # Ultrix sh set writes to stderr and can't be redirected directly,
 # and sets the high bit in the cache file unless we assign to the vars.
 (set) 2>&1 |
-  case `(ac_space=' '; set) 2>&1 | grep ac_space` in
+  case `(ac_space=' '; set | grep ac_space) 2>&1` in
   *ac_space=\ *)
     # `set' does not quote correctly, so add quotes (double-quote substitution
     # turns \\\\ into \\, and sed turns \\ into \).
@@ -3536,7 +3626,7 @@ do
     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
-    echo "$CONFIG_STATUS generated by autoconf version 2.12.2"
+    echo "$CONFIG_STATUS generated by autoconf version 2.13"
     exit 0 ;;
   -help | --help | --hel | --he | --h)
     echo "\$ac_cs_usage"; exit 0 ;;
@@ -3580,6 +3670,7 @@ s%@SHELL@%$SHELL%g
 s%@CFLAGS@%$CFLAGS%g
 s%@CPPFLAGS@%$CPPFLAGS%g
 s%@CXXFLAGS@%$CXXFLAGS%g
+s%@FFLAGS@%$FFLAGS%g
 s%@DEFS@%$DEFS%g
 s%@LDFLAGS@%$LDFLAGS%g
 s%@LIBS@%$LIBS%g
@@ -3615,6 +3706,7 @@ s%@build_vendor@%$build_vendor%g
 s%@build_os@%$build_os%g
 s%@CC@%$CC%g
 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
+s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
 s%@INSTALL_DATA@%$INSTALL_DATA%g
 s%@CC_FOR_BUILD@%$CC_FOR_BUILD%g
 s%@HDEFINES@%$HDEFINES%g
index c139f713cd65130591553600f3c8470d4559c3bc..cef343daf8bb9e55185fdaee339ec622b2e28adf 100644 (file)
@@ -7,7 +7,18 @@ SIM_AC_COMMON
 
 AC_CHECK_HEADERS(stdlib.h)
 
-AC_CHECK_LIB(termcap, main, TERMCAP=-ltermcap, TERMCAP="")
+# In the Cygwin environment, we need some additional flags.
+AC_CACHE_CHECK([for cygwin], sim_cv_os_cygwin,
+[AC_EGREP_CPP(lose, [
+#ifdef __CYGWIN__
+lose
+#endif],[sim_cv_os_cygwin=yes],[sim_cv_os_cygwin=no])])
+
+if test x$sim_cv_os_cygwin = xyes; then
+  TERMCAP='`if test -r ../../libtermcap/libtermcap.a; then echo ../../libtermcap/libtermcap.a; else echo -ltermcap; fi` -luser32'
+else
+  AC_CHECK_LIB(termcap, main, TERMCAP=-ltermcap, TERMCAP="")
+fi
 AC_SUBST(TERMCAP)
 
 SIM_AC_OUTPUT
index dd399aafb5972e68227af39098fbd9d51106f17d..7d0f18d0c27e8d6f99242b9b964d271f1b5b2dc7 100644 (file)
@@ -1,3 +1,44 @@
+Fri Apr 16 16:50:31 1999  Doug Evans  <devans@charmed.cygnus.com>
+
+       * devices.c (device_io_read_buffer): New arg `sd'.
+       (device_io_write_buffer): New arg `sd'.
+       (device_error): Give proper arg spec.
+
+1999-04-10  Doug Evans  <devans@casey.cygnus.com>
+
+       * cpu.h,sem-switch.c,sem.c: Rebuild.
+
+1999-03-27  Doug Evans  <devans@casey.cygnus.com>
+
+       * decode.c: Rebuild.
+
+1999-03-22  Doug Evans  <devans@casey.cygnus.com>
+
+       * arch.c,arch.h,model.c: Rebuild.
+       * fr30.c (fr30bf_fetch_register): Replace calls to a_fr30_h_* with
+       calls to fr30bf_h_*.
+       (fr30bf_store_register): Ditto.
+       * traps.c (setup_int): Ditto.
+       * sim-if.c (sim_open): Update call to fr30_cgen_cpu_open.
+
+Mon Mar 22 13:13:05 1999  Dave Brolley  <brolley@cygnus.com>
+
+       * configure.in: Use SIM_AC_OPTION_ALIGNMENT(FORCED_ALIGNMENT).
+       * configure: Regenerate.
+       * cpu.h: Regenerate.
+
+1999-03-11  Doug Evans  <devans@casey.cygnus.com>
+
+       * arch.c,arch.h,cpu.c,cpu.h: Rebuild.
+       * fr30-sim.h (GET_H_SBIT,SET_H_SBIT): Delete.
+       (GET_H_CCR,SET_H_CCR,GET_H_SCR,SET_H_SCR,GET_H_ILM,SET_H_ILM): Delete.
+       (GET_H_PS,SET_H_PS,GET_H_DR,SET_H_DR): Delete.
+       * sim-if.c (sim_open): Update call to fr30_cgen_cpu_open.
+
+1999-02-25  Doug Evans  <devans@casey.cygnus.com>
+
+       * cpu.h: Rebuild.
+
 1999-02-09  Doug Evans  <devans@casey.cygnus.com>
 
        * Makefile.in (SIM_EXTRA_DEPS): Add fr30-desc.h, delete cpu-opc.h.
index db6e23e1a02dd25cfc156f86ae9058de21a83e8f..55eea0da90e191d5bc672641009e1ec963fccf1a 100644 (file)
@@ -33,663 +33,3 @@ const MACH *sim_machs[] =
   0
 };
 
-/* Get the value of h-pc.  */
-
-USI
-a_fr30_h_pc_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_pc_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-pc.  */
-
-void
-a_fr30_h_pc_set (SIM_CPU *current_cpu, USI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_pc_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-gr.  */
-
-SI
-a_fr30_h_gr_get (SIM_CPU *current_cpu, UINT regno)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_gr_get (current_cpu, regno);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-gr.  */
-
-void
-a_fr30_h_gr_set (SIM_CPU *current_cpu, UINT regno, SI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_gr_set (current_cpu, regno, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-cr.  */
-
-SI
-a_fr30_h_cr_get (SIM_CPU *current_cpu, UINT regno)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_cr_get (current_cpu, regno);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-cr.  */
-
-void
-a_fr30_h_cr_set (SIM_CPU *current_cpu, UINT regno, SI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_cr_set (current_cpu, regno, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-dr.  */
-
-SI
-a_fr30_h_dr_get (SIM_CPU *current_cpu, UINT regno)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_dr_get (current_cpu, regno);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-dr.  */
-
-void
-a_fr30_h_dr_set (SIM_CPU *current_cpu, UINT regno, SI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_dr_set (current_cpu, regno, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-ps.  */
-
-USI
-a_fr30_h_ps_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_ps_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-ps.  */
-
-void
-a_fr30_h_ps_set (SIM_CPU *current_cpu, USI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_ps_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-r13.  */
-
-SI
-a_fr30_h_r13_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_r13_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-r13.  */
-
-void
-a_fr30_h_r13_set (SIM_CPU *current_cpu, SI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_r13_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-r14.  */
-
-SI
-a_fr30_h_r14_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_r14_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-r14.  */
-
-void
-a_fr30_h_r14_set (SIM_CPU *current_cpu, SI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_r14_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-r15.  */
-
-SI
-a_fr30_h_r15_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_r15_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-r15.  */
-
-void
-a_fr30_h_r15_set (SIM_CPU *current_cpu, SI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_r15_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-nbit.  */
-
-BI
-a_fr30_h_nbit_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_nbit_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-nbit.  */
-
-void
-a_fr30_h_nbit_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_nbit_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-zbit.  */
-
-BI
-a_fr30_h_zbit_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_zbit_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-zbit.  */
-
-void
-a_fr30_h_zbit_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_zbit_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-vbit.  */
-
-BI
-a_fr30_h_vbit_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_vbit_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-vbit.  */
-
-void
-a_fr30_h_vbit_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_vbit_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-cbit.  */
-
-BI
-a_fr30_h_cbit_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_cbit_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-cbit.  */
-
-void
-a_fr30_h_cbit_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_cbit_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-ibit.  */
-
-BI
-a_fr30_h_ibit_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_ibit_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-ibit.  */
-
-void
-a_fr30_h_ibit_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_ibit_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-sbit.  */
-
-BI
-a_fr30_h_sbit_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_sbit_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-sbit.  */
-
-void
-a_fr30_h_sbit_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_sbit_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-tbit.  */
-
-BI
-a_fr30_h_tbit_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_tbit_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-tbit.  */
-
-void
-a_fr30_h_tbit_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_tbit_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-d0bit.  */
-
-BI
-a_fr30_h_d0bit_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_d0bit_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-d0bit.  */
-
-void
-a_fr30_h_d0bit_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_d0bit_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-d1bit.  */
-
-BI
-a_fr30_h_d1bit_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_d1bit_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-d1bit.  */
-
-void
-a_fr30_h_d1bit_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_d1bit_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-ccr.  */
-
-UQI
-a_fr30_h_ccr_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_ccr_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-ccr.  */
-
-void
-a_fr30_h_ccr_set (SIM_CPU *current_cpu, UQI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_ccr_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-scr.  */
-
-UQI
-a_fr30_h_scr_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_scr_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-scr.  */
-
-void
-a_fr30_h_scr_set (SIM_CPU *current_cpu, UQI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_scr_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-ilm.  */
-
-UQI
-a_fr30_h_ilm_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      return fr30bf_h_ilm_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-ilm.  */
-
-void
-a_fr30_h_ilm_set (SIM_CPU *current_cpu, UQI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_FR30BF
-    case bfd_mach_fr30 : 
-      fr30bf_h_ilm_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
index 7bde11d66da958b7ca9dff8afac4aa1ddc2c5d87..ffc516eaebd0023e7d071027e50b6eebfe8c5695 100644 (file)
@@ -27,48 +27,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #define TARGET_BIG_ENDIAN 1
 
-/* Cover fns for register access.  */
-USI a_fr30_h_pc_get (SIM_CPU *);
-void a_fr30_h_pc_set (SIM_CPU *, USI);
-SI a_fr30_h_gr_get (SIM_CPU *, UINT);
-void a_fr30_h_gr_set (SIM_CPU *, UINT, SI);
-SI a_fr30_h_cr_get (SIM_CPU *, UINT);
-void a_fr30_h_cr_set (SIM_CPU *, UINT, SI);
-SI a_fr30_h_dr_get (SIM_CPU *, UINT);
-void a_fr30_h_dr_set (SIM_CPU *, UINT, SI);
-USI a_fr30_h_ps_get (SIM_CPU *);
-void a_fr30_h_ps_set (SIM_CPU *, USI);
-SI a_fr30_h_r13_get (SIM_CPU *);
-void a_fr30_h_r13_set (SIM_CPU *, SI);
-SI a_fr30_h_r14_get (SIM_CPU *);
-void a_fr30_h_r14_set (SIM_CPU *, SI);
-SI a_fr30_h_r15_get (SIM_CPU *);
-void a_fr30_h_r15_set (SIM_CPU *, SI);
-BI a_fr30_h_nbit_get (SIM_CPU *);
-void a_fr30_h_nbit_set (SIM_CPU *, BI);
-BI a_fr30_h_zbit_get (SIM_CPU *);
-void a_fr30_h_zbit_set (SIM_CPU *, BI);
-BI a_fr30_h_vbit_get (SIM_CPU *);
-void a_fr30_h_vbit_set (SIM_CPU *, BI);
-BI a_fr30_h_cbit_get (SIM_CPU *);
-void a_fr30_h_cbit_set (SIM_CPU *, BI);
-BI a_fr30_h_ibit_get (SIM_CPU *);
-void a_fr30_h_ibit_set (SIM_CPU *, BI);
-BI a_fr30_h_sbit_get (SIM_CPU *);
-void a_fr30_h_sbit_set (SIM_CPU *, BI);
-BI a_fr30_h_tbit_get (SIM_CPU *);
-void a_fr30_h_tbit_set (SIM_CPU *, BI);
-BI a_fr30_h_d0bit_get (SIM_CPU *);
-void a_fr30_h_d0bit_set (SIM_CPU *, BI);
-BI a_fr30_h_d1bit_get (SIM_CPU *);
-void a_fr30_h_d1bit_set (SIM_CPU *, BI);
-UQI a_fr30_h_ccr_get (SIM_CPU *);
-void a_fr30_h_ccr_set (SIM_CPU *, UQI);
-UQI a_fr30_h_scr_get (SIM_CPU *);
-void a_fr30_h_scr_set (SIM_CPU *, UQI);
-UQI a_fr30_h_ilm_get (SIM_CPU *);
-void a_fr30_h_ilm_set (SIM_CPU *, UQI);
-
 /* Enum declaration for model types.  */
 typedef enum model_type {
   MODEL_FR30_1, MODEL_MAX
index 43063ad23bb0540f8b3aedf5bef6d60675a468ca..b650e0c427b613c64fa26bd62687073cdf912f52 100644 (file)
@@ -3482,7 +3482,7 @@ else
 fi
 fi
 
-wire_alignment="NONSTRICT_ALIGNMENT"
+wire_alignment="FORCED_ALIGNMENT"
 default_alignment=""
 
 # Check whether --enable-sim-alignment or --disable-sim-alignment was given.
index fc25dfc54b66033c28492f79bb166640d6c77c0f..cb01e1308b5bc2f2b47b46efdc07cadbe7b3c040 100644 (file)
@@ -6,7 +6,7 @@ AC_INIT(Makefile.in)
 SIM_AC_COMMON
 
 SIM_AC_OPTION_ENDIAN(BIG_ENDIAN)
-SIM_AC_OPTION_ALIGNMENT(NONSTRICT_ALIGNMENT)
+SIM_AC_OPTION_ALIGNMENT(FORCED_ALIGNMENT)
 SIM_AC_OPTION_HOSTENDIAN
 SIM_AC_OPTION_SCACHE(16384)
 SIM_AC_OPTION_DEFAULT_MODEL(fr30-1)
index c339a93dc1c2df8868accf9f8273f67871b6d2aa..fb94688c623d2f72b78326c3d463779045d33318 100644 (file)
@@ -26,6 +26,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define WANT_CPU_FR30BF
 
 #include "sim-main.h"
+#include "cgen-ops.h"
 
 /* Get the value of h-pc.  */
 
index 9a02863213083c37bc7ea85fd0f4fca6f893fa5f..13aceb4e4fd5125dbbc8e762315fcdababd72bc2 100644 (file)
@@ -50,21 +50,27 @@ typedef struct {
 #define SET_H_CR(a1, x) (CPU (h_cr)[a1] = (x))
   /* dedicated registers */
   SI h_dr[6];
-/* GET_H_DR macro user-written */
-/* SET_H_DR macro user-written */
-  /* program status */
+#define GET_H_DR(index) fr30bf_h_dr_get_handler (current_cpu, index)
+#define SET_H_DR(index, x) \
+do { \
+fr30bf_h_dr_set_handler (current_cpu, (index), (x));\
+} while (0)
+  /* processor status */
   USI h_ps;
-/* GET_H_PS macro user-written */
-/* SET_H_PS macro user-written */
-  /* General Register 13 explicitely required */
+#define GET_H_PS() fr30bf_h_ps_get_handler (current_cpu)
+#define SET_H_PS(x) \
+do { \
+fr30bf_h_ps_set_handler (current_cpu, (x));\
+} while (0)
+  /* General Register 13 explicitly required */
   SI h_r13;
 #define GET_H_R13() CPU (h_r13)
 #define SET_H_R13(x) (CPU (h_r13) = (x))
-  /* General Register 14 explicitely required */
+  /* General Register 14 explicitly required */
   SI h_r14;
 #define GET_H_R14() CPU (h_r14)
 #define SET_H_R14(x) (CPU (h_r14) = (x))
-  /* General Register 15 explicitely required */
+  /* General Register 15 explicitly required */
   SI h_r15;
 #define GET_H_R15() CPU (h_r15)
 #define SET_H_R15(x) (CPU (h_r15) = (x))
@@ -88,10 +94,13 @@ typedef struct {
   BI h_ibit;
 #define GET_H_IBIT() CPU (h_ibit)
 #define SET_H_IBIT(x) (CPU (h_ibit) = (x))
-  /* stack            bit */
+  /* stack bit */
   BI h_sbit;
-/* GET_H_SBIT macro user-written */
-/* SET_H_SBIT macro user-written */
+#define GET_H_SBIT() fr30bf_h_sbit_get_handler (current_cpu)
+#define SET_H_SBIT(x) \
+do { \
+fr30bf_h_sbit_set_handler (current_cpu, (x));\
+} while (0)
   /* trace trap       bit */
   BI h_tbit;
 #define GET_H_TBIT() CPU (h_tbit)
@@ -104,18 +113,27 @@ typedef struct {
   BI h_d1bit;
 #define GET_H_D1BIT() CPU (h_d1bit)
 #define SET_H_D1BIT(x) (CPU (h_d1bit) = (x))
-  /* condition code   bits */
+  /* condition code bits */
   UQI h_ccr;
-/* GET_H_CCR macro user-written */
-/* SET_H_CCR macro user-written */
+#define GET_H_CCR() fr30bf_h_ccr_get_handler (current_cpu)
+#define SET_H_CCR(x) \
+do { \
+fr30bf_h_ccr_set_handler (current_cpu, (x));\
+} while (0)
   /* system condition bits */
   UQI h_scr;
-/* GET_H_SCR macro user-written */
-/* SET_H_SCR macro user-written */
-  /* interrupt level  mask */
+#define GET_H_SCR() fr30bf_h_scr_get_handler (current_cpu)
+#define SET_H_SCR(x) \
+do { \
+fr30bf_h_scr_set_handler (current_cpu, (x));\
+} while (0)
+  /* interrupt level mask */
   UQI h_ilm;
-/* GET_H_ILM macro user-written */
-/* SET_H_ILM macro user-written */
+#define GET_H_ILM() fr30bf_h_ilm_get_handler (current_cpu)
+#define SET_H_ILM(x) \
+do { \
+fr30bf_h_ilm_set_handler (current_cpu, (x));\
+} while (0)
   } hardware;
 #define CPU_CGEN_HW(cpu) (& (cpu)->cpu_data.hardware)
 } FR30BF_CPU_DATA;
@@ -918,9 +936,9 @@ struct scache {
   f_op1 = EXTRACT_UINT (insn, 16, 0, 4); \
   f_i20_4 = EXTRACT_UINT (insn, 16, 8, 4); \
   f_i20_16 = (0|(EXTRACT_UINT (word_1, 16, 0, 16) << 0)); \
-do {\
+{\
   f_i20 = ((((f_i20_4) << (16))) | (f_i20_16));\
-} while (0);\
+}\
   f_op2 = EXTRACT_UINT (insn, 16, 4, 4); \
   f_Ri = EXTRACT_UINT (insn, 16, 12, 4); \
 
@@ -933,12 +951,14 @@ do {\
   UINT f_Ri; \
   /* Contents of trailing part of insn.  */ \
   UINT word_1; \
+  UINT word_2; \
   unsigned int length;
 #define EXTRACT_IFMT_LDI32_CODE \
   length = 6; \
-  word_1 = GETIMEMUSI (current_cpu, pc + 2); \
+  word_1 = GETIMEMUHI (current_cpu, pc + 2); \
+  word_2 = GETIMEMUHI (current_cpu, pc + 4); \
   f_op1 = EXTRACT_UINT (insn, 16, 0, 4); \
-  f_i32 = (0|(EXTRACT_UINT (word_1, 32, 0, 32) << 0)); \
+  f_i32 = (0|(EXTRACT_UINT (word_2, 16, 0, 16) << 0)|(EXTRACT_UINT (word_1, 16, 0, 16) << 16)); \
   f_op2 = EXTRACT_UINT (insn, 16, 4, 4); \
   f_op3 = EXTRACT_UINT (insn, 16, 8, 4); \
   f_Ri = EXTRACT_UINT (insn, 16, 12, 4); \
index c6d16567f3f5131e4cc3f22fe34da3c33c907c34..e41c45f53fa701a33e385a27d1a0cb913af1b9dd 100644 (file)
@@ -46,6 +46,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define FAST(fn)
 #endif
 
+/* The INSN_ prefix is not here and is instead part of the `insn' argument
+   to avoid collisions with header files (e.g. `AND' in ansidecl.h).  */
+#define IDX(insn) CONCAT2 (FR30BF_,insn)
+#define TYPE(insn) CONCAT2 (FR30_,insn)
+
 /* The instruction descriptor array.
    This is computed at runtime.  Space for it is not malloc'd to save a
    teensy bit of cpu in the decoder.  Moving it to malloc space is trivial
@@ -53,11 +58,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
    addition of instructions nor an SMP machine with different cpus).  */
 static IDESC fr30bf_insn_data[FR30BF_INSN_MAX];
 
-/* The INSN_ prefix is not here and is instead part of the `insn' argument
-   to avoid collisions with header files (e.g. `AND' in ansidecl.h).  */
-#define IDX(insn) CONCAT2 (FR30BF_,insn)
-#define TYPE(insn) CONCAT2 (FR30_,insn)
-
 /* Commas between elements are contained in the macros.
    Some of these are conditionally compiled out.  */
 
@@ -241,6 +241,9 @@ static const struct insn_sem fr30bf_insn_sem_invalid =
   VIRTUAL_INSN_X_INVALID, IDX (INSN_X_INVALID), FULL (x_invalid) FAST (x_invalid)
 };
 
+#undef FMT
+#undef FULL
+#undef FAST
 #undef IDX
 #undef TYPE
 
@@ -302,64 +305,6 @@ fr30bf_init_idesc_table (SIM_CPU *cpu)
   CPU_IDESC (cpu) = table;
 }
 
-/* Enum declaration for all instruction semantic formats.  */
-typedef enum sfmt {
-  FMT_EMPTY, FMT_ADD, FMT_ADDI, FMT_ADD2
- , FMT_ADDC, FMT_ADDN, FMT_ADDNI, FMT_ADDN2
- , FMT_CMP, FMT_CMPI, FMT_CMP2, FMT_AND
- , FMT_ANDM, FMT_ANDH, FMT_ANDB, FMT_BANDL
- , FMT_BTSTL, FMT_MUL, FMT_MULU, FMT_MULH
- , FMT_DIV0S, FMT_DIV0U, FMT_DIV1, FMT_DIV2
- , FMT_DIV3, FMT_DIV4S, FMT_LSL, FMT_LSLI
- , FMT_LDI8, FMT_LDI20, FMT_LDI32, FMT_LD
- , FMT_LDUH, FMT_LDUB, FMT_LDR13, FMT_LDR13UH
- , FMT_LDR13UB, FMT_LDR14, FMT_LDR14UH, FMT_LDR14UB
- , FMT_LDR15, FMT_LDR15GR, FMT_LDR15DR, FMT_LDR15PS
- , FMT_ST, FMT_STH, FMT_STB, FMT_STR13
- , FMT_STR13H, FMT_STR13B, FMT_STR14, FMT_STR14H
- , FMT_STR14B, FMT_STR15, FMT_STR15GR, FMT_STR15DR
- , FMT_STR15PS, FMT_MOV, FMT_MOVDR, FMT_MOVPS
- , FMT_MOV2DR, FMT_MOV2PS, FMT_JMP, FMT_CALLR
- , FMT_CALL, FMT_RET, FMT_INT, FMT_INTE
- , FMT_RETI, FMT_BRAD, FMT_BNOD, FMT_BEQD
- , FMT_BCD, FMT_BND, FMT_BVD, FMT_BLTD
- , FMT_BLED, FMT_BLSD, FMT_DMOVR13, FMT_DMOVR13H
- , FMT_DMOVR13B, FMT_DMOVR13PI, FMT_DMOVR13PIH, FMT_DMOVR13PIB
- , FMT_DMOVR15PI, FMT_DMOV2R13, FMT_DMOV2R13H, FMT_DMOV2R13B
- , FMT_DMOV2R13PI, FMT_DMOV2R13PIH, FMT_DMOV2R13PIB, FMT_DMOV2R15PD
- , FMT_LDRES, FMT_COPOP, FMT_COPLD, FMT_COPST
- , FMT_NOP, FMT_ANDCCR, FMT_STILM, FMT_ADDSP
- , FMT_EXTSB, FMT_EXTUB, FMT_EXTSH, FMT_EXTUH
- , FMT_LDM0, FMT_LDM1, FMT_STM0, FMT_STM1
- , FMT_ENTER, FMT_LEAVE, FMT_XCHB
-} SFMT;
-
-/* The decoder uses this to record insns and direct extraction handling.  */
-
-typedef struct {
-  const IDESC *idesc;
-#ifdef __GNUC__
-  void *sfmt;
-#else
-  enum sfmt sfmt;
-#endif
-} DECODE_DESC;
-
-/* Macro to go from decode phase to extraction phase.  */
-
-#ifdef __GNUC__
-#define GOTO_EXTRACT(id) goto *(id)->sfmt
-#else
-#define GOTO_EXTRACT(id) goto extract
-#endif
-
-/* The decoder needs a slightly different computed goto switch control.  */
-#ifdef __GNUC__
-#define DECODE_SWITCH(N, X) goto *labels_##N[X];
-#else
-#define DECODE_SWITCH(N, X) switch (X)
-#endif
-
 /* Given an instruction, return a pointer to its IDESC entry.  */
 
 const IDESC *
@@ -367,309 +312,342 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
               CGEN_INSN_INT base_insn,
               ARGBUF *abuf)
 {
-  /* Result of decoder, used by extractor.  */
-  const DECODE_DESC *idecode;
-
-  /* First decode the instruction.  */
+  /* Result of decoder.  */
+  FR30BF_INSN_TYPE itype;
 
   {
-#define I(insn) & fr30bf_insn_data[CONCAT2 (FR30BF_,insn)]
-#ifdef __GNUC__
-#define E(fmt) && case_ex_##fmt
-#else
-#define E(fmt) fmt
-#endif
-    CGEN_INSN_INT insn = base_insn;
-    static const DECODE_DESC idecode_invalid = { I (INSN_X_INVALID), E (FMT_EMPTY) };
-
-    {
-#ifdef __GNUC__
-      static const void *labels_0[256] = {
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && case_0_7, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && case_0_23, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && case_0_151, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && case_0_159, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-      };
-#endif
-      static const DECODE_DESC insns[256] = {
-        { I (INSN_LDR13), E (FMT_LDR13) }, { I (INSN_LDR13UH), E (FMT_LDR13UH) }, 
-        { I (INSN_LDR13UB), E (FMT_LDR13UB) }, { I (INSN_LDR15), E (FMT_LDR15) }, 
-        { I (INSN_LD), E (FMT_LD) }, { I (INSN_LDUH), E (FMT_LDUH) }, 
-        { I (INSN_LDUB), E (FMT_LDUB) }, { 0 }, 
-        { I (INSN_DMOV2R13), E (FMT_DMOV2R13) }, { I (INSN_DMOV2R13H), E (FMT_DMOV2R13H) }, 
-        { I (INSN_DMOV2R13B), E (FMT_DMOV2R13B) }, { I (INSN_DMOV2R15PD), E (FMT_DMOV2R15PD) }, 
-        { I (INSN_DMOV2R13PI), E (FMT_DMOV2R13PI) }, { I (INSN_DMOV2R13PIH), E (FMT_DMOV2R13PIH) }, 
-        { I (INSN_DMOV2R13PIB), E (FMT_DMOV2R13PIB) }, { I (INSN_ENTER), E (FMT_ENTER) }, 
-        { I (INSN_STR13), E (FMT_STR13) }, { I (INSN_STR13H), E (FMT_STR13H) }, 
-        { I (INSN_STR13B), E (FMT_STR13B) }, { I (INSN_STR15), E (FMT_STR15) }, 
-        { I (INSN_ST), E (FMT_ST) }, { I (INSN_STH), E (FMT_STH) }, 
-        { I (INSN_STB), E (FMT_STB) }, { 0 }, 
-        { I (INSN_DMOVR13), E (FMT_DMOVR13) }, { I (INSN_DMOVR13H), E (FMT_DMOVR13H) }, 
-        { I (INSN_DMOVR13B), E (FMT_DMOVR13B) }, { I (INSN_DMOVR15PI), E (FMT_DMOVR15PI) }, 
-        { I (INSN_DMOVR13PI), E (FMT_DMOVR13PI) }, { I (INSN_DMOVR13PIH), E (FMT_DMOVR13PIH) }, 
-        { I (INSN_DMOVR13PIB), E (FMT_DMOVR13PIB) }, { I (INSN_INT), E (FMT_INT) }, 
-        { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) }, 
-        { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) }, 
-        { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) }, 
-        { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) }, 
-        { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) }, 
-        { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) }, 
-        { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) }, 
-        { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) }, 
-        { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) }, 
-        { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) }, 
-        { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) }, 
-        { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) }, 
-        { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) }, 
-        { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) }, 
-        { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) }, 
-        { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) }, 
-        { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) }, 
-        { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) }, 
-        { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) }, 
-        { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) }, 
-        { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) }, 
-        { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) }, 
-        { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) }, 
-        { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) }, 
-        { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) }, 
-        { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) }, 
-        { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) }, 
-        { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) }, 
-        { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) }, 
-        { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) }, 
-        { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) }, 
-        { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) }, 
-        { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) }, 
-        { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) }, 
-        { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) }, 
-        { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) }, 
-        { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) }, 
-        { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) }, 
-        { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) }, 
-        { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) }, 
-        { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) }, 
-        { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) }, 
-        { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) }, 
-        { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) }, 
-        { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) }, 
-        { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) }, 
-        { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) }, 
-        { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) }, 
-        { I (INSN_BANDL), E (FMT_BANDL) }, { I (INSN_BANDH), E (FMT_BANDL) }, 
-        { I (INSN_AND), E (FMT_AND) }, { I (INSN_ANDCCR), E (FMT_ANDCCR) }, 
-        { I (INSN_ANDM), E (FMT_ANDM) }, { I (INSN_ANDH), E (FMT_ANDH) }, 
-        { I (INSN_ANDB), E (FMT_ANDB) }, { I (INSN_STILM), E (FMT_STILM) }, 
-        { I (INSN_BTSTL), E (FMT_BTSTL) }, { I (INSN_BTSTH), E (FMT_BTSTL) }, 
-        { I (INSN_XCHB), E (FMT_XCHB) }, { I (INSN_MOV), E (FMT_MOV) }, 
-        { I (INSN_LDM0), E (FMT_LDM0) }, { I (INSN_LDM1), E (FMT_LDM1) }, 
-        { I (INSN_STM0), E (FMT_STM0) }, { I (INSN_STM1), E (FMT_STM1) }, 
-        { I (INSN_BORL), E (FMT_BANDL) }, { I (INSN_BORH), E (FMT_BANDL) }, 
-        { I (INSN_OR), E (FMT_AND) }, { I (INSN_ORCCR), E (FMT_ANDCCR) }, 
-        { I (INSN_ORM), E (FMT_ANDM) }, { I (INSN_ORH), E (FMT_ANDH) }, 
-        { I (INSN_ORB), E (FMT_ANDB) }, { 0 }, 
-        { I (INSN_BEORL), E (FMT_BANDL) }, { I (INSN_BEORH), E (FMT_BANDL) }, 
-        { I (INSN_EOR), E (FMT_AND) }, { I (INSN_LDI20), E (FMT_LDI20) }, 
-        { I (INSN_EORM), E (FMT_ANDM) }, { I (INSN_EORH), E (FMT_ANDH) }, 
-        { I (INSN_EORB), E (FMT_ANDB) }, { 0 }, 
-        { I (INSN_ADDNI), E (FMT_ADDNI) }, { I (INSN_ADDN2), E (FMT_ADDN2) }, 
-        { I (INSN_ADDN), E (FMT_ADDN) }, { I (INSN_ADDSP), E (FMT_ADDSP) }, 
-        { I (INSN_ADDI), E (FMT_ADDI) }, { I (INSN_ADD2), E (FMT_ADD2) }, 
-        { I (INSN_ADD), E (FMT_ADD) }, { I (INSN_ADDC), E (FMT_ADDC) }, 
-        { I (INSN_CMPI), E (FMT_CMPI) }, { I (INSN_CMP2), E (FMT_CMP2) }, 
-        { I (INSN_CMP), E (FMT_CMP) }, { I (INSN_MULU), E (FMT_MULU) }, 
-        { I (INSN_SUB), E (FMT_ADD) }, { I (INSN_SUBC), E (FMT_ADDC) }, 
-        { I (INSN_SUBN), E (FMT_ADDN) }, { I (INSN_MUL), E (FMT_MUL) }, 
-        { I (INSN_LSRI), E (FMT_LSLI) }, { I (INSN_LSR2), E (FMT_LSLI) }, 
-        { I (INSN_LSR), E (FMT_LSL) }, { I (INSN_MOV2DR), E (FMT_MOV2DR) }, 
-        { I (INSN_LSLI), E (FMT_LSLI) }, { I (INSN_LSL2), E (FMT_LSLI) }, 
-        { I (INSN_LSL), E (FMT_LSL) }, { I (INSN_MOVDR), E (FMT_MOVDR) }, 
-        { I (INSN_ASRI), E (FMT_LSLI) }, { I (INSN_ASR2), E (FMT_LSLI) }, 
-        { I (INSN_ASR), E (FMT_LSL) }, { I (INSN_MULUH), E (FMT_MULH) }, 
-        { I (INSN_LDRES), E (FMT_LDRES) }, { I (INSN_STRES), E (FMT_LDRES) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_MULH), E (FMT_MULH) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_CALL), E (FMT_CALL) }, { I (INSN_CALL), E (FMT_CALL) }, 
-        { I (INSN_CALL), E (FMT_CALL) }, { I (INSN_CALL), E (FMT_CALL) }, 
-        { I (INSN_CALL), E (FMT_CALL) }, { I (INSN_CALL), E (FMT_CALL) }, 
-        { I (INSN_CALL), E (FMT_CALL) }, { I (INSN_CALL), E (FMT_CALL) }, 
-        { I (INSN_CALLD), E (FMT_CALL) }, { I (INSN_CALLD), E (FMT_CALL) }, 
-        { I (INSN_CALLD), E (FMT_CALL) }, { I (INSN_CALLD), E (FMT_CALL) }, 
-        { I (INSN_CALLD), E (FMT_CALL) }, { I (INSN_CALLD), E (FMT_CALL) }, 
-        { I (INSN_CALLD), E (FMT_CALL) }, { I (INSN_CALLD), E (FMT_CALL) }, 
-        { I (INSN_BRA), E (FMT_BRAD) }, { I (INSN_BNO), E (FMT_BNOD) }, 
-        { I (INSN_BEQ), E (FMT_BEQD) }, { I (INSN_BNE), E (FMT_BEQD) }, 
-        { I (INSN_BC), E (FMT_BCD) }, { I (INSN_BNC), E (FMT_BCD) }, 
-        { I (INSN_BN), E (FMT_BND) }, { I (INSN_BP), E (FMT_BND) }, 
-        { I (INSN_BV), E (FMT_BVD) }, { I (INSN_BNV), E (FMT_BVD) }, 
-        { I (INSN_BLT), E (FMT_BLTD) }, { I (INSN_BGE), E (FMT_BLTD) }, 
-        { I (INSN_BLE), E (FMT_BLED) }, { I (INSN_BGT), E (FMT_BLED) }, 
-        { I (INSN_BLS), E (FMT_BLSD) }, { I (INSN_BHI), E (FMT_BLSD) }, 
-        { I (INSN_BRAD), E (FMT_BRAD) }, { I (INSN_BNOD), E (FMT_BNOD) }, 
-        { I (INSN_BEQD), E (FMT_BEQD) }, { I (INSN_BNED), E (FMT_BEQD) }, 
-        { I (INSN_BCD), E (FMT_BCD) }, { I (INSN_BNCD), E (FMT_BCD) }, 
-        { I (INSN_BND), E (FMT_BND) }, { I (INSN_BPD), E (FMT_BND) }, 
-        { I (INSN_BVD), E (FMT_BVD) }, { I (INSN_BNVD), E (FMT_BVD) }, 
-        { I (INSN_BLTD), E (FMT_BLTD) }, { I (INSN_BGED), E (FMT_BLTD) }, 
-        { I (INSN_BLED), E (FMT_BLED) }, { I (INSN_BGTD), E (FMT_BLED) }, 
-        { I (INSN_BLSD), E (FMT_BLSD) }, { I (INSN_BHID), E (FMT_BLSD) }, 
-      };
-      unsigned int val;
-      val = (((insn >> 8) & (255 << 0)));
-      DECODE_SWITCH (0, val)
+    CGEN_INSN_INT insn = base_insn;
+
+    {
+      unsigned int val = (((insn >> 8) & (255 << 0)));
+      switch (val)
+      {
+      case 0 : itype = FR30BF_INSN_LDR13; goto extract_fmt_ldr13;
+      case 1 : itype = FR30BF_INSN_LDR13UH; goto extract_fmt_ldr13uh;
+      case 2 : itype = FR30BF_INSN_LDR13UB; goto extract_fmt_ldr13ub;
+      case 3 : itype = FR30BF_INSN_LDR15; goto extract_fmt_ldr15;
+      case 4 : itype = FR30BF_INSN_LD; goto extract_fmt_ld;
+      case 5 : itype = FR30BF_INSN_LDUH; goto extract_fmt_lduh;
+      case 6 : itype = FR30BF_INSN_LDUB; goto extract_fmt_ldub;
+      case 7 :
         {
-        CASE (0, 7) :
+          unsigned int val = (((insn >> 4) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_LDR15GR), E (FMT_LDR15GR) }, { I (INSN_MOV2PS), E (FMT_MOV2PS) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_LDR15DR), E (FMT_LDR15DR) }, { I (INSN_LDR15PS), E (FMT_LDR15PS) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 4) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = FR30BF_INSN_LDR15GR; goto extract_fmt_ldr15gr;
+          case 1 : itype = FR30BF_INSN_MOV2PS; goto extract_fmt_mov2ps;
+          case 8 : itype = FR30BF_INSN_LDR15DR; goto extract_fmt_ldr15dr;
+          case 9 : itype = FR30BF_INSN_LDR15PS; goto extract_fmt_ldr15ps;
+          default : itype = FR30BF_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 23) :
+        }
+      case 8 : itype = FR30BF_INSN_DMOV2R13; goto extract_fmt_dmov2r13;
+      case 9 : itype = FR30BF_INSN_DMOV2R13H; goto extract_fmt_dmov2r13h;
+      case 10 : itype = FR30BF_INSN_DMOV2R13B; goto extract_fmt_dmov2r13b;
+      case 11 : itype = FR30BF_INSN_DMOV2R15PD; goto extract_fmt_dmov2r15pd;
+      case 12 : itype = FR30BF_INSN_DMOV2R13PI; goto extract_fmt_dmov2r13pi;
+      case 13 : itype = FR30BF_INSN_DMOV2R13PIH; goto extract_fmt_dmov2r13pih;
+      case 14 : itype = FR30BF_INSN_DMOV2R13PIB; goto extract_fmt_dmov2r13pib;
+      case 15 : itype = FR30BF_INSN_ENTER; goto extract_fmt_enter;
+      case 16 : itype = FR30BF_INSN_STR13; goto extract_fmt_str13;
+      case 17 : itype = FR30BF_INSN_STR13H; goto extract_fmt_str13h;
+      case 18 : itype = FR30BF_INSN_STR13B; goto extract_fmt_str13b;
+      case 19 : itype = FR30BF_INSN_STR15; goto extract_fmt_str15;
+      case 20 : itype = FR30BF_INSN_ST; goto extract_fmt_st;
+      case 21 : itype = FR30BF_INSN_STH; goto extract_fmt_sth;
+      case 22 : itype = FR30BF_INSN_STB; goto extract_fmt_stb;
+      case 23 :
+        {
+          unsigned int val = (((insn >> 4) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_STR15GR), E (FMT_STR15GR) }, { I (INSN_MOVPS), E (FMT_MOVPS) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_STR15DR), E (FMT_STR15DR) }, { I (INSN_STR15PS), E (FMT_STR15PS) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 4) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = FR30BF_INSN_STR15GR; goto extract_fmt_str15gr;
+          case 1 : itype = FR30BF_INSN_MOVPS; goto extract_fmt_movps;
+          case 8 : itype = FR30BF_INSN_STR15DR; goto extract_fmt_str15dr;
+          case 9 : itype = FR30BF_INSN_STR15PS; goto extract_fmt_str15ps;
+          default : itype = FR30BF_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 151) :
+        }
+      case 24 : itype = FR30BF_INSN_DMOVR13; goto extract_fmt_dmovr13;
+      case 25 : itype = FR30BF_INSN_DMOVR13H; goto extract_fmt_dmovr13h;
+      case 26 : itype = FR30BF_INSN_DMOVR13B; goto extract_fmt_dmovr13b;
+      case 27 : itype = FR30BF_INSN_DMOVR15PI; goto extract_fmt_dmovr15pi;
+      case 28 : itype = FR30BF_INSN_DMOVR13PI; goto extract_fmt_dmovr13pi;
+      case 29 : itype = FR30BF_INSN_DMOVR13PIH; goto extract_fmt_dmovr13pih;
+      case 30 : itype = FR30BF_INSN_DMOVR13PIB; goto extract_fmt_dmovr13pib;
+      case 31 : itype = FR30BF_INSN_INT; goto extract_fmt_int;
+      case 32 : /* fall through */
+      case 33 : /* fall through */
+      case 34 : /* fall through */
+      case 35 : /* fall through */
+      case 36 : /* fall through */
+      case 37 : /* fall through */
+      case 38 : /* fall through */
+      case 39 : /* fall through */
+      case 40 : /* fall through */
+      case 41 : /* fall through */
+      case 42 : /* fall through */
+      case 43 : /* fall through */
+      case 44 : /* fall through */
+      case 45 : /* fall through */
+      case 46 : /* fall through */
+      case 47 : itype = FR30BF_INSN_LDR14; goto extract_fmt_ldr14;
+      case 48 : /* fall through */
+      case 49 : /* fall through */
+      case 50 : /* fall through */
+      case 51 : /* fall through */
+      case 52 : /* fall through */
+      case 53 : /* fall through */
+      case 54 : /* fall through */
+      case 55 : /* fall through */
+      case 56 : /* fall through */
+      case 57 : /* fall through */
+      case 58 : /* fall through */
+      case 59 : /* fall through */
+      case 60 : /* fall through */
+      case 61 : /* fall through */
+      case 62 : /* fall through */
+      case 63 : itype = FR30BF_INSN_STR14; goto extract_fmt_str14;
+      case 64 : /* fall through */
+      case 65 : /* fall through */
+      case 66 : /* fall through */
+      case 67 : /* fall through */
+      case 68 : /* fall through */
+      case 69 : /* fall through */
+      case 70 : /* fall through */
+      case 71 : /* fall through */
+      case 72 : /* fall through */
+      case 73 : /* fall through */
+      case 74 : /* fall through */
+      case 75 : /* fall through */
+      case 76 : /* fall through */
+      case 77 : /* fall through */
+      case 78 : /* fall through */
+      case 79 : itype = FR30BF_INSN_LDR14UH; goto extract_fmt_ldr14uh;
+      case 80 : /* fall through */
+      case 81 : /* fall through */
+      case 82 : /* fall through */
+      case 83 : /* fall through */
+      case 84 : /* fall through */
+      case 85 : /* fall through */
+      case 86 : /* fall through */
+      case 87 : /* fall through */
+      case 88 : /* fall through */
+      case 89 : /* fall through */
+      case 90 : /* fall through */
+      case 91 : /* fall through */
+      case 92 : /* fall through */
+      case 93 : /* fall through */
+      case 94 : /* fall through */
+      case 95 : itype = FR30BF_INSN_STR14H; goto extract_fmt_str14h;
+      case 96 : /* fall through */
+      case 97 : /* fall through */
+      case 98 : /* fall through */
+      case 99 : /* fall through */
+      case 100 : /* fall through */
+      case 101 : /* fall through */
+      case 102 : /* fall through */
+      case 103 : /* fall through */
+      case 104 : /* fall through */
+      case 105 : /* fall through */
+      case 106 : /* fall through */
+      case 107 : /* fall through */
+      case 108 : /* fall through */
+      case 109 : /* fall through */
+      case 110 : /* fall through */
+      case 111 : itype = FR30BF_INSN_LDR14UB; goto extract_fmt_ldr14ub;
+      case 112 : /* fall through */
+      case 113 : /* fall through */
+      case 114 : /* fall through */
+      case 115 : /* fall through */
+      case 116 : /* fall through */
+      case 117 : /* fall through */
+      case 118 : /* fall through */
+      case 119 : /* fall through */
+      case 120 : /* fall through */
+      case 121 : /* fall through */
+      case 122 : /* fall through */
+      case 123 : /* fall through */
+      case 124 : /* fall through */
+      case 125 : /* fall through */
+      case 126 : /* fall through */
+      case 127 : itype = FR30BF_INSN_STR14B; goto extract_fmt_str14b;
+      case 128 : itype = FR30BF_INSN_BANDL; goto extract_fmt_bandl;
+      case 129 : itype = FR30BF_INSN_BANDH; goto extract_fmt_bandl;
+      case 130 : itype = FR30BF_INSN_AND; goto extract_fmt_and;
+      case 131 : itype = FR30BF_INSN_ANDCCR; goto extract_fmt_andccr;
+      case 132 : itype = FR30BF_INSN_ANDM; goto extract_fmt_andm;
+      case 133 : itype = FR30BF_INSN_ANDH; goto extract_fmt_andh;
+      case 134 : itype = FR30BF_INSN_ANDB; goto extract_fmt_andb;
+      case 135 : itype = FR30BF_INSN_STILM; goto extract_fmt_stilm;
+      case 136 : itype = FR30BF_INSN_BTSTL; goto extract_fmt_btstl;
+      case 137 : itype = FR30BF_INSN_BTSTH; goto extract_fmt_btstl;
+      case 138 : itype = FR30BF_INSN_XCHB; goto extract_fmt_xchb;
+      case 139 : itype = FR30BF_INSN_MOV; goto extract_fmt_mov;
+      case 140 : itype = FR30BF_INSN_LDM0; goto extract_fmt_ldm0;
+      case 141 : itype = FR30BF_INSN_LDM1; goto extract_fmt_ldm1;
+      case 142 : itype = FR30BF_INSN_STM0; goto extract_fmt_stm0;
+      case 143 : itype = FR30BF_INSN_STM1; goto extract_fmt_stm1;
+      case 144 : itype = FR30BF_INSN_BORL; goto extract_fmt_bandl;
+      case 145 : itype = FR30BF_INSN_BORH; goto extract_fmt_bandl;
+      case 146 : itype = FR30BF_INSN_OR; goto extract_fmt_and;
+      case 147 : itype = FR30BF_INSN_ORCCR; goto extract_fmt_andccr;
+      case 148 : itype = FR30BF_INSN_ORM; goto extract_fmt_andm;
+      case 149 : itype = FR30BF_INSN_ORH; goto extract_fmt_andh;
+      case 150 : itype = FR30BF_INSN_ORB; goto extract_fmt_andb;
+      case 151 :
+        {
+          unsigned int val = (((insn >> 4) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_JMP), E (FMT_JMP) }, { I (INSN_CALLR), E (FMT_CALLR) }, 
-              { I (INSN_RET), E (FMT_RET) }, { I (INSN_RETI), E (FMT_RETI) }, 
-              { I (INSN_DIV0S), E (FMT_DIV0S) }, { I (INSN_DIV0U), E (FMT_DIV0U) }, 
-              { I (INSN_DIV1), E (FMT_DIV1) }, { I (INSN_DIV2), E (FMT_DIV2) }, 
-              { I (INSN_EXTSB), E (FMT_EXTSB) }, { I (INSN_EXTUB), E (FMT_EXTUB) }, 
-              { I (INSN_EXTSH), E (FMT_EXTSH) }, { I (INSN_EXTUH), E (FMT_EXTUH) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 4) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = FR30BF_INSN_JMP; goto extract_fmt_jmp;
+          case 1 : itype = FR30BF_INSN_CALLR; goto extract_fmt_callr;
+          case 2 : itype = FR30BF_INSN_RET; goto extract_fmt_ret;
+          case 3 : itype = FR30BF_INSN_RETI; goto extract_fmt_reti;
+          case 4 : itype = FR30BF_INSN_DIV0S; goto extract_fmt_div0s;
+          case 5 : itype = FR30BF_INSN_DIV0U; goto extract_fmt_div0u;
+          case 6 : itype = FR30BF_INSN_DIV1; goto extract_fmt_div1;
+          case 7 : itype = FR30BF_INSN_DIV2; goto extract_fmt_div2;
+          case 8 : itype = FR30BF_INSN_EXTSB; goto extract_fmt_extsb;
+          case 9 : itype = FR30BF_INSN_EXTUB; goto extract_fmt_extub;
+          case 10 : itype = FR30BF_INSN_EXTSH; goto extract_fmt_extsh;
+          case 11 : itype = FR30BF_INSN_EXTUH; goto extract_fmt_extuh;
+          default : itype = FR30BF_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 159) :
+        }
+      case 152 : itype = FR30BF_INSN_BEORL; goto extract_fmt_bandl;
+      case 153 : itype = FR30BF_INSN_BEORH; goto extract_fmt_bandl;
+      case 154 : itype = FR30BF_INSN_EOR; goto extract_fmt_and;
+      case 155 : itype = FR30BF_INSN_LDI20; goto extract_fmt_ldi20;
+      case 156 : itype = FR30BF_INSN_EORM; goto extract_fmt_andm;
+      case 157 : itype = FR30BF_INSN_EORH; goto extract_fmt_andh;
+      case 158 : itype = FR30BF_INSN_EORB; goto extract_fmt_andb;
+      case 159 :
+        {
+          unsigned int val = (((insn >> 4) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_JMPD), E (FMT_JMP) }, { I (INSN_CALLRD), E (FMT_CALLR) }, 
-              { I (INSN_RET_D), E (FMT_RET) }, { I (INSN_INTE), E (FMT_INTE) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_DIV3), E (FMT_DIV3) }, { I (INSN_DIV4S), E (FMT_DIV4S) }, 
-              { I (INSN_LDI32), E (FMT_LDI32) }, { I (INSN_LEAVE), E (FMT_LEAVE) }, 
-              { I (INSN_NOP), E (FMT_NOP) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_COPOP), E (FMT_COPOP) }, { I (INSN_COPLD), E (FMT_COPLD) }, 
-              { I (INSN_COPST), E (FMT_COPST) }, { I (INSN_COPSV), E (FMT_COPST) }, 
-            };
-            unsigned int val = (((insn >> 4) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = FR30BF_INSN_JMPD; goto extract_fmt_jmp;
+          case 1 : itype = FR30BF_INSN_CALLRD; goto extract_fmt_callr;
+          case 2 : itype = FR30BF_INSN_RET_D; goto extract_fmt_ret;
+          case 3 : itype = FR30BF_INSN_INTE; goto extract_fmt_inte;
+          case 6 : itype = FR30BF_INSN_DIV3; goto extract_fmt_div3;
+          case 7 : itype = FR30BF_INSN_DIV4S; goto extract_fmt_div4s;
+          case 8 : itype = FR30BF_INSN_LDI32; goto extract_fmt_ldi32;
+          case 9 : itype = FR30BF_INSN_LEAVE; goto extract_fmt_leave;
+          case 10 : itype = FR30BF_INSN_NOP; goto extract_fmt_nop;
+          case 12 : itype = FR30BF_INSN_COPOP; goto extract_fmt_copop;
+          case 13 : itype = FR30BF_INSN_COPLD; goto extract_fmt_copld;
+          case 14 : itype = FR30BF_INSN_COPST; goto extract_fmt_copst;
+          case 15 : itype = FR30BF_INSN_COPSV; goto extract_fmt_copst;
+          default : itype = FR30BF_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        DEFAULT (0) :
-          idecode = &insns[val];
-          GOTO_EXTRACT (idecode);
         }
-      ENDSWITCH (0)
+      case 160 : itype = FR30BF_INSN_ADDNI; goto extract_fmt_addni;
+      case 161 : itype = FR30BF_INSN_ADDN2; goto extract_fmt_addn2;
+      case 162 : itype = FR30BF_INSN_ADDN; goto extract_fmt_addn;
+      case 163 : itype = FR30BF_INSN_ADDSP; goto extract_fmt_addsp;
+      case 164 : itype = FR30BF_INSN_ADDI; goto extract_fmt_addi;
+      case 165 : itype = FR30BF_INSN_ADD2; goto extract_fmt_add2;
+      case 166 : itype = FR30BF_INSN_ADD; goto extract_fmt_add;
+      case 167 : itype = FR30BF_INSN_ADDC; goto extract_fmt_addc;
+      case 168 : itype = FR30BF_INSN_CMPI; goto extract_fmt_cmpi;
+      case 169 : itype = FR30BF_INSN_CMP2; goto extract_fmt_cmp2;
+      case 170 : itype = FR30BF_INSN_CMP; goto extract_fmt_cmp;
+      case 171 : itype = FR30BF_INSN_MULU; goto extract_fmt_mulu;
+      case 172 : itype = FR30BF_INSN_SUB; goto extract_fmt_add;
+      case 173 : itype = FR30BF_INSN_SUBC; goto extract_fmt_addc;
+      case 174 : itype = FR30BF_INSN_SUBN; goto extract_fmt_addn;
+      case 175 : itype = FR30BF_INSN_MUL; goto extract_fmt_mul;
+      case 176 : itype = FR30BF_INSN_LSRI; goto extract_fmt_lsli;
+      case 177 : itype = FR30BF_INSN_LSR2; goto extract_fmt_lsli;
+      case 178 : itype = FR30BF_INSN_LSR; goto extract_fmt_lsl;
+      case 179 : itype = FR30BF_INSN_MOV2DR; goto extract_fmt_mov2dr;
+      case 180 : itype = FR30BF_INSN_LSLI; goto extract_fmt_lsli;
+      case 181 : itype = FR30BF_INSN_LSL2; goto extract_fmt_lsli;
+      case 182 : itype = FR30BF_INSN_LSL; goto extract_fmt_lsl;
+      case 183 : itype = FR30BF_INSN_MOVDR; goto extract_fmt_movdr;
+      case 184 : itype = FR30BF_INSN_ASRI; goto extract_fmt_lsli;
+      case 185 : itype = FR30BF_INSN_ASR2; goto extract_fmt_lsli;
+      case 186 : itype = FR30BF_INSN_ASR; goto extract_fmt_lsl;
+      case 187 : itype = FR30BF_INSN_MULUH; goto extract_fmt_mulh;
+      case 188 : itype = FR30BF_INSN_LDRES; goto extract_fmt_ldres;
+      case 189 : itype = FR30BF_INSN_STRES; goto extract_fmt_ldres;
+      case 191 : itype = FR30BF_INSN_MULH; goto extract_fmt_mulh;
+      case 192 : /* fall through */
+      case 193 : /* fall through */
+      case 194 : /* fall through */
+      case 195 : /* fall through */
+      case 196 : /* fall through */
+      case 197 : /* fall through */
+      case 198 : /* fall through */
+      case 199 : /* fall through */
+      case 200 : /* fall through */
+      case 201 : /* fall through */
+      case 202 : /* fall through */
+      case 203 : /* fall through */
+      case 204 : /* fall through */
+      case 205 : /* fall through */
+      case 206 : /* fall through */
+      case 207 : itype = FR30BF_INSN_LDI8; goto extract_fmt_ldi8;
+      case 208 : /* fall through */
+      case 209 : /* fall through */
+      case 210 : /* fall through */
+      case 211 : /* fall through */
+      case 212 : /* fall through */
+      case 213 : /* fall through */
+      case 214 : /* fall through */
+      case 215 : itype = FR30BF_INSN_CALL; goto extract_fmt_call;
+      case 216 : /* fall through */
+      case 217 : /* fall through */
+      case 218 : /* fall through */
+      case 219 : /* fall through */
+      case 220 : /* fall through */
+      case 221 : /* fall through */
+      case 222 : /* fall through */
+      case 223 : itype = FR30BF_INSN_CALLD; goto extract_fmt_call;
+      case 224 : itype = FR30BF_INSN_BRA; goto extract_fmt_brad;
+      case 225 : itype = FR30BF_INSN_BNO; goto extract_fmt_bnod;
+      case 226 : itype = FR30BF_INSN_BEQ; goto extract_fmt_beqd;
+      case 227 : itype = FR30BF_INSN_BNE; goto extract_fmt_beqd;
+      case 228 : itype = FR30BF_INSN_BC; goto extract_fmt_bcd;
+      case 229 : itype = FR30BF_INSN_BNC; goto extract_fmt_bcd;
+      case 230 : itype = FR30BF_INSN_BN; goto extract_fmt_bnd;
+      case 231 : itype = FR30BF_INSN_BP; goto extract_fmt_bnd;
+      case 232 : itype = FR30BF_INSN_BV; goto extract_fmt_bvd;
+      case 233 : itype = FR30BF_INSN_BNV; goto extract_fmt_bvd;
+      case 234 : itype = FR30BF_INSN_BLT; goto extract_fmt_bltd;
+      case 235 : itype = FR30BF_INSN_BGE; goto extract_fmt_bltd;
+      case 236 : itype = FR30BF_INSN_BLE; goto extract_fmt_bled;
+      case 237 : itype = FR30BF_INSN_BGT; goto extract_fmt_bled;
+      case 238 : itype = FR30BF_INSN_BLS; goto extract_fmt_blsd;
+      case 239 : itype = FR30BF_INSN_BHI; goto extract_fmt_blsd;
+      case 240 : itype = FR30BF_INSN_BRAD; goto extract_fmt_brad;
+      case 241 : itype = FR30BF_INSN_BNOD; goto extract_fmt_bnod;
+      case 242 : itype = FR30BF_INSN_BEQD; goto extract_fmt_beqd;
+      case 243 : itype = FR30BF_INSN_BNED; goto extract_fmt_beqd;
+      case 244 : itype = FR30BF_INSN_BCD; goto extract_fmt_bcd;
+      case 245 : itype = FR30BF_INSN_BNCD; goto extract_fmt_bcd;
+      case 246 : itype = FR30BF_INSN_BND; goto extract_fmt_bnd;
+      case 247 : itype = FR30BF_INSN_BPD; goto extract_fmt_bnd;
+      case 248 : itype = FR30BF_INSN_BVD; goto extract_fmt_bvd;
+      case 249 : itype = FR30BF_INSN_BNVD; goto extract_fmt_bvd;
+      case 250 : itype = FR30BF_INSN_BLTD; goto extract_fmt_bltd;
+      case 251 : itype = FR30BF_INSN_BGED; goto extract_fmt_bltd;
+      case 252 : itype = FR30BF_INSN_BLED; goto extract_fmt_bled;
+      case 253 : itype = FR30BF_INSN_BGTD; goto extract_fmt_bled;
+      case 254 : itype = FR30BF_INSN_BLSD; goto extract_fmt_blsd;
+      case 255 : itype = FR30BF_INSN_BHID; goto extract_fmt_blsd;
+      default : itype = FR30BF_INSN_X_INVALID; goto extract_fmt_empty;
+      }
     }
-#undef I
-#undef E
   }
 
   /* The instruction has been decoded, now extract the fields.  */
 
- extract:
-  {
-#ifndef __GNUC__
-    switch (idecode->sfmt)
-#endif
-      {
-
-  CASE (ex, FMT_EMPTY) :
+ extract_fmt_empty:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_empty.f
   EXTRACT_IFMT_EMPTY_VARS /* */
@@ -680,11 +658,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_empty", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADD) :
extract_fmt_add:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_add.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -706,11 +685,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADDI) :
extract_fmt_addi:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_addi.f
   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
@@ -731,11 +711,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADD2) :
extract_fmt_add2:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_add2.f
   EXTRACT_IFMT_ADD2_VARS /* f-op1 f-op2 f-m4 f-Ri */
@@ -756,11 +737,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADDC) :
extract_fmt_addc:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_addc.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -782,11 +764,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADDN) :
extract_fmt_addn:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_addn.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -808,11 +791,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADDNI) :
extract_fmt_addni:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_addni.f
   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
@@ -833,11 +817,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADDN2) :
extract_fmt_addn2:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_addn2.f
   EXTRACT_IFMT_ADD2_VARS /* f-op1 f-op2 f-m4 f-Ri */
@@ -858,11 +843,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMP) :
extract_fmt_cmp:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmp.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -883,11 +869,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPI) :
extract_fmt_cmpi:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmpi.f
   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
@@ -907,11 +894,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMP2) :
extract_fmt_cmp2:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmp2.f
   EXTRACT_IFMT_ADD2_VARS /* f-op1 f-op2 f-m4 f-Ri */
@@ -931,11 +919,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_AND) :
extract_fmt_and:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_and.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -957,11 +946,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ANDM) :
extract_fmt_andm:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_andm.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -982,11 +972,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ANDH) :
extract_fmt_andh:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_andh.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1007,11 +998,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ANDB) :
extract_fmt_andb:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_andb.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1032,11 +1024,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BANDL) :
extract_fmt_bandl:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_bandl.f
   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
@@ -1056,11 +1049,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BTSTL) :
extract_fmt_btstl:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_btstl.f
   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
@@ -1080,11 +1074,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MUL) :
extract_fmt_mul:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_mul.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1105,11 +1100,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MULU) :
extract_fmt_mulu:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_mulu.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1130,11 +1126,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MULH) :
extract_fmt_mulh:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_mulh.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1155,11 +1152,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DIV0S) :
extract_fmt_div0s:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_div0s.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -1178,11 +1176,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DIV0U) :
extract_fmt_div0u:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_div0u.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -1193,11 +1192,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_div0u", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DIV1) :
extract_fmt_div1:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_div1.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -1216,11 +1216,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DIV2) :
extract_fmt_div2:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_div2.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -1239,11 +1240,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DIV3) :
extract_fmt_div3:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_div3.f
   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
@@ -1254,11 +1256,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_div3", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DIV4S) :
extract_fmt_div4s:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_div4s.f
   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
@@ -1269,11 +1272,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_div4s", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LSL) :
extract_fmt_lsl:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lsl.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1295,11 +1299,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LSLI) :
extract_fmt_lsli:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lsli.f
   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
@@ -1320,11 +1325,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDI8) :
extract_fmt_ldi8:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldi8.f
   EXTRACT_IFMT_LDI8_VARS /* f-op1 f-i8 f-Ri */
@@ -1344,11 +1350,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDI20) :
extract_fmt_ldi20:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldi20.f
   EXTRACT_IFMT_LDI20_VARS /* f-op1 f-i20 f-op2 f-Ri */
@@ -1368,11 +1375,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDI32) :
extract_fmt_ldi32:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldi32.f
   EXTRACT_IFMT_LDI32_VARS /* f-op1 f-i32 f-op2 f-op3 f-Ri */
@@ -1392,11 +1400,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD) :
extract_fmt_ld:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ld.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1417,11 +1426,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDUH) :
extract_fmt_lduh:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lduh.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1442,11 +1452,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDUB) :
extract_fmt_ldub:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldub.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1467,11 +1478,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDR13) :
extract_fmt_ldr13:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldr13.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1493,11 +1505,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDR13UH) :
extract_fmt_ldr13uh:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldr13uh.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1519,11 +1532,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDR13UB) :
extract_fmt_ldr13ub:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldr13ub.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1545,11 +1559,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDR14) :
extract_fmt_ldr14:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldr14.f
   EXTRACT_IFMT_LDR14_VARS /* f-op1 f-disp10 f-Ri */
@@ -1570,11 +1585,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDR14UH) :
extract_fmt_ldr14uh:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldr14uh.f
   EXTRACT_IFMT_LDR14UH_VARS /* f-op1 f-disp9 f-Ri */
@@ -1595,11 +1611,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDR14UB) :
extract_fmt_ldr14ub:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldr14ub.f
   EXTRACT_IFMT_LDR14UB_VARS /* f-op1 f-disp8 f-Ri */
@@ -1620,11 +1637,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDR15) :
extract_fmt_ldr15:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldr15.f
   EXTRACT_IFMT_LDR15_VARS /* f-op1 f-op2 f-udisp6 f-Ri */
@@ -1645,11 +1663,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDR15GR) :
extract_fmt_ldr15gr:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldr15gr.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -1671,11 +1690,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDR15DR) :
extract_fmt_ldr15dr:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldr15dr.f
   EXTRACT_IFMT_LDR15DR_VARS /* f-op1 f-op2 f-op3 f-Rs2 */
@@ -1695,11 +1715,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDR15PS) :
extract_fmt_ldr15ps:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldr15ps.f
   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
@@ -1718,11 +1739,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST) :
extract_fmt_st:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_st.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1743,11 +1765,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STH) :
extract_fmt_sth:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_sth.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1768,11 +1791,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STB) :
extract_fmt_stb:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stb.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1793,11 +1817,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STR13) :
extract_fmt_str13:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_str13.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1819,11 +1844,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STR13H) :
extract_fmt_str13h:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_str13h.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1845,11 +1871,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STR13B) :
extract_fmt_str13b:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_str13b.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -1871,11 +1898,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STR14) :
extract_fmt_str14:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_str14.f
   EXTRACT_IFMT_LDR14_VARS /* f-op1 f-disp10 f-Ri */
@@ -1896,11 +1924,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STR14H) :
extract_fmt_str14h:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_str14h.f
   EXTRACT_IFMT_LDR14UH_VARS /* f-op1 f-disp9 f-Ri */
@@ -1921,11 +1950,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STR14B) :
extract_fmt_str14b:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_str14b.f
   EXTRACT_IFMT_LDR14UB_VARS /* f-op1 f-disp8 f-Ri */
@@ -1946,11 +1976,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STR15) :
extract_fmt_str15:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_str15.f
   EXTRACT_IFMT_LDR15_VARS /* f-op1 f-op2 f-udisp6 f-Ri */
@@ -1971,11 +2002,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STR15GR) :
extract_fmt_str15gr:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_str15gr.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -1996,11 +2028,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STR15DR) :
extract_fmt_str15dr:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_str15dr.f
   EXTRACT_IFMT_LDR15DR_VARS /* f-op1 f-op2 f-op3 f-Rs2 */
@@ -2020,11 +2053,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STR15PS) :
extract_fmt_str15ps:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_str15ps.f
   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
@@ -2043,11 +2077,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOV) :
extract_fmt_mov:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_mov.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -2068,11 +2103,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOVDR) :
extract_fmt_movdr:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_movdr.f
   EXTRACT_IFMT_MOVDR_VARS /* f-op1 f-op2 f-Rs1 f-Ri */
@@ -2092,11 +2128,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOVPS) :
extract_fmt_movps:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_movps.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -2115,11 +2152,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOV2DR) :
extract_fmt_mov2dr:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_mov2dr.f
   EXTRACT_IFMT_MOVDR_VARS /* f-op1 f-op2 f-Rs1 f-Ri */
@@ -2139,11 +2177,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOV2PS) :
extract_fmt_mov2ps:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_mov2ps.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -2162,11 +2201,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_JMP) :
extract_fmt_jmp:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_jmp.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -2186,11 +2226,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CALLR) :
extract_fmt_callr:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_callr.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -2210,11 +2251,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CALL) :
extract_fmt_call:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_call.f
   EXTRACT_IFMT_CALL_VARS /* f-op1 f-op5 f-rel12 */
@@ -2233,11 +2275,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_RET) :
extract_fmt_ret:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_ret.f
   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
@@ -2255,11 +2298,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_INT) :
extract_fmt_int:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_int.f
   EXTRACT_IFMT_INT_VARS /* f-op1 f-op2 f-u8 */
@@ -2278,11 +2322,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_INTE) :
extract_fmt_inte:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_inte.f
   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
@@ -2300,11 +2345,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_RETI) :
extract_fmt_reti:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_reti.f
   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
@@ -2322,11 +2368,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BRAD) :
extract_fmt_brad:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_brad.f
   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
@@ -2345,11 +2392,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BNOD) :
extract_fmt_bnod:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_bnod.f
   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
@@ -2360,11 +2408,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_bnod", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BEQD) :
extract_fmt_beqd:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_beqd.f
   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
@@ -2383,11 +2432,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BCD) :
extract_fmt_bcd:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bcd.f
   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
@@ -2406,11 +2456,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BND) :
extract_fmt_bnd:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bnd.f
   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
@@ -2429,11 +2480,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BVD) :
extract_fmt_bvd:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bvd.f
   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
@@ -2452,11 +2504,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BLTD) :
extract_fmt_bltd:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bltd.f
   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
@@ -2475,11 +2528,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BLED) :
extract_fmt_bled:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bled.f
   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
@@ -2498,11 +2552,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BLSD) :
extract_fmt_blsd:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_blsd.f
   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
@@ -2521,11 +2576,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOVR13) :
extract_fmt_dmovr13:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmovr13.f
   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
@@ -2544,11 +2600,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOVR13H) :
extract_fmt_dmovr13h:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmovr13h.f
   EXTRACT_IFMT_DMOVR13H_VARS /* f-op1 f-op2 f-dir9 */
@@ -2567,11 +2624,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOVR13B) :
extract_fmt_dmovr13b:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmovr13b.f
   EXTRACT_IFMT_DMOVR13B_VARS /* f-op1 f-op2 f-dir8 */
@@ -2590,11 +2648,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOVR13PI) :
extract_fmt_dmovr13pi:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmovr13pi.f
   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
@@ -2614,11 +2673,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOVR13PIH) :
extract_fmt_dmovr13pih:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmovr13pih.f
   EXTRACT_IFMT_DMOVR13H_VARS /* f-op1 f-op2 f-dir9 */
@@ -2638,11 +2698,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOVR13PIB) :
extract_fmt_dmovr13pib:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmovr13pib.f
   EXTRACT_IFMT_DMOVR13B_VARS /* f-op1 f-op2 f-dir8 */
@@ -2662,11 +2723,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOVR15PI) :
extract_fmt_dmovr15pi:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmovr15pi.f
   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
@@ -2686,11 +2748,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOV2R13) :
extract_fmt_dmov2r13:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmov2r13.f
   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
@@ -2709,11 +2772,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOV2R13H) :
extract_fmt_dmov2r13h:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmov2r13h.f
   EXTRACT_IFMT_DMOVR13H_VARS /* f-op1 f-op2 f-dir9 */
@@ -2732,11 +2796,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOV2R13B) :
extract_fmt_dmov2r13b:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmov2r13b.f
   EXTRACT_IFMT_DMOVR13B_VARS /* f-op1 f-op2 f-dir8 */
@@ -2755,11 +2820,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOV2R13PI) :
extract_fmt_dmov2r13pi:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmov2r13pi.f
   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
@@ -2779,11 +2845,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOV2R13PIH) :
extract_fmt_dmov2r13pih:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmov2r13pih.f
   EXTRACT_IFMT_DMOVR13H_VARS /* f-op1 f-op2 f-dir9 */
@@ -2803,11 +2870,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOV2R13PIB) :
extract_fmt_dmov2r13pib:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmov2r13pib.f
   EXTRACT_IFMT_DMOVR13B_VARS /* f-op1 f-op2 f-dir8 */
@@ -2827,11 +2895,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DMOV2R15PD) :
extract_fmt_dmov2r15pd:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_dmov2r15pd.f
   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
@@ -2851,11 +2920,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDRES) :
extract_fmt_ldres:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldres.f
   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
@@ -2875,11 +2945,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_COPOP) :
extract_fmt_copop:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_copop.f
   EXTRACT_IFMT_COPOP_VARS /* f-op1 f-ccc f-op2 f-op3 f-CRj f-u4c f-CRi */
@@ -2890,11 +2961,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_copop", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_COPLD) :
extract_fmt_copld:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_copld.f
   EXTRACT_IFMT_COPLD_VARS /* f-op1 f-ccc f-op2 f-op3 f-Rjc f-u4c f-CRi */
@@ -2905,11 +2977,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_copld", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_COPST) :
extract_fmt_copst:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_copst.f
   EXTRACT_IFMT_COPST_VARS /* f-op1 f-ccc f-op2 f-op3 f-CRj f-u4c f-Ric */
@@ -2920,11 +2993,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_copst", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_NOP) :
extract_fmt_nop:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_nop.f
   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
@@ -2935,11 +3009,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_nop", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ANDCCR) :
extract_fmt_andccr:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_andccr.f
   EXTRACT_IFMT_INT_VARS /* f-op1 f-op2 f-u8 */
@@ -2951,11 +3026,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_andccr", "f_u8 0x%x", 'x', f_u8, (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STILM) :
extract_fmt_stilm:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stilm.f
   EXTRACT_IFMT_INT_VARS /* f-op1 f-op2 f-u8 */
@@ -2967,11 +3043,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_stilm", "f_u8 0x%x", 'x', f_u8, (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADDSP) :
extract_fmt_addsp:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_addsp.f
   EXTRACT_IFMT_ADDSP_VARS /* f-op1 f-op2 f-s10 */
@@ -2991,11 +3068,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_EXTSB) :
extract_fmt_extsb:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_extsb.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -3015,11 +3093,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_EXTUB) :
extract_fmt_extub:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_extub.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -3039,11 +3118,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_EXTSH) :
extract_fmt_extsh:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_extsh.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -3063,11 +3143,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_EXTUH) :
extract_fmt_extuh:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_extuh.f
   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
@@ -3087,11 +3168,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDM0) :
extract_fmt_ldm0:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldm0.f
   EXTRACT_IFMT_LDM0_VARS /* f-op1 f-op2 f-reglist_low_ld */
@@ -3119,11 +3201,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDM1) :
extract_fmt_ldm1:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldm1.f
   EXTRACT_IFMT_LDM1_VARS /* f-op1 f-op2 f-reglist_hi_ld */
@@ -3150,11 +3233,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STM0) :
extract_fmt_stm0:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stm0.f
   EXTRACT_IFMT_STM0_VARS /* f-op1 f-op2 f-reglist_low_st */
@@ -3182,11 +3266,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STM1) :
extract_fmt_stm1:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stm1.f
   EXTRACT_IFMT_STM1_VARS /* f-op1 f-op2 f-reglist_hi_st */
@@ -3213,11 +3298,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ENTER) :
extract_fmt_enter:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_enter.f
   EXTRACT_IFMT_ENTER_VARS /* f-op1 f-op2 f-u10 */
@@ -3239,11 +3325,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LEAVE) :
extract_fmt_leave:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_leave.f
   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
@@ -3264,11 +3351,12 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_XCHB) :
extract_fmt_xchb:
   {
+    const IDESC *idesc = &fr30bf_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_xchb.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
@@ -3290,14 +3378,7 @@ fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
-  }
-
-
-      }
-    ENDSWITCH (ex)
-
+    return idesc;
   }
 
-  return idecode->idesc;
 }
index f378a525cc3b613eccbf1bac8207e4ee24ede065..a3d47cf765d50cdfabd7c9a990e35549cdcde226 100644 (file)
@@ -31,10 +31,8 @@ device fr30_devices;
 int
 device_io_read_buffer (device *me, void *source, int space,
                       address_word addr, unsigned nr_bytes,
-                      SIM_CPU *cpu, sim_cia cia)
+                      SIM_DESC sd, SIM_CPU *cpu, sim_cia cia)
 {
-  SIM_DESC sd = CPU_STATE (cpu);
-
   if (STATE_ENVIRONMENT (sd) != OPERATING_ENVIRONMENT)
     return nr_bytes;
 
@@ -69,10 +67,8 @@ device_io_read_buffer (device *me, void *source, int space,
 int
 device_io_write_buffer (device *me, const void *source, int space,
                        address_word addr, unsigned nr_bytes,
-                       SIM_CPU *cpu, sim_cia cia)
+                       SIM_DESC sd, SIM_CPU *cpu, sim_cia cia)
 {
-  SIM_DESC sd = CPU_STATE (cpu);
-
 #if WITH_SCACHE
   if (addr == MCCR_ADDR)
     {
@@ -96,4 +92,7 @@ device_io_write_buffer (device *me, const void *source, int space,
   return nr_bytes;
 }
 
-void device_error () {}
+void
+device_error (device *me, char *message, ...)
+{
+}
index b9018efe6d46fc2afe5810a96ae4a83b3c642646..dbb8117f9746f5f25361e70be850f1323fa64759 100644 (file)
@@ -33,33 +33,21 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 extern BI fr30bf_h_sbit_get_handler (SIM_CPU *);
 extern void fr30bf_h_sbit_set_handler (SIM_CPU *, BI);
-#define GET_H_SBIT() fr30bf_h_sbit_get_handler (current_cpu)
-#define SET_H_SBIT(val) fr30bf_h_sbit_set_handler (current_cpu, (val))
 
 extern UQI fr30bf_h_ccr_get_handler (SIM_CPU *);
 extern void fr30bf_h_ccr_set_handler (SIM_CPU *, UQI);
-#define GET_H_CCR() fr30bf_h_ccr_get_handler (current_cpu)
-#define SET_H_CCR(val) fr30bf_h_ccr_set_handler (current_cpu, (val))
 
 extern UQI fr30bf_h_scr_get_handler (SIM_CPU *);
 extern void fr30bf_h_scr_set_handler (SIM_CPU *, UQI);
-#define GET_H_SCR() fr30bf_h_scr_get_handler (current_cpu)
-#define SET_H_SCR(val) fr30bf_h_scr_set_handler (current_cpu, (val))
 
 extern UQI fr30bf_h_ilm_get_handler (SIM_CPU *);
 extern void fr30bf_h_ilm_set_handler (SIM_CPU *, UQI);
-#define GET_H_ILM() fr30bf_h_ilm_get_handler (current_cpu)
-#define SET_H_ILM(val) fr30bf_h_ilm_set_handler (current_cpu, (val))
 
 extern USI fr30bf_h_ps_get_handler (SIM_CPU *);
 extern void fr30bf_h_ps_set_handler (SIM_CPU *, USI);
-#define GET_H_PS() fr30bf_h_ps_get_handler (current_cpu)
-#define SET_H_PS(val) fr30bf_h_ps_set_handler (current_cpu, (val))
 
 extern SI fr30bf_h_dr_get_handler (SIM_CPU *, UINT);
 extern void fr30bf_h_dr_set_handler (SIM_CPU *, UINT, SI);
-#define GET_H_DR(regno) fr30bf_h_dr_get_handler (current_cpu, (regno))
-#define SET_H_DR(regno, val) fr30bf_h_dr_set_handler (current_cpu, (regno), (val))
 \f
 #define GETTWI GETTSI
 #define SETTWI SETTSI
index 78b9b7ce8b20e91260dbe3b7c0848b3a63a6e88f..51336540783ecb93a00c0d7d68b9a56b4078e97a 100644 (file)
@@ -48,15 +48,15 @@ int
 fr30bf_fetch_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len)
 {
   if (rn < 16)
-    SETTWI (buf, a_fr30_h_gr_get (current_cpu, rn));
+    SETTWI (buf, fr30bf_h_gr_get (current_cpu, rn));
   else
     switch (rn)
       {
       case PC_REGNUM :
-       SETTWI (buf, a_fr30_h_pc_get (current_cpu));
+       SETTWI (buf, fr30bf_h_pc_get (current_cpu));
        break;
       case PS_REGNUM :
-       SETTWI (buf, a_fr30_h_ps_get (current_cpu));
+       SETTWI (buf, fr30bf_h_ps_get (current_cpu));
        break;
       case TBR_REGNUM :
       case RP_REGNUM :
@@ -64,7 +64,7 @@ fr30bf_fetch_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len
       case USP_REGNUM :
       case MDH_REGNUM :
       case MDL_REGNUM :
-       SETTWI (buf, a_fr30_h_dr_get (current_cpu,
+       SETTWI (buf, fr30bf_h_dr_get (current_cpu,
                                      decode_gdb_dr_regnum (rn)));
        break;
       default :
@@ -80,15 +80,15 @@ int
 fr30bf_store_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len)
 {
   if (rn < 16)
-    a_fr30_h_gr_set (current_cpu, rn, GETTWI (buf));
+    fr30bf_h_gr_set (current_cpu, rn, GETTWI (buf));
   else
     switch (rn)
       {
       case PC_REGNUM :
-       a_fr30_h_pc_set (current_cpu, GETTWI (buf));
+       fr30bf_h_pc_set (current_cpu, GETTWI (buf));
        break;
       case PS_REGNUM :
-       a_fr30_h_ps_set (current_cpu, GETTWI (buf));
+       fr30bf_h_ps_set (current_cpu, GETTWI (buf));
        break;
       case TBR_REGNUM :
       case RP_REGNUM :
@@ -96,7 +96,7 @@ fr30bf_store_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len
       case USP_REGNUM :
       case MDH_REGNUM :
       case MDL_REGNUM :
-       a_fr30_h_dr_set (current_cpu,
+       fr30bf_h_dr_set (current_cpu,
                         decode_gdb_dr_regnum (rn),
                         GETTWI (buf));
        break;
index 7be6305e40793b88c28645f93460eb5aff4ac812..a4d0714cbe2899f0d166f578f14316a2d277b198 100644 (file)
@@ -3996,7 +3996,7 @@ fr30_init_cpu (SIM_CPU *cpu)
 
 const MACH fr30_mach =
 {
-  "fr30", "fr30",
+  "fr30", "fr30", MACH_FR30,
   32, 32, & fr30_models[0], & fr30bf_imp_properties,
   fr30_init_cpu,
   fr30bf_prepare_run
index 86950b27edf34b688724db967709741e52efef5f..ace4bcab907b0a73b880b19c86c1fae0e88b3313 100644 (file)
@@ -403,7 +403,7 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = ADDOFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
     CPU (h_vbit) = opval;
@@ -419,7 +419,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -430,8 +430,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -446,7 +446,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = ADDOFSI (* FLD (i_Ri), FLD (f_u4), 0);
     CPU (h_vbit) = opval;
@@ -462,7 +462,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -473,8 +473,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -489,7 +489,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = ADDOFSI (* FLD (i_Ri), FLD (f_m4), 0);
     CPU (h_vbit) = opval;
@@ -505,7 +505,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -516,8 +516,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -532,7 +532,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = ADDCSI (* FLD (i_Ri), * FLD (i_Rj), CPU (h_cbit));
   {
@@ -550,7 +550,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -561,8 +561,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -634,7 +634,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = SUBOFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
     CPU (h_vbit) = opval;
@@ -650,7 +650,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -661,8 +661,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -677,7 +677,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = SUBCSI (* FLD (i_Ri), * FLD (i_Rj), CPU (h_cbit));
   {
@@ -695,7 +695,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -706,8 +706,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -741,7 +741,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp1;
   {
     BI opval = SUBOFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
@@ -754,7 +754,7 @@ do {
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
   tmp_tmp1 = SUBSI (* FLD (i_Ri), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp1, 0);
     CPU (h_zbit) = opval;
@@ -765,8 +765,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -781,7 +781,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp1;
   {
     BI opval = SUBOFSI (* FLD (i_Ri), FLD (f_u4), 0);
@@ -794,7 +794,7 @@ do {
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
   tmp_tmp1 = SUBSI (* FLD (i_Ri), FLD (f_u4));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp1, 0);
     CPU (h_zbit) = opval;
@@ -805,8 +805,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -821,7 +821,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp1;
   {
     BI opval = SUBOFSI (* FLD (i_Ri), FLD (f_m4), 0);
@@ -834,7 +834,7 @@ do {
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
   tmp_tmp1 = SUBSI (* FLD (i_Ri), FLD (f_m4));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp1, 0);
     CPU (h_zbit) = opval;
@@ -845,8 +845,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -861,13 +861,13 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ANDSI (* FLD (i_Ri), * FLD (i_Rj));
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -878,8 +878,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -894,13 +894,13 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ORSI (* FLD (i_Ri), * FLD (i_Rj));
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -911,8 +911,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -927,13 +927,13 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = XORSI (* FLD (i_Ri), * FLD (i_Rj));
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -944,8 +944,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
 #undef FLD
 }
@@ -960,10 +960,10 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = ANDSI (GETMEMSI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -974,13 +974,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     SI opval = tmp_tmp;
     SETMEMSI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -995,10 +995,10 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   HI tmp_tmp;
   tmp_tmp = ANDHI (GETMEMHI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQHI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1009,13 +1009,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     HI opval = tmp_tmp;
     SETMEMHI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1030,10 +1030,10 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   QI tmp_tmp;
   tmp_tmp = ANDQI (GETMEMQI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQQI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1044,13 +1044,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     QI opval = tmp_tmp;
     SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1065,10 +1065,10 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = ORSI (GETMEMSI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1079,13 +1079,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     SI opval = tmp_tmp;
     SETMEMSI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1100,10 +1100,10 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   HI tmp_tmp;
   tmp_tmp = ORHI (GETMEMHI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQHI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1114,13 +1114,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     HI opval = tmp_tmp;
     SETMEMHI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1135,10 +1135,10 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   QI tmp_tmp;
   tmp_tmp = ORQI (GETMEMQI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQQI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1149,13 +1149,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     QI opval = tmp_tmp;
     SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1170,10 +1170,10 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = XORSI (GETMEMSI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1184,13 +1184,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     SI opval = tmp_tmp;
     SETMEMSI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1205,10 +1205,10 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   HI tmp_tmp;
   tmp_tmp = XORHI (GETMEMHI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQHI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1219,13 +1219,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     HI opval = tmp_tmp;
     SETMEMHI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1240,10 +1240,10 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   QI tmp_tmp;
   tmp_tmp = XORQI (GETMEMQI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQQI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1254,13 +1254,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     QI opval = tmp_tmp;
     SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1389,7 +1389,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   QI tmp_tmp;
   tmp_tmp = ANDQI (FLD (f_u4), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
   {
@@ -1402,7 +1402,7 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1417,7 +1417,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   QI tmp_tmp;
   tmp_tmp = ANDQI (SLLQI (FLD (f_u4), 4), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
   {
@@ -1430,7 +1430,7 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1445,7 +1445,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   DI tmp_tmp;
   tmp_tmp = MULDI (EXTSIDI (* FLD (i_Rj)), EXTSIDI (* FLD (i_Ri)));
   {
@@ -1473,7 +1473,7 @@ do {
     CPU (h_vbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1488,7 +1488,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   DI tmp_tmp;
   tmp_tmp = MULDI (ZEXTSIDI (* FLD (i_Rj)), ZEXTSIDI (* FLD (i_Ri)));
   {
@@ -1516,7 +1516,7 @@ do {
     CPU (h_vbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1531,7 +1531,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = MULHI (TRUNCSIHI (* FLD (i_Rj)), TRUNCSIHI (* FLD (i_Ri)));
     SET_H_DR (((UINT) 5), opval);
@@ -1547,7 +1547,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1562,7 +1562,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = MULSI (ANDSI (* FLD (i_Rj), 65535), ANDSI (* FLD (i_Ri), 65535));
     SET_H_DR (((UINT) 5), opval);
@@ -1578,7 +1578,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1593,7 +1593,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = LTSI (GET_H_DR (((UINT) 5)), 0);
     CPU (h_d0bit) = opval;
@@ -1619,7 +1619,7 @@ if (NEBI (CPU (h_d0bit), 0)) {
     TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -1635,7 +1635,7 @@ if (NEBI (CPU (h_d0bit), 0)) {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = 0;
     CPU (h_d0bit) = opval;
@@ -1651,7 +1651,7 @@ do {
     SET_H_DR (((UINT) 4), opval);
     TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1666,7 +1666,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   {
     SI opval = SLLSI (GET_H_DR (((UINT) 4)), 1);
@@ -1686,7 +1686,7 @@ if (LTSI (GET_H_DR (((UINT) 5)), 0)) {
     TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
   }
 if (EQBI (CPU (h_d1bit), 1)) {
-do {
+{
   tmp_tmp = ADDSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
   {
     BI opval = ADDCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
@@ -1694,9 +1694,9 @@ do {
     written |= (1 << 6);
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
-} while (0);
+}
 } else {
-do {
+{
   tmp_tmp = SUBSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
   {
     BI opval = SUBCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
@@ -1704,10 +1704,10 @@ do {
     written |= (1 << 6);
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
-} while (0);
+}
 }
 if (NOTBI (XORBI (XORBI (CPU (h_d0bit), CPU (h_d1bit)), CPU (h_cbit)))) {
-do {
+{
   {
     SI opval = tmp_tmp;
     SET_H_DR (((UINT) 4), opval);
@@ -1718,14 +1718,14 @@ do {
     SET_H_DR (((UINT) 5), opval);
     TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
   }
-} while (0);
+}
 }
   {
     BI opval = EQSI (GET_H_DR (((UINT) 4)), 0);
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -1741,10 +1741,10 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
 if (EQBI (CPU (h_d1bit), 1)) {
-do {
+{
   tmp_tmp = ADDSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
   {
     BI opval = ADDCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
@@ -1752,9 +1752,9 @@ do {
     written |= (1 << 3);
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
-} while (0);
+}
 } else {
-do {
+{
   tmp_tmp = SUBSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
   {
     BI opval = SUBCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
@@ -1762,10 +1762,10 @@ do {
     written |= (1 << 3);
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
-} while (0);
+}
 }
 if (EQSI (tmp_tmp, 0)) {
-do {
+{
   {
     BI opval = 1;
     CPU (h_zbit) = opval;
@@ -1778,7 +1778,7 @@ do {
     written |= (1 << 4);
     TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -1787,7 +1787,7 @@ do {
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -1849,11 +1849,11 @@ if (EQBI (CPU (h_d1bit), 1)) {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ANDSI (* FLD (i_Rj), 31);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (32, tmp_shift))), 0);
     CPU (h_cbit) = opval;
@@ -1866,7 +1866,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -1885,7 +1885,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -1901,11 +1901,11 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = FLD (f_u4);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (32, tmp_shift))), 0);
     CPU (h_cbit) = opval;
@@ -1918,7 +1918,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -1937,7 +1937,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -1953,11 +1953,11 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ADDSI (FLD (f_u4), 16);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (32, tmp_shift))), 0);
     CPU (h_cbit) = opval;
@@ -1970,7 +1970,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -1989,7 +1989,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -2005,11 +2005,11 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ANDSI (* FLD (i_Rj), 31);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -2022,7 +2022,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -2041,7 +2041,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -2057,11 +2057,11 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = FLD (f_u4);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -2074,7 +2074,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -2093,7 +2093,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -2109,11 +2109,11 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ADDSI (FLD (f_u4), 16);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -2126,7 +2126,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -2145,7 +2145,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -2161,11 +2161,11 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ANDSI (* FLD (i_Rj), 31);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -2178,7 +2178,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -2197,7 +2197,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -2213,11 +2213,11 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = FLD (f_u4);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -2230,7 +2230,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -2249,7 +2249,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -2265,11 +2265,11 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ADDSI (FLD (f_u4), 16);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -2282,7 +2282,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -2301,7 +2301,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -2564,7 +2564,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     * FLD (i_Ri) = opval;
@@ -2578,7 +2578,7 @@ if (NESI (FLD (f_Ri), 15)) {
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -2594,7 +2594,7 @@ if (NESI (FLD (f_Ri), 15)) {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
   {
@@ -2607,7 +2607,7 @@ do {
     SET_H_DR (FLD (f_Rs2), opval);
     TRACE_RESULT (current_cpu, abuf, "Rs2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2622,7 +2622,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     SET_H_PS (opval);
@@ -2633,7 +2633,7 @@ do {
     CPU (h_gr[((UINT) 15)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2838,7 +2838,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = * FLD (i_Ri);
   {
@@ -2851,7 +2851,7 @@ do {
     SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2866,7 +2866,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = GET_H_DR (FLD (f_Rs2));
   {
@@ -2879,7 +2879,7 @@ do {
     SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2894,7 +2894,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -2905,7 +2905,7 @@ do {
     SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3037,13 +3037,13 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = * FLD (i_Ri);
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -3060,7 +3060,7 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ADDSI (pc, 2);
     SET_H_DR (((UINT) 1), opval);
@@ -3071,7 +3071,7 @@ do {
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -3088,8 +3088,8 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-do {
+{
+{
   {
     SI opval = ADDSI (pc, 4);
     SET_H_DR (((UINT) 1), opval);
@@ -3100,8 +3100,8 @@ do {
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -3118,7 +3118,7 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ADDSI (pc, 2);
     SET_H_DR (((UINT) 1), opval);
@@ -3129,7 +3129,7 @@ do {
     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -3146,8 +3146,8 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-do {
+{
+{
   {
     SI opval = ADDSI (pc, 4);
     SET_H_DR (((UINT) 1), opval);
@@ -3158,8 +3158,8 @@ do {
     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -3197,13 +3197,13 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = GET_H_DR (((UINT) 1));
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -3220,7 +3220,7 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 ; /*clobber*/
 ; /*clobber*/
 ; /*clobber*/
@@ -3229,7 +3229,7 @@ do {
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -3246,7 +3246,7 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 ; /*clobber*/
 ; /*clobber*/
 ; /*clobber*/
@@ -3255,7 +3255,7 @@ do {
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -3273,7 +3273,7 @@ do {
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
 if (EQBI (GET_H_SBIT (), 0)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, GET_H_DR (((UINT) 2)));
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
@@ -3298,9 +3298,9 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "dr-2", 'x', opval);
   }
-} while (0);
+}
 } else {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, GET_H_DR (((UINT) 3)));
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
@@ -3325,7 +3325,7 @@ do {
     written |= (1 << 6);
     TRACE_RESULT (current_cpu, abuf, "dr-3", 'x', opval);
   }
-} while (0);
+}
 }
 
   abuf->written = written;
@@ -3344,13 +3344,13 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = FLD (i_label9);
     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -3387,9 +3387,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 do { } while (0); /*nop*/
-} while (0);
+}
 
 #undef FLD
 }
@@ -3420,7 +3420,7 @@ do { } while (0); /*nop*/
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (CPU (h_zbit)) {
   {
     USI opval = FLD (i_label9);
@@ -3429,7 +3429,7 @@ if (CPU (h_zbit)) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3472,7 +3472,7 @@ if (CPU (h_zbit)) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (CPU (h_zbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3481,7 +3481,7 @@ if (NOTBI (CPU (h_zbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3524,7 +3524,7 @@ if (NOTBI (CPU (h_zbit))) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (CPU (h_cbit)) {
   {
     USI opval = FLD (i_label9);
@@ -3533,7 +3533,7 @@ if (CPU (h_cbit)) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3576,7 +3576,7 @@ if (CPU (h_cbit)) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (CPU (h_cbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3585,7 +3585,7 @@ if (NOTBI (CPU (h_cbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3628,7 +3628,7 @@ if (NOTBI (CPU (h_cbit))) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (CPU (h_nbit)) {
   {
     USI opval = FLD (i_label9);
@@ -3637,7 +3637,7 @@ if (CPU (h_nbit)) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3680,7 +3680,7 @@ if (CPU (h_nbit)) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (CPU (h_nbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3689,7 +3689,7 @@ if (NOTBI (CPU (h_nbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3732,7 +3732,7 @@ if (NOTBI (CPU (h_nbit))) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (CPU (h_vbit)) {
   {
     USI opval = FLD (i_label9);
@@ -3741,7 +3741,7 @@ if (CPU (h_vbit)) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3784,7 +3784,7 @@ if (CPU (h_vbit)) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (CPU (h_vbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3793,7 +3793,7 @@ if (NOTBI (CPU (h_vbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3836,7 +3836,7 @@ if (NOTBI (CPU (h_vbit))) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (XORBI (CPU (h_vbit), CPU (h_nbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3845,7 +3845,7 @@ if (XORBI (CPU (h_vbit), CPU (h_nbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3888,7 +3888,7 @@ if (XORBI (CPU (h_vbit), CPU (h_nbit))) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (XORBI (CPU (h_vbit), CPU (h_nbit)))) {
   {
     USI opval = FLD (i_label9);
@@ -3897,7 +3897,7 @@ if (NOTBI (XORBI (CPU (h_vbit), CPU (h_nbit)))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3940,7 +3940,7 @@ if (NOTBI (XORBI (CPU (h_vbit), CPU (h_nbit)))) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3949,7 +3949,7 @@ if (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3992,7 +3992,7 @@ if (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit))) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit)))) {
   {
     USI opval = FLD (i_label9);
@@ -4001,7 +4001,7 @@ if (NOTBI (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit)))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -4044,7 +4044,7 @@ if (NOTBI (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit)))) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ORBI (CPU (h_cbit), CPU (h_zbit))) {
   {
     USI opval = FLD (i_label9);
@@ -4053,7 +4053,7 @@ if (ORBI (CPU (h_cbit), CPU (h_zbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -4096,7 +4096,7 @@ if (ORBI (CPU (h_cbit), CPU (h_zbit))) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (ORBI (CPU (h_cbit), CPU (h_zbit)))) {
   {
     USI opval = FLD (i_label9);
@@ -4105,7 +4105,7 @@ if (NOTBI (ORBI (CPU (h_cbit), CPU (h_zbit)))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -4204,7 +4204,7 @@ if (NOTBI (ORBI (CPU (h_cbit), CPU (h_zbit)))) {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 13)]));
     SETMEMSI (current_cpu, pc, FLD (f_dir10), opval);
@@ -4215,7 +4215,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4230,7 +4230,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     HI opval = GETMEMHI (current_cpu, pc, CPU (h_gr[((UINT) 13)]));
     SETMEMHI (current_cpu, pc, FLD (f_dir9), opval);
@@ -4241,7 +4241,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4256,7 +4256,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     QI opval = GETMEMQI (current_cpu, pc, CPU (h_gr[((UINT) 13)]));
     SETMEMQI (current_cpu, pc, FLD (f_dir8), opval);
@@ -4267,7 +4267,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4282,7 +4282,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     SETMEMSI (current_cpu, pc, FLD (f_dir10), opval);
@@ -4293,7 +4293,7 @@ do {
     CPU (h_gr[((UINT) 15)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4365,7 +4365,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, FLD (f_dir10));
     SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 13)]), opval);
@@ -4376,7 +4376,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4391,7 +4391,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     HI opval = GETMEMHI (current_cpu, pc, FLD (f_dir9));
     SETMEMHI (current_cpu, pc, CPU (h_gr[((UINT) 13)]), opval);
@@ -4402,7 +4402,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4417,7 +4417,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     QI opval = GETMEMQI (current_cpu, pc, FLD (f_dir8));
     SETMEMQI (current_cpu, pc, CPU (h_gr[((UINT) 13)]), opval);
@@ -4428,7 +4428,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4443,7 +4443,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -4454,7 +4454,7 @@ do {
     SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4734,9 +4734,9 @@ do { } while (0); /*nop*/
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ANDSI (FLD (f_reglist_low_ld), 1)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 0)]) = opval;
@@ -4749,10 +4749,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 2)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 1)]) = opval;
@@ -4765,10 +4765,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 4)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 2)]) = opval;
@@ -4781,10 +4781,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 8)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 3)]) = opval;
@@ -4797,10 +4797,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 16)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 4)]) = opval;
@@ -4813,10 +4813,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 32)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 5)]) = opval;
@@ -4829,10 +4829,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 64)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 6)]) = opval;
@@ -4845,10 +4845,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 128)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 7)]) = opval;
@@ -4861,9 +4861,9 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
 }
-} while (0);
+}
+}
 
   abuf->written = written;
 #undef FLD
@@ -4879,9 +4879,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ANDSI (FLD (f_reglist_hi_ld), 1)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 8)]) = opval;
@@ -4894,10 +4894,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 2)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 9)]) = opval;
@@ -4910,10 +4910,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 4)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 10)]) = opval;
@@ -4926,10 +4926,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 8)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 11)]) = opval;
@@ -4942,10 +4942,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 16)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 12)]) = opval;
@@ -4958,10 +4958,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 32)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 13)]) = opval;
@@ -4974,10 +4974,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 64)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 14)]) = opval;
@@ -4990,7 +4990,7 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 128)) {
   {
@@ -5000,7 +5000,7 @@ if (ANDSI (FLD (f_reglist_hi_ld), 128)) {
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
@@ -5016,9 +5016,9 @@ if (ANDSI (FLD (f_reglist_hi_ld), 128)) {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ANDSI (FLD (f_reglist_low_st), 1)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5031,10 +5031,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 2)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5047,10 +5047,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 4)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5063,10 +5063,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 8)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5079,10 +5079,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 16)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5095,10 +5095,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 32)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5111,10 +5111,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 64)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5127,10 +5127,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 128)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5143,9 +5143,9 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
 }
-} while (0);
+}
+}
 
   abuf->written = written;
 #undef FLD
@@ -5161,9 +5161,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ANDSI (FLD (f_reglist_hi_st), 1)) {
-do {
+{
   SI tmp_save_r15;
   tmp_save_r15 = CPU (h_gr[((UINT) 15)]);
   {
@@ -5178,10 +5178,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 2)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5194,10 +5194,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 4)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5210,10 +5210,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 8)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5226,10 +5226,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 16)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5242,10 +5242,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 32)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5258,10 +5258,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 64)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5274,10 +5274,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 128)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5290,9 +5290,9 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
 }
-} while (0);
+}
+}
 
   abuf->written = written;
 #undef FLD
@@ -5308,7 +5308,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
   {
@@ -5326,7 +5326,7 @@ do {
     CPU (h_gr[((UINT) 15)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5341,7 +5341,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ADDSI (CPU (h_gr[((UINT) 14)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5352,7 +5352,7 @@ do {
     CPU (h_gr[((UINT) 14)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-14", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5367,7 +5367,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = * FLD (i_Ri);
   {
@@ -5380,7 +5380,7 @@ do {
     SETMEMUQI (current_cpu, pc, * FLD (i_Rj), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
index 8224c3350d986a7ac06ff955f9115940ac1889b4..e35c421654a2b181ae42a8b517efddf1d9fab058 100644 (file)
@@ -191,7 +191,7 @@ SEM_FN_NAME (fr30bf,add) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = ADDOFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
     CPU (h_vbit) = opval;
@@ -207,7 +207,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -218,8 +218,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -236,7 +236,7 @@ SEM_FN_NAME (fr30bf,addi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = ADDOFSI (* FLD (i_Ri), FLD (f_u4), 0);
     CPU (h_vbit) = opval;
@@ -252,7 +252,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -263,8 +263,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -281,7 +281,7 @@ SEM_FN_NAME (fr30bf,add2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = ADDOFSI (* FLD (i_Ri), FLD (f_m4), 0);
     CPU (h_vbit) = opval;
@@ -297,7 +297,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -308,8 +308,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -326,7 +326,7 @@ SEM_FN_NAME (fr30bf,addc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = ADDCSI (* FLD (i_Ri), * FLD (i_Rj), CPU (h_cbit));
   {
@@ -344,7 +344,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -355,8 +355,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -436,7 +436,7 @@ SEM_FN_NAME (fr30bf,sub) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = SUBOFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
     CPU (h_vbit) = opval;
@@ -452,7 +452,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -463,8 +463,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -481,7 +481,7 @@ SEM_FN_NAME (fr30bf,subc) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = SUBCSI (* FLD (i_Ri), * FLD (i_Rj), CPU (h_cbit));
   {
@@ -499,7 +499,7 @@ do {
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -510,8 +510,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -549,7 +549,7 @@ SEM_FN_NAME (fr30bf,cmp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp1;
   {
     BI opval = SUBOFSI (* FLD (i_Ri), * FLD (i_Rj), 0);
@@ -562,7 +562,7 @@ do {
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
   tmp_tmp1 = SUBSI (* FLD (i_Ri), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp1, 0);
     CPU (h_zbit) = opval;
@@ -573,8 +573,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -591,7 +591,7 @@ SEM_FN_NAME (fr30bf,cmpi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp1;
   {
     BI opval = SUBOFSI (* FLD (i_Ri), FLD (f_u4), 0);
@@ -604,7 +604,7 @@ do {
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
   tmp_tmp1 = SUBSI (* FLD (i_Ri), FLD (f_u4));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp1, 0);
     CPU (h_zbit) = opval;
@@ -615,8 +615,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -633,7 +633,7 @@ SEM_FN_NAME (fr30bf,cmp2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp1;
   {
     BI opval = SUBOFSI (* FLD (i_Ri), FLD (f_m4), 0);
@@ -646,7 +646,7 @@ do {
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
   tmp_tmp1 = SUBSI (* FLD (i_Ri), FLD (f_m4));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp1, 0);
     CPU (h_zbit) = opval;
@@ -657,8 +657,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -675,13 +675,13 @@ SEM_FN_NAME (fr30bf,and) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ANDSI (* FLD (i_Ri), * FLD (i_Rj));
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -692,8 +692,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -710,13 +710,13 @@ SEM_FN_NAME (fr30bf,or) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ORSI (* FLD (i_Ri), * FLD (i_Rj));
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -727,8 +727,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -745,13 +745,13 @@ SEM_FN_NAME (fr30bf,eor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = XORSI (* FLD (i_Ri), * FLD (i_Rj));
     * FLD (i_Ri) = opval;
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-do {
+{
   {
     BI opval = EQSI (* FLD (i_Ri), 0);
     CPU (h_zbit) = opval;
@@ -762,8 +762,8 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   return vpc;
 #undef FLD
@@ -780,10 +780,10 @@ SEM_FN_NAME (fr30bf,andm) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = ANDSI (GETMEMSI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -794,13 +794,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     SI opval = tmp_tmp;
     SETMEMSI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -817,10 +817,10 @@ SEM_FN_NAME (fr30bf,andh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   HI tmp_tmp;
   tmp_tmp = ANDHI (GETMEMHI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQHI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -831,13 +831,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     HI opval = tmp_tmp;
     SETMEMHI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -854,10 +854,10 @@ SEM_FN_NAME (fr30bf,andb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   QI tmp_tmp;
   tmp_tmp = ANDQI (GETMEMQI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQQI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -868,13 +868,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     QI opval = tmp_tmp;
     SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -891,10 +891,10 @@ SEM_FN_NAME (fr30bf,orm) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = ORSI (GETMEMSI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -905,13 +905,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     SI opval = tmp_tmp;
     SETMEMSI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -928,10 +928,10 @@ SEM_FN_NAME (fr30bf,orh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   HI tmp_tmp;
   tmp_tmp = ORHI (GETMEMHI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQHI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -942,13 +942,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     HI opval = tmp_tmp;
     SETMEMHI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -965,10 +965,10 @@ SEM_FN_NAME (fr30bf,orb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   QI tmp_tmp;
   tmp_tmp = ORQI (GETMEMQI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQQI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -979,13 +979,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     QI opval = tmp_tmp;
     SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1002,10 +1002,10 @@ SEM_FN_NAME (fr30bf,eorm) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = XORSI (GETMEMSI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQSI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1016,13 +1016,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     SI opval = tmp_tmp;
     SETMEMSI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1039,10 +1039,10 @@ SEM_FN_NAME (fr30bf,eorh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   HI tmp_tmp;
   tmp_tmp = XORHI (GETMEMHI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQHI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1053,13 +1053,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     HI opval = tmp_tmp;
     SETMEMHI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1076,10 +1076,10 @@ SEM_FN_NAME (fr30bf,eorb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   QI tmp_tmp;
   tmp_tmp = XORQI (GETMEMQI (current_cpu, pc, * FLD (i_Ri)), * FLD (i_Rj));
-do {
+{
   {
     BI opval = EQQI (tmp_tmp, 0);
     CPU (h_zbit) = opval;
@@ -1090,13 +1090,13 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
   {
     QI opval = tmp_tmp;
     SETMEMQI (current_cpu, pc, * FLD (i_Ri), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1239,7 +1239,7 @@ SEM_FN_NAME (fr30bf,btstl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   QI tmp_tmp;
   tmp_tmp = ANDQI (FLD (f_u4), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
   {
@@ -1252,7 +1252,7 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1269,7 +1269,7 @@ SEM_FN_NAME (fr30bf,btsth) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   QI tmp_tmp;
   tmp_tmp = ANDQI (SLLQI (FLD (f_u4), 4), GETMEMQI (current_cpu, pc, * FLD (i_Ri)));
   {
@@ -1282,7 +1282,7 @@ do {
     CPU (h_nbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "nbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1299,7 +1299,7 @@ SEM_FN_NAME (fr30bf,mul) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   DI tmp_tmp;
   tmp_tmp = MULDI (EXTSIDI (* FLD (i_Rj)), EXTSIDI (* FLD (i_Ri)));
   {
@@ -1327,7 +1327,7 @@ do {
     CPU (h_vbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1344,7 +1344,7 @@ SEM_FN_NAME (fr30bf,mulu) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   DI tmp_tmp;
   tmp_tmp = MULDI (ZEXTSIDI (* FLD (i_Rj)), ZEXTSIDI (* FLD (i_Ri)));
   {
@@ -1372,7 +1372,7 @@ do {
     CPU (h_vbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "vbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1389,7 +1389,7 @@ SEM_FN_NAME (fr30bf,mulh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = MULHI (TRUNCSIHI (* FLD (i_Rj)), TRUNCSIHI (* FLD (i_Ri)));
     SET_H_DR (((UINT) 5), opval);
@@ -1405,7 +1405,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1422,7 +1422,7 @@ SEM_FN_NAME (fr30bf,muluh) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = MULSI (ANDSI (* FLD (i_Rj), 65535), ANDSI (* FLD (i_Ri), 65535));
     SET_H_DR (((UINT) 5), opval);
@@ -1438,7 +1438,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1455,7 +1455,7 @@ SEM_FN_NAME (fr30bf,div0s) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = LTSI (GET_H_DR (((UINT) 5)), 0);
     CPU (h_d0bit) = opval;
@@ -1481,7 +1481,7 @@ if (NEBI (CPU (h_d0bit), 0)) {
     TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -1499,7 +1499,7 @@ SEM_FN_NAME (fr30bf,div0u) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = 0;
     CPU (h_d0bit) = opval;
@@ -1515,7 +1515,7 @@ do {
     SET_H_DR (((UINT) 4), opval);
     TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1532,7 +1532,7 @@ SEM_FN_NAME (fr30bf,div1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   {
     SI opval = SLLSI (GET_H_DR (((UINT) 4)), 1);
@@ -1552,7 +1552,7 @@ if (LTSI (GET_H_DR (((UINT) 5)), 0)) {
     TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
   }
 if (EQBI (CPU (h_d1bit), 1)) {
-do {
+{
   tmp_tmp = ADDSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
   {
     BI opval = ADDCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
@@ -1560,9 +1560,9 @@ do {
     written |= (1 << 6);
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
-} while (0);
+}
 } else {
-do {
+{
   tmp_tmp = SUBSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
   {
     BI opval = SUBCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
@@ -1570,10 +1570,10 @@ do {
     written |= (1 << 6);
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
-} while (0);
+}
 }
 if (NOTBI (XORBI (XORBI (CPU (h_d0bit), CPU (h_d1bit)), CPU (h_cbit)))) {
-do {
+{
   {
     SI opval = tmp_tmp;
     SET_H_DR (((UINT) 4), opval);
@@ -1584,14 +1584,14 @@ do {
     SET_H_DR (((UINT) 5), opval);
     TRACE_RESULT (current_cpu, abuf, "dr-5", 'x', opval);
   }
-} while (0);
+}
 }
   {
     BI opval = EQSI (GET_H_DR (((UINT) 4)), 0);
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -1609,10 +1609,10 @@ SEM_FN_NAME (fr30bf,div2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
 if (EQBI (CPU (h_d1bit), 1)) {
-do {
+{
   tmp_tmp = ADDSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
   {
     BI opval = ADDCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
@@ -1620,9 +1620,9 @@ do {
     written |= (1 << 3);
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
-} while (0);
+}
 } else {
-do {
+{
   tmp_tmp = SUBSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri));
   {
     BI opval = SUBCFSI (GET_H_DR (((UINT) 4)), * FLD (i_Ri), 0);
@@ -1630,10 +1630,10 @@ do {
     written |= (1 << 3);
     TRACE_RESULT (current_cpu, abuf, "cbit", 'x', opval);
   }
-} while (0);
+}
 }
 if (EQSI (tmp_tmp, 0)) {
-do {
+{
   {
     BI opval = 1;
     CPU (h_zbit) = opval;
@@ -1646,7 +1646,7 @@ do {
     written |= (1 << 4);
     TRACE_RESULT (current_cpu, abuf, "dr-4", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -1655,7 +1655,7 @@ do {
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -1723,11 +1723,11 @@ SEM_FN_NAME (fr30bf,lsl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ANDSI (* FLD (i_Rj), 31);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (32, tmp_shift))), 0);
     CPU (h_cbit) = opval;
@@ -1740,7 +1740,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -1759,7 +1759,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -1777,11 +1777,11 @@ SEM_FN_NAME (fr30bf,lsli) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = FLD (f_u4);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (32, tmp_shift))), 0);
     CPU (h_cbit) = opval;
@@ -1794,7 +1794,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -1813,7 +1813,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -1831,11 +1831,11 @@ SEM_FN_NAME (fr30bf,lsl2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ADDSI (FLD (f_u4), 16);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (32, tmp_shift))), 0);
     CPU (h_cbit) = opval;
@@ -1848,7 +1848,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -1867,7 +1867,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -1885,11 +1885,11 @@ SEM_FN_NAME (fr30bf,lsr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ANDSI (* FLD (i_Rj), 31);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -1902,7 +1902,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -1921,7 +1921,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -1939,11 +1939,11 @@ SEM_FN_NAME (fr30bf,lsri) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = FLD (f_u4);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -1956,7 +1956,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -1975,7 +1975,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -1993,11 +1993,11 @@ SEM_FN_NAME (fr30bf,lsr2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ADDSI (FLD (f_u4), 16);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -2010,7 +2010,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -2029,7 +2029,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -2047,11 +2047,11 @@ SEM_FN_NAME (fr30bf,asr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ANDSI (* FLD (i_Rj), 31);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -2064,7 +2064,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -2083,7 +2083,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -2101,11 +2101,11 @@ SEM_FN_NAME (fr30bf,asri) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = FLD (f_u4);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -2118,7 +2118,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -2137,7 +2137,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -2155,11 +2155,11 @@ SEM_FN_NAME (fr30bf,asr2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_shift;
   tmp_shift = ADDSI (FLD (f_u4), 16);
 if (NESI (tmp_shift, 0)) {
-do {
+{
   {
     BI opval = NESI (ANDSI (* FLD (i_Ri), SLLSI (1, SUBSI (tmp_shift, 1))), 0);
     CPU (h_cbit) = opval;
@@ -2172,7 +2172,7 @@ do {
     written |= (1 << 2);
     TRACE_RESULT (current_cpu, abuf, "Ri", 'x', opval);
   }
-} while (0);
+}
 } else {
   {
     BI opval = 0;
@@ -2191,7 +2191,7 @@ do {
     CPU (h_zbit) = opval;
     TRACE_RESULT (current_cpu, abuf, "zbit", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -2482,7 +2482,7 @@ SEM_FN_NAME (fr30bf,ldr15gr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     * FLD (i_Ri) = opval;
@@ -2496,7 +2496,7 @@ if (NESI (FLD (f_Ri), 15)) {
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -2514,7 +2514,7 @@ SEM_FN_NAME (fr30bf,ldr15dr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
   {
@@ -2527,7 +2527,7 @@ do {
     SET_H_DR (FLD (f_Rs2), opval);
     TRACE_RESULT (current_cpu, abuf, "Rs2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2544,7 +2544,7 @@ SEM_FN_NAME (fr30bf,ldr15ps) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     SET_H_PS (opval);
@@ -2555,7 +2555,7 @@ do {
     CPU (h_gr[((UINT) 15)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2782,7 +2782,7 @@ SEM_FN_NAME (fr30bf,str15gr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = * FLD (i_Ri);
   {
@@ -2795,7 +2795,7 @@ do {
     SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2812,7 +2812,7 @@ SEM_FN_NAME (fr30bf,str15dr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = GET_H_DR (FLD (f_Rs2));
   {
@@ -2825,7 +2825,7 @@ do {
     SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2842,7 +2842,7 @@ SEM_FN_NAME (fr30bf,str15ps) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -2853,7 +2853,7 @@ do {
     SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2999,13 +2999,13 @@ SEM_FN_NAME (fr30bf,jmpd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = * FLD (i_Ri);
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -3024,7 +3024,7 @@ SEM_FN_NAME (fr30bf,callr) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ADDSI (pc, 2);
     SET_H_DR (((UINT) 1), opval);
@@ -3035,7 +3035,7 @@ do {
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -3054,8 +3054,8 @@ SEM_FN_NAME (fr30bf,callrd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-do {
+{
+{
   {
     SI opval = ADDSI (pc, 4);
     SET_H_DR (((UINT) 1), opval);
@@ -3066,8 +3066,8 @@ do {
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -3086,7 +3086,7 @@ SEM_FN_NAME (fr30bf,call) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ADDSI (pc, 2);
     SET_H_DR (((UINT) 1), opval);
@@ -3097,7 +3097,7 @@ do {
     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -3116,8 +3116,8 @@ SEM_FN_NAME (fr30bf,calld) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-do {
+{
+{
   {
     SI opval = ADDSI (pc, 4);
     SET_H_DR (((UINT) 1), opval);
@@ -3128,8 +3128,8 @@ do {
     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
-} while (0);
+}
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -3171,13 +3171,13 @@ SEM_FN_NAME (fr30bf,ret_d) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = GET_H_DR (((UINT) 1));
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -3196,7 +3196,7 @@ SEM_FN_NAME (fr30bf,int) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 ; /*clobber*/
 ; /*clobber*/
 ; /*clobber*/
@@ -3205,7 +3205,7 @@ do {
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -3224,7 +3224,7 @@ SEM_FN_NAME (fr30bf,inte) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 ; /*clobber*/
 ; /*clobber*/
 ; /*clobber*/
@@ -3233,7 +3233,7 @@ do {
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -3253,7 +3253,7 @@ SEM_FN_NAME (fr30bf,reti) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
 if (EQBI (GET_H_SBIT (), 0)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, GET_H_DR (((UINT) 2)));
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
@@ -3278,9 +3278,9 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "dr-2", 'x', opval);
   }
-} while (0);
+}
 } else {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, GET_H_DR (((UINT) 3)));
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
@@ -3305,7 +3305,7 @@ do {
     written |= (1 << 6);
     TRACE_RESULT (current_cpu, abuf, "dr-3", 'x', opval);
   }
-} while (0);
+}
 }
 
   abuf->written = written;
@@ -3326,13 +3326,13 @@ SEM_FN_NAME (fr30bf,brad) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = FLD (i_label9);
     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -3373,9 +3373,9 @@ SEM_FN_NAME (fr30bf,bnod) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 do { } while (0); /*nop*/
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3410,7 +3410,7 @@ SEM_FN_NAME (fr30bf,beqd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (CPU (h_zbit)) {
   {
     USI opval = FLD (i_label9);
@@ -3419,7 +3419,7 @@ if (CPU (h_zbit)) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3466,7 +3466,7 @@ SEM_FN_NAME (fr30bf,bned) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (CPU (h_zbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3475,7 +3475,7 @@ if (NOTBI (CPU (h_zbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3522,7 +3522,7 @@ SEM_FN_NAME (fr30bf,bcd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (CPU (h_cbit)) {
   {
     USI opval = FLD (i_label9);
@@ -3531,7 +3531,7 @@ if (CPU (h_cbit)) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3578,7 +3578,7 @@ SEM_FN_NAME (fr30bf,bncd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (CPU (h_cbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3587,7 +3587,7 @@ if (NOTBI (CPU (h_cbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3634,7 +3634,7 @@ SEM_FN_NAME (fr30bf,bnd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (CPU (h_nbit)) {
   {
     USI opval = FLD (i_label9);
@@ -3643,7 +3643,7 @@ if (CPU (h_nbit)) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3690,7 +3690,7 @@ SEM_FN_NAME (fr30bf,bpd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (CPU (h_nbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3699,7 +3699,7 @@ if (NOTBI (CPU (h_nbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3746,7 +3746,7 @@ SEM_FN_NAME (fr30bf,bvd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (CPU (h_vbit)) {
   {
     USI opval = FLD (i_label9);
@@ -3755,7 +3755,7 @@ if (CPU (h_vbit)) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3802,7 +3802,7 @@ SEM_FN_NAME (fr30bf,bnvd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (CPU (h_vbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3811,7 +3811,7 @@ if (NOTBI (CPU (h_vbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3858,7 +3858,7 @@ SEM_FN_NAME (fr30bf,bltd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (XORBI (CPU (h_vbit), CPU (h_nbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3867,7 +3867,7 @@ if (XORBI (CPU (h_vbit), CPU (h_nbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3914,7 +3914,7 @@ SEM_FN_NAME (fr30bf,bged) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (XORBI (CPU (h_vbit), CPU (h_nbit)))) {
   {
     USI opval = FLD (i_label9);
@@ -3923,7 +3923,7 @@ if (NOTBI (XORBI (CPU (h_vbit), CPU (h_nbit)))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -3970,7 +3970,7 @@ SEM_FN_NAME (fr30bf,bled) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit))) {
   {
     USI opval = FLD (i_label9);
@@ -3979,7 +3979,7 @@ if (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -4026,7 +4026,7 @@ SEM_FN_NAME (fr30bf,bgtd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit)))) {
   {
     USI opval = FLD (i_label9);
@@ -4035,7 +4035,7 @@ if (NOTBI (ORBI (XORBI (CPU (h_vbit), CPU (h_nbit)), CPU (h_zbit)))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -4082,7 +4082,7 @@ SEM_FN_NAME (fr30bf,blsd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ORBI (CPU (h_cbit), CPU (h_zbit))) {
   {
     USI opval = FLD (i_label9);
@@ -4091,7 +4091,7 @@ if (ORBI (CPU (h_cbit), CPU (h_zbit))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -4138,7 +4138,7 @@ SEM_FN_NAME (fr30bf,bhid) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (NOTBI (ORBI (CPU (h_cbit), CPU (h_zbit)))) {
   {
     USI opval = FLD (i_label9);
@@ -4147,7 +4147,7 @@ if (NOTBI (ORBI (CPU (h_cbit), CPU (h_zbit)))) {
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   SEM_BRANCH_FINI (vpc);
@@ -4256,7 +4256,7 @@ SEM_FN_NAME (fr30bf,dmovr13pi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 13)]));
     SETMEMSI (current_cpu, pc, FLD (f_dir10), opval);
@@ -4267,7 +4267,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4284,7 +4284,7 @@ SEM_FN_NAME (fr30bf,dmovr13pih) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     HI opval = GETMEMHI (current_cpu, pc, CPU (h_gr[((UINT) 13)]));
     SETMEMHI (current_cpu, pc, FLD (f_dir9), opval);
@@ -4295,7 +4295,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4312,7 +4312,7 @@ SEM_FN_NAME (fr30bf,dmovr13pib) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     QI opval = GETMEMQI (current_cpu, pc, CPU (h_gr[((UINT) 13)]));
     SETMEMQI (current_cpu, pc, FLD (f_dir8), opval);
@@ -4323,7 +4323,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4340,7 +4340,7 @@ SEM_FN_NAME (fr30bf,dmovr15pi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     SETMEMSI (current_cpu, pc, FLD (f_dir10), opval);
@@ -4351,7 +4351,7 @@ do {
     CPU (h_gr[((UINT) 15)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4431,7 +4431,7 @@ SEM_FN_NAME (fr30bf,dmov2r13pi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, FLD (f_dir10));
     SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 13)]), opval);
@@ -4442,7 +4442,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4459,7 +4459,7 @@ SEM_FN_NAME (fr30bf,dmov2r13pih) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     HI opval = GETMEMHI (current_cpu, pc, FLD (f_dir9));
     SETMEMHI (current_cpu, pc, CPU (h_gr[((UINT) 13)]), opval);
@@ -4470,7 +4470,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4487,7 +4487,7 @@ SEM_FN_NAME (fr30bf,dmov2r13pib) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     QI opval = GETMEMQI (current_cpu, pc, FLD (f_dir8));
     SETMEMQI (current_cpu, pc, CPU (h_gr[((UINT) 13)]), opval);
@@ -4498,7 +4498,7 @@ do {
     CPU (h_gr[((UINT) 13)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-13", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4515,7 +4515,7 @@ SEM_FN_NAME (fr30bf,dmov2r15pd) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -4526,7 +4526,7 @@ do {
     SETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4838,9 +4838,9 @@ SEM_FN_NAME (fr30bf,ldm0) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ANDSI (FLD (f_reglist_low_ld), 1)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 0)]) = opval;
@@ -4853,10 +4853,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 2)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 1)]) = opval;
@@ -4869,10 +4869,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 4)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 2)]) = opval;
@@ -4885,10 +4885,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 8)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 3)]) = opval;
@@ -4901,10 +4901,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 16)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 4)]) = opval;
@@ -4917,10 +4917,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 32)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 5)]) = opval;
@@ -4933,10 +4933,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 64)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 6)]) = opval;
@@ -4949,10 +4949,10 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_ld), 128)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 7)]) = opval;
@@ -4965,9 +4965,9 @@ do {
     written |= (1 << 5);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
 }
-} while (0);
+}
+}
 
   abuf->written = written;
   return vpc;
@@ -4985,9 +4985,9 @@ SEM_FN_NAME (fr30bf,ldm1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ANDSI (FLD (f_reglist_hi_ld), 1)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 8)]) = opval;
@@ -5000,10 +5000,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 2)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 9)]) = opval;
@@ -5016,10 +5016,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 4)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 10)]) = opval;
@@ -5032,10 +5032,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 8)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 11)]) = opval;
@@ -5048,10 +5048,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 16)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 12)]) = opval;
@@ -5064,10 +5064,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 32)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 13)]) = opval;
@@ -5080,10 +5080,10 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 64)) {
-do {
+{
   {
     SI opval = GETMEMSI (current_cpu, pc, CPU (h_gr[((UINT) 15)]));
     CPU (h_gr[((UINT) 14)]) = opval;
@@ -5096,7 +5096,7 @@ do {
     written |= (1 << 8);
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_ld), 128)) {
   {
@@ -5106,7 +5106,7 @@ if (ANDSI (FLD (f_reglist_hi_ld), 128)) {
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
 }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
@@ -5124,9 +5124,9 @@ SEM_FN_NAME (fr30bf,stm0) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ANDSI (FLD (f_reglist_low_st), 1)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5139,10 +5139,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 2)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5155,10 +5155,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 4)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5171,10 +5171,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 8)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5187,10 +5187,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 16)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5203,10 +5203,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 32)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5219,10 +5219,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 64)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5235,10 +5235,10 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_low_st), 128)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5251,9 +5251,9 @@ do {
     written |= (1 << 11);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
 }
-} while (0);
+}
+}
 
   abuf->written = written;
   return vpc;
@@ -5271,9 +5271,9 @@ SEM_FN_NAME (fr30bf,stm1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (ANDSI (FLD (f_reglist_hi_st), 1)) {
-do {
+{
   SI tmp_save_r15;
   tmp_save_r15 = CPU (h_gr[((UINT) 15)]);
   {
@@ -5288,10 +5288,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 2)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5304,10 +5304,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 4)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5320,10 +5320,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 8)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5336,10 +5336,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 16)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5352,10 +5352,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 32)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5368,10 +5368,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 64)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5384,10 +5384,10 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 }
 if (ANDSI (FLD (f_reglist_hi_st), 128)) {
-do {
+{
   {
     SI opval = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5400,9 +5400,9 @@ do {
     written |= (1 << 10);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
 }
-} while (0);
+}
+}
 
   abuf->written = written;
   return vpc;
@@ -5420,7 +5420,7 @@ SEM_FN_NAME (fr30bf,enter) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = SUBSI (CPU (h_gr[((UINT) 15)]), 4);
   {
@@ -5438,7 +5438,7 @@ do {
     CPU (h_gr[((UINT) 15)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-15", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5455,7 +5455,7 @@ SEM_FN_NAME (fr30bf,leave) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ADDSI (CPU (h_gr[((UINT) 14)]), 4);
     CPU (h_gr[((UINT) 15)]) = opval;
@@ -5466,7 +5466,7 @@ do {
     CPU (h_gr[((UINT) 14)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-14", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5483,7 +5483,7 @@ SEM_FN_NAME (fr30bf,xchb) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_tmp;
   tmp_tmp = * FLD (i_Ri);
   {
@@ -5496,7 +5496,7 @@ do {
     SETMEMUQI (current_cpu, pc, * FLD (i_Rj), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
index 5df0f83f57a54dd4734a675e787dd118b8c13827..28b344d9c5ec9c9e22e517178d1485f1232387db 100644 (file)
@@ -143,8 +143,8 @@ sim_open (kind, callback, abfd, argv)
 
   /* Open a copy of the cpu descriptor table.  */
   {
-    CGEN_CPU_DESC cd = fr30_cgen_cpu_open (STATE_ARCHITECTURE (sd)->mach,
-                                          CGEN_ENDIAN_BIG);
+    CGEN_CPU_DESC cd = fr30_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd)->printable_name,
+                                            CGEN_ENDIAN_BIG);
     for (i = 0; i < MAX_NR_PROCESSORS; ++i)
       {
        SIM_CPU *cpu = STATE_CPU (sd, i);
index 599bca288911c496c8ee16a69a8119d42c6b134a..11f7a30605daee65b11677c6c2fba9005780e7e9 100644 (file)
@@ -104,15 +104,15 @@ syscall_write_mem (host_callback *cb, struct cb_syscall *sc,
 static void
 setup_int (SIM_CPU *current_cpu, PCADDR pc)
 {
-  USI ssp = a_fr30_h_dr_get (current_cpu, H_DR_SSP);
-  USI ps = a_fr30_h_ps_get (current_cpu);
+  USI ssp = fr30bf_h_dr_get (current_cpu, H_DR_SSP);
+  USI ps = fr30bf_h_ps_get (current_cpu);
 
   ssp -= 4;
   SETMEMSI (current_cpu, pc, ssp, ps);
   ssp -= 4;
   SETMEMSI (current_cpu, pc, ssp, pc + 2);
-  a_fr30_h_dr_set (current_cpu, H_DR_SSP, ssp);
-  a_fr30_h_sbit_set (current_cpu, 0);
+  fr30bf_h_dr_set (current_cpu, H_DR_SSP, ssp);
+  fr30bf_h_sbit_set (current_cpu, 0);
 }
 
 /* Trap support.
@@ -143,9 +143,9 @@ fr30_int (SIM_CPU *current_cpu, PCADDR pc, int num)
         We assume there's a branch there to some handler.  */
       USI new_pc;
       setup_int (current_cpu, pc);
-      a_fr30_h_ibit_set (current_cpu, 0);
+      fr30bf_h_ibit_set (current_cpu, 0);
       new_pc = GETMEMSI (current_cpu, pc,
-                        a_fr30_h_dr_get (current_cpu, H_DR_TBR)
+                        fr30bf_h_dr_get (current_cpu, H_DR_TBR)
                         + 1024 - ((num + 1) * 4));
       return new_pc;
     }
@@ -158,10 +158,10 @@ fr30_int (SIM_CPU *current_cpu, PCADDR pc, int num)
        CB_SYSCALL s;
 
        CB_SYSCALL_INIT (&s);
-       s.func = a_fr30_h_gr_get (current_cpu, 0);
-       s.arg1 = a_fr30_h_gr_get (current_cpu, 4);
-       s.arg2 = a_fr30_h_gr_get (current_cpu, 5);
-       s.arg3 = a_fr30_h_gr_get (current_cpu, 6);
+       s.func = fr30bf_h_gr_get (current_cpu, 0);
+       s.arg1 = fr30bf_h_gr_get (current_cpu, 4);
+       s.arg2 = fr30bf_h_gr_get (current_cpu, 5);
+       s.arg3 = fr30bf_h_gr_get (current_cpu, 6);
 
        if (s.func == TARGET_SYS_exit)
          {
@@ -173,9 +173,9 @@ fr30_int (SIM_CPU *current_cpu, PCADDR pc, int num)
        s.read_mem = syscall_read_mem;
        s.write_mem = syscall_write_mem;
        cb_syscall (cb, &s);
-       a_fr30_h_gr_set (current_cpu, 2, s.errcode); /* TODO: check this one */
-       a_fr30_h_gr_set (current_cpu, 4, s.result);
-       a_fr30_h_gr_set (current_cpu, 1, s.result2); /* TODO: check this one */
+       fr30bf_h_gr_set (current_cpu, 2, s.errcode); /* TODO: check this one */
+       fr30bf_h_gr_set (current_cpu, 4, s.result);
+       fr30bf_h_gr_set (current_cpu, 1, s.result2); /* TODO: check this one */
        break;
       }
 
@@ -188,9 +188,9 @@ fr30_int (SIM_CPU *current_cpu, PCADDR pc, int num)
       {
        USI new_pc;
        setup_int (current_cpu, pc);
-       a_fr30_h_ibit_set (current_cpu, 0);
+       fr30bf_h_ibit_set (current_cpu, 0);
        new_pc = GETMEMSI (current_cpu, pc,
-                          a_fr30_h_dr_get (current_cpu, H_DR_TBR)
+                          fr30bf_h_dr_get (current_cpu, H_DR_TBR)
                           + 1024 - ((num + 1) * 4));
        return new_pc;
       }
@@ -209,9 +209,9 @@ fr30_inte (SIM_CPU *current_cpu, PCADDR pc, int num)
      We assume there's a branch there to some handler.  */
   USI new_pc;
   setup_int (current_cpu, pc);
-  a_fr30_h_ilm_set (current_cpu, 4);
+  fr30bf_h_ilm_set (current_cpu, 4);
   new_pc = GETMEMSI (current_cpu, pc,
-                    a_fr30_h_dr_get (current_cpu, H_DR_TBR)
+                    fr30bf_h_dr_get (current_cpu, H_DR_TBR)
                     + 1024 - ((9 + 1) * 4));
   return new_pc;
 }
index 0071781aeecfac937324735eac6bf680b4599e43..f058ca901ff86f31e2598d4d2dc5771c910c8b8f 100644 (file)
@@ -1,3 +1,9 @@
+1999-04-02  Keith Seitz  <keiths@cygnus.com>
+
+       * compile.c (POLL_QUIT_INTERVAL): Define. Used to tweak the
+       frequency at which the poll_quit callback is used.
+       (sim_resume): Use POLL_QUIT_INTERVAL instead of hard-coded value.
+
 Tue Apr 28 18:33:31 1998  Geoffrey Noer  <noer@cygnus.com>
 
         * configure: Regenerated to track ../common/aclocal.m4 changes.
index 0e1fd9cf0c16ab4f0dcd407210c7abb6b3bcceab..2ec759d43db05ea8a586c0f920501681c3a3f068 100644 (file)
@@ -74,6 +74,10 @@ void sim_set_simcache_size PARAMS ((int));
 
 #include "inst.h"
 
+/* The rate at which to call the host's poll_quit callback. */
+
+#define POLL_QUIT_INTERVAL 0x80000
+
 #define LOW_BYTE(x) ((x) & 0xff)
 #define HIGH_BYTE(x) (((x)>>8) & 0xff)
 #define P(X,Y) ((X<<8) | Y)
@@ -1726,7 +1730,7 @@ sim_resume (sd, step, siggnal)
 
       if (--poll_count < 0)
        {
-         poll_count = 100;
+         poll_count = POLL_QUIT_INTERVAL;
          if ((*sim_callback->poll_quit) != NULL
              && (*sim_callback->poll_quit) (sim_callback))
            sim_stop (sd);
index 5a87da546fbaef39d71a06bc3a9557dceb27f6a2..837233c094783f3040ed5e4b3bcbfd2e7405ba92 100644 (file)
@@ -1,3 +1,51 @@
+Fri Apr 16 16:50:31 1999  Doug Evans  <devans@charmed.cygnus.com>
+
+       * devices.c (device_io_read_buffer): New arg `sd'.
+       (device_io_write_buffer): New arg `sd'.
+       (device_error): Give proper arg spec.
+
+1999-04-14  Doug Evans  <devans@casey.cygnus.com>
+
+       * i960-desc.c,i960-desc.h: Rebuild.
+
+Sun Apr 11 00:25:17 1999  Jim Wilson  <wilson@cygnus.com>
+
+       * TODO: Document more toolchain problems.
+       * cpu.h, decode.c, model.c, sem-switch.c, sem.c: Rebuild.
+
+1999-04-10  Doug Evans  <devans@casey.cygnus.com>
+
+       * cpu.h,decode.c,sem-switch.c,sem.c: Rebuild.
+
+Fri Apr  9 19:30:05 1999  Jim Wilson  <wilson@cygnus.com>
+
+       * README, TODO: Clean up and update.
+       * sim-if.c: s/m32r/i960.  s/sparc32/i960.
+       * decode.c, decode.h, i960-desc.c, i960-desc.h, i960-opc.h, model.c,
+       sem-switch.c, sem.c: Rebuild.
+
+1999-03-27  Doug Evans  <devans@casey.cygnus.com>
+
+       * decode.c: Rebuild.
+
+1999-03-22  Doug Evans  <devans@casey.cygnus.com>
+
+       * arch.c,arch.h,model.c,i960-desc.c,i960-desc.h,i960-opc.h: Rebuild.
+       * i960-sim.h (a_i960_h_gr_get,a_i960_h_gr_set): Declare.
+       (a_i960_h_pc_get,a_i960_h_pc_set): Declare.
+       * i960.c (a_i960_h_gr_get,a_i960_h_gr_set): New functions.
+       (a_i960_h_pc_get,a_i960_h_pc_set): Ditto.
+       * sim-if.c (sim_open): Update call to i960_cgen_cpu_open.
+
+1999-03-11  Doug Evans  <devans@casey.cygnus.com>
+
+       * arch.c,arch.h,cpu.c,i960-desc.c,i960-desc.h: Rebuild.
+       * sim-if.c (sim_open): Update call to i960_cgen_cpu_open.
+
+1999-02-25  Doug Evans  <devans@casey.cygnus.com>
+
+       * i960-desc.c,i960-desc.h: Rebuild.
+
 1999-02-09  Doug Evans  <devans@casey.cygnus.com>
 
        * Makefile.in (I960_OBJS): Add i960-desc.o.
index f337558c9f5baeadf1e2cbee490a873b24659ca2..6d38a407dedbc226270b04a215211cc26f761863 100644 (file)
@@ -1,9 +1,18 @@
 This is the i960 simulator directory.
 
-It is still work-in-progress.  The current sources are reasonably
+It is still a work in progress.  The current sources are reasonably
 well tested and lots of features are in.  However, there's lots
 more yet to come.
 
+---
+
+The simulator only supports the i960KA currently.  Not all instructions
+are supported yet, only those instructions needed by the gcc/g++ testsuites
+have been added so far.  There is no profiling support as yet.  There is
+no pipeline or timing support as yet.
+
+---
+
 There are lots of machine generated files in the source directory!
 They are only generated if you configure with --enable-cgen-maint,
 similar in behaviour to Makefile.in, configure under automake/autoconf.
index 263daacbbab962a496a8b225d88d695b54ee12f5..5e156b131bc6544c55ebe6890b6a8fe868203e2d 100644 (file)
@@ -1,9 +1,64 @@
-- header file dependencies revisit
-- hooks cleanup
-- testsuites
-- FIXME's
-- memory accesses still test if profiling is on even in fast mode
-- fill nop counting done even in fast mode
-- have semantic code use G/SET_H_FOO if not default [incl fun-access]
-- have G/SET_H_FOO macros call function if fun-access
-- --> can always use G/S_H_FOO macros
+See ??? comments here and in cgen, and in libgloss/i960.
+
+Simulator:
+
+Update sim/i960 directory from sim/m32r directory.  sim/i960 dir was created
+by copying the sim/m32r in September 1998, and is missing all sim/m32r updates
+since then.
+
+Review, clean up, finish, etc simulator files that are not cgen generated.
+This includes devices.c, i960-sim.h, mloop.in, sim-if.c, sim-main.h,
+tconfig.in, and traps.c.
+
+Some functions do not show up in trace output.  This occasionally happens
+for main.
+
+Gdb core dumps if compile without -mka.  Apparently a problem with recognizing
+"core" machine type.
+
+Get profiling working.
+
+Add pipelining, execution unit, timing, etc info.
+
+Add support for other models, besides KA.
+
+Add support for newer architectures, e.g. v1.1 instructions.
+
+Compiler:
+
+Running gcc gives nm warning from collect about missing a.out file.
+The output file is b.out, not a.out.  Collect is probably looking for
+the wrong file name.
+
+Use of -mca gives lots of linker warnings for ka/ca architecture conflicts,
+but the two architectures are compatible.
+
+Need 96 bit long double support in fp-bit.c, otherwise any testcase using
+long double arithmetic hits an abort and runtime.
+
+Compiler takes far too much time to compile PlumHall testcases at high
+optimization levels.
+
+r2 seems to be an available call-clobbered registers, since it isn't used
+until a call occurs, and is dead when the call returns.
+
+BSP:
+
+Libgloss does not check for syscall error returns, which means errno never
+gets set.
+
+Libgloss does not use the syscall.h file.
+
+Binutils:
+
+Objdump -d fails on 64-bit host, specifically irix6.
+
+Gdb:
+
+Gdb sometimes prints messages about trace/breakpoint trap when hitting a
+breakpoint.
+
+Frame, up, down and related commands don't work.
+
+Gdb fails when next'ing over a leaf function compiled with -mleaf-procedure.
+Gdb fails when step'ing over a return from such a leaf function.
index 5d3ab8462099f1dfdb8ee3d991b4fd957e99b727..74833b06daa63b20521da1f25d18be241729d6c7 100644 (file)
@@ -36,129 +36,3 @@ const MACH *sim_machs[] =
   0
 };
 
-/* Get the value of h-pc.  */
-
-USI
-a_i960_h_pc_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ka_sa : 
-      return i960base_h_pc_get (current_cpu);
-#endif
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ca : 
-      return i960base_h_pc_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-pc.  */
-
-void
-a_i960_h_pc_set (SIM_CPU *current_cpu, USI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ka_sa : 
-      i960base_h_pc_set (current_cpu, newval);
-      break;
-#endif
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ca : 
-      i960base_h_pc_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-gr.  */
-
-SI
-a_i960_h_gr_get (SIM_CPU *current_cpu, UINT regno)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ka_sa : 
-      return i960base_h_gr_get (current_cpu, regno);
-#endif
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ca : 
-      return i960base_h_gr_get (current_cpu, regno);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-gr.  */
-
-void
-a_i960_h_gr_set (SIM_CPU *current_cpu, UINT regno, SI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ka_sa : 
-      i960base_h_gr_set (current_cpu, regno, newval);
-      break;
-#endif
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ca : 
-      i960base_h_gr_set (current_cpu, regno, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-cc.  */
-
-SI
-a_i960_h_cc_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ka_sa : 
-      return i960base_h_cc_get (current_cpu);
-#endif
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ca : 
-      return i960base_h_cc_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-cc.  */
-
-void
-a_i960_h_cc_set (SIM_CPU *current_cpu, SI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ka_sa : 
-      i960base_h_cc_set (current_cpu, newval);
-      break;
-#endif
-#ifdef HAVE_CPU_I960BASE
-    case bfd_mach_i960_ca : 
-      i960base_h_cc_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
index 26dcfd659c403e0255e14af186d46fd81101df8e..fdfbf350b2044b44e32d75f6083f38faa7281581 100644 (file)
@@ -27,14 +27,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #define TARGET_BIG_ENDIAN 1
 
-/* Cover fns for register access.  */
-USI a_i960_h_pc_get (SIM_CPU *);
-void a_i960_h_pc_set (SIM_CPU *, USI);
-SI a_i960_h_gr_get (SIM_CPU *, UINT);
-void a_i960_h_gr_set (SIM_CPU *, UINT, SI);
-SI a_i960_h_cc_get (SIM_CPU *);
-void a_i960_h_cc_set (SIM_CPU *, SI);
-
 /* Enum declaration for model types.  */
 typedef enum model_type {
   MODEL_I960KA, MODEL_I960CA, MODEL_MAX
index aec6a06ee73abf7ef5b8f15578c76357e9e85cdc..c41b643fd11d94c2e6d617cdae905332974825ec 100644 (file)
@@ -26,6 +26,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define WANT_CPU_I960BASE
 
 #include "sim-main.h"
+#include "cgen-ops.h"
 
 /* Get the value of h-pc.  */
 
index 42532b0888d10db81b131774d1f5ff635390f0c9..98879067e0e795b9ccd70623199135e90b9bffa8 100644 (file)
@@ -154,6 +154,34 @@ union sem_fields {
       SI * i_dst;
       unsigned char out_dst;
     } fmt_not3;
+    struct { /* e.g. shlo $src1, $src2, $dst */
+      SI * i_src1;
+      SI * i_src2;
+      SI * i_dst;
+      unsigned char in_src1;
+      unsigned char in_src2;
+      unsigned char out_dst;
+    } fmt_shlo;
+    struct { /* e.g. shlo $lit1, $src2, $dst */
+      UINT f_src1;
+      SI * i_src2;
+      SI * i_dst;
+      unsigned char in_src2;
+      unsigned char out_dst;
+    } fmt_shlo1;
+    struct { /* e.g. shlo $src1, $lit2, $dst */
+      UINT f_src2;
+      SI * i_src1;
+      SI * i_dst;
+      unsigned char in_src1;
+      unsigned char out_dst;
+    } fmt_shlo2;
+    struct { /* e.g. shlo $lit1, $lit2, $dst */
+      UINT f_src1;
+      UINT f_src2;
+      SI * i_dst;
+      unsigned char out_dst;
+    } fmt_shlo3;
     struct { /* e.g. emul $src1, $src2, $dst */
       UINT f_srcdst;
       SI * i_src1;
@@ -162,7 +190,7 @@ union sem_fields {
       unsigned char in_src1;
       unsigned char in_src2;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_emul;
     struct { /* e.g. emul $lit1, $src2, $dst */
       UINT f_srcdst;
@@ -171,7 +199,7 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_src2;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_emul1;
     struct { /* e.g. emul $src1, $lit2, $dst */
       UINT f_srcdst;
@@ -180,7 +208,7 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_src1;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_emul2;
     struct { /* e.g. emul $lit1, $lit2, $dst */
       UINT f_srcdst;
@@ -188,67 +216,67 @@ union sem_fields {
       UINT f_src2;
       SI * i_dst;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_emul3;
     struct { /* e.g. movl $src1, $dst */
       UINT f_src1;
       UINT f_srcdst;
       SI * i_src1;
       SI * i_dst;
-      unsigned char in_h_gr_add__VM_index_of_src1_const__WI_1;
+      unsigned char in_h_gr_add__VM_index_of_src1_1;
       unsigned char in_src1;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_movl;
     struct { /* e.g. movl $lit1, $dst */
       UINT f_srcdst;
       UINT f_src1;
       SI * i_dst;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_movl1;
     struct { /* e.g. movt $src1, $dst */
       UINT f_src1;
       UINT f_srcdst;
       SI * i_src1;
       SI * i_dst;
-      unsigned char in_h_gr_add__VM_index_of_src1_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_src1_const__WI_2;
+      unsigned char in_h_gr_add__VM_index_of_src1_1;
+      unsigned char in_h_gr_add__VM_index_of_src1_2;
       unsigned char in_src1;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
     } fmt_movt;
     struct { /* e.g. movt $lit1, $dst */
       UINT f_srcdst;
       UINT f_src1;
       SI * i_dst;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
     } fmt_movt1;
     struct { /* e.g. movq $src1, $dst */
       UINT f_src1;
       UINT f_srcdst;
       SI * i_src1;
       SI * i_dst;
-      unsigned char in_h_gr_add__VM_index_of_src1_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_src1_const__WI_2;
-      unsigned char in_h_gr_add__VM_index_of_src1_const__WI_3;
+      unsigned char in_h_gr_add__VM_index_of_src1_1;
+      unsigned char in_h_gr_add__VM_index_of_src1_2;
+      unsigned char in_h_gr_add__VM_index_of_src1_3;
       unsigned char in_src1;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_3;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_3;
     } fmt_movq;
     struct { /* e.g. movq $lit1, $dst */
       UINT f_srcdst;
       UINT f_src1;
       SI * i_dst;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_3;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_3;
     } fmt_movq1;
     struct { /* e.g. modpc $src1, $src2, $dst */
       SI * i_src2;
@@ -603,7 +631,7 @@ union sem_fields {
       UINT f_offset;
       SI * i_dst;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_ldl_offset;
     struct { /* e.g. ldl $offset($abase), $dst */
       UINT f_srcdst;
@@ -612,7 +640,7 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_abase;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_ldl_indirect_offset;
     struct { /* e.g. ldl ($abase), $dst */
       UINT f_srcdst;
@@ -620,7 +648,7 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_abase;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_ldl_indirect;
     struct { /* e.g. ldl ($abase)[$index*S$scale], $dst */
       UINT f_srcdst;
@@ -631,14 +659,14 @@ union sem_fields {
       unsigned char in_abase;
       unsigned char in_index;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_ldl_indirect_index;
     struct { /* e.g. ldl $optdisp, $dst */
       UINT f_srcdst;
       UINT f_optdisp;
       SI * i_dst;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_ldl_disp;
     struct { /* e.g. ldl $optdisp($abase), $dst */
       UINT f_srcdst;
@@ -647,7 +675,7 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_abase;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_ldl_indirect_disp;
     struct { /* e.g. ldl $optdisp[$index*S$scale], $dst */
       UINT f_srcdst;
@@ -657,7 +685,7 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_index;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_ldl_index_disp;
     struct { /* e.g. ldl $optdisp($abase)[$index*S$scale], $dst */
       UINT f_srcdst;
@@ -669,15 +697,15 @@ union sem_fields {
       unsigned char in_abase;
       unsigned char in_index;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
     } fmt_ldl_indirect_index_disp;
     struct { /* e.g. ldt $offset, $dst */
       UINT f_srcdst;
       UINT f_offset;
       SI * i_dst;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
     } fmt_ldt_offset;
     struct { /* e.g. ldt $offset($abase), $dst */
       UINT f_srcdst;
@@ -686,8 +714,8 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_abase;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
     } fmt_ldt_indirect_offset;
     struct { /* e.g. ldt ($abase), $dst */
       UINT f_srcdst;
@@ -695,8 +723,8 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_abase;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
     } fmt_ldt_indirect;
     struct { /* e.g. ldt ($abase)[$index*S$scale], $dst */
       UINT f_srcdst;
@@ -707,16 +735,16 @@ union sem_fields {
       unsigned char in_abase;
       unsigned char in_index;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
     } fmt_ldt_indirect_index;
     struct { /* e.g. ldt $optdisp, $dst */
       UINT f_srcdst;
       UINT f_optdisp;
       SI * i_dst;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
     } fmt_ldt_disp;
     struct { /* e.g. ldt $optdisp($abase), $dst */
       UINT f_srcdst;
@@ -725,8 +753,8 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_abase;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
     } fmt_ldt_indirect_disp;
     struct { /* e.g. ldt $optdisp[$index*S$scale], $dst */
       UINT f_srcdst;
@@ -736,8 +764,8 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_index;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
     } fmt_ldt_index_disp;
     struct { /* e.g. ldt $optdisp($abase)[$index*S$scale], $dst */
       UINT f_srcdst;
@@ -749,17 +777,17 @@ union sem_fields {
       unsigned char in_abase;
       unsigned char in_index;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
     } fmt_ldt_indirect_index_disp;
     struct { /* e.g. ldq $offset, $dst */
       UINT f_srcdst;
       UINT f_offset;
       SI * i_dst;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_3;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_3;
     } fmt_ldq_offset;
     struct { /* e.g. ldq $offset($abase), $dst */
       UINT f_srcdst;
@@ -768,9 +796,9 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_abase;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_3;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_3;
     } fmt_ldq_indirect_offset;
     struct { /* e.g. ldq ($abase), $dst */
       UINT f_srcdst;
@@ -778,9 +806,9 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_abase;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_3;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_3;
     } fmt_ldq_indirect;
     struct { /* e.g. ldq ($abase)[$index*S$scale], $dst */
       UINT f_srcdst;
@@ -791,18 +819,18 @@ union sem_fields {
       unsigned char in_abase;
       unsigned char in_index;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_3;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_3;
     } fmt_ldq_indirect_index;
     struct { /* e.g. ldq $optdisp, $dst */
       UINT f_srcdst;
       UINT f_optdisp;
       SI * i_dst;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_3;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_3;
     } fmt_ldq_disp;
     struct { /* e.g. ldq $optdisp($abase), $dst */
       UINT f_srcdst;
@@ -811,9 +839,9 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_abase;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_3;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_3;
     } fmt_ldq_indirect_disp;
     struct { /* e.g. ldq $optdisp[$index*S$scale], $dst */
       UINT f_srcdst;
@@ -823,9 +851,9 @@ union sem_fields {
       SI * i_dst;
       unsigned char in_index;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_3;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_3;
     } fmt_ldq_index_disp;
     struct { /* e.g. ldq $optdisp($abase)[$index*S$scale], $dst */
       UINT f_srcdst;
@@ -837,9 +865,9 @@ union sem_fields {
       unsigned char in_abase;
       unsigned char in_index;
       unsigned char out_dst;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_1;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_2;
-      unsigned char out_h_gr_add__VM_index_of_dst_const__WI_3;
+      unsigned char out_h_gr_add__VM_index_of_dst_1;
+      unsigned char out_h_gr_add__VM_index_of_dst_2;
+      unsigned char out_h_gr_add__VM_index_of_dst_3;
     } fmt_ldq_indirect_index_disp;
     struct { /* e.g. st $st_src, $offset */
       UINT f_offset;
@@ -1016,7 +1044,7 @@ union sem_fields {
       UINT f_srcdst;
       UINT f_offset;
       SI * i_st_src;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
       unsigned char in_st_src;
     } fmt_stl_offset;
     struct { /* e.g. stl $st_src, $offset($abase) */
@@ -1025,7 +1053,7 @@ union sem_fields {
       SI * i_abase;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
       unsigned char in_st_src;
     } fmt_stl_indirect_offset;
     struct { /* e.g. stl $st_src, ($abase) */
@@ -1033,7 +1061,7 @@ union sem_fields {
       SI * i_abase;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
       unsigned char in_st_src;
     } fmt_stl_indirect;
     struct { /* e.g. stl $st_src, ($abase)[$index*S$scale] */
@@ -1043,7 +1071,7 @@ union sem_fields {
       SI * i_index;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
       unsigned char in_index;
       unsigned char in_st_src;
     } fmt_stl_indirect_index;
@@ -1051,7 +1079,7 @@ union sem_fields {
       UINT f_srcdst;
       UINT f_optdisp;
       SI * i_st_src;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
       unsigned char in_st_src;
     } fmt_stl_disp;
     struct { /* e.g. stl $st_src, $optdisp($abase) */
@@ -1060,7 +1088,7 @@ union sem_fields {
       SI * i_abase;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
       unsigned char in_st_src;
     } fmt_stl_indirect_disp;
     struct { /* e.g. stl $st_src, $optdisp[$index*S$scale */
@@ -1069,7 +1097,7 @@ union sem_fields {
       UINT f_scale;
       SI * i_index;
       SI * i_st_src;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
       unsigned char in_index;
       unsigned char in_st_src;
     } fmt_stl_index_disp;
@@ -1081,7 +1109,7 @@ union sem_fields {
       SI * i_index;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
       unsigned char in_index;
       unsigned char in_st_src;
     } fmt_stl_indirect_index_disp;
@@ -1089,8 +1117,8 @@ union sem_fields {
       UINT f_srcdst;
       UINT f_offset;
       SI * i_st_src;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
       unsigned char in_st_src;
     } fmt_stt_offset;
     struct { /* e.g. stt $st_src, $offset($abase) */
@@ -1099,8 +1127,8 @@ union sem_fields {
       SI * i_abase;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
       unsigned char in_st_src;
     } fmt_stt_indirect_offset;
     struct { /* e.g. stt $st_src, ($abase) */
@@ -1108,8 +1136,8 @@ union sem_fields {
       SI * i_abase;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
       unsigned char in_st_src;
     } fmt_stt_indirect;
     struct { /* e.g. stt $st_src, ($abase)[$index*S$scale] */
@@ -1119,8 +1147,8 @@ union sem_fields {
       SI * i_index;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
       unsigned char in_index;
       unsigned char in_st_src;
     } fmt_stt_indirect_index;
@@ -1128,8 +1156,8 @@ union sem_fields {
       UINT f_srcdst;
       UINT f_optdisp;
       SI * i_st_src;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
       unsigned char in_st_src;
     } fmt_stt_disp;
     struct { /* e.g. stt $st_src, $optdisp($abase) */
@@ -1138,8 +1166,8 @@ union sem_fields {
       SI * i_abase;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
       unsigned char in_st_src;
     } fmt_stt_indirect_disp;
     struct { /* e.g. stt $st_src, $optdisp[$index*S$scale */
@@ -1148,8 +1176,8 @@ union sem_fields {
       UINT f_scale;
       SI * i_index;
       SI * i_st_src;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
       unsigned char in_index;
       unsigned char in_st_src;
     } fmt_stt_index_disp;
@@ -1161,8 +1189,8 @@ union sem_fields {
       SI * i_index;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
       unsigned char in_index;
       unsigned char in_st_src;
     } fmt_stt_indirect_index_disp;
@@ -1170,9 +1198,9 @@ union sem_fields {
       UINT f_srcdst;
       UINT f_offset;
       SI * i_st_src;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_3;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_3;
       unsigned char in_st_src;
     } fmt_stq_offset;
     struct { /* e.g. stq $st_src, $offset($abase) */
@@ -1181,9 +1209,9 @@ union sem_fields {
       SI * i_abase;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_3;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_3;
       unsigned char in_st_src;
     } fmt_stq_indirect_offset;
     struct { /* e.g. stq $st_src, ($abase) */
@@ -1191,9 +1219,9 @@ union sem_fields {
       SI * i_abase;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_3;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_3;
       unsigned char in_st_src;
     } fmt_stq_indirect;
     struct { /* e.g. stq $st_src, ($abase)[$index*S$scale] */
@@ -1203,9 +1231,9 @@ union sem_fields {
       SI * i_index;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_3;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_3;
       unsigned char in_index;
       unsigned char in_st_src;
     } fmt_stq_indirect_index;
@@ -1213,9 +1241,9 @@ union sem_fields {
       UINT f_srcdst;
       UINT f_optdisp;
       SI * i_st_src;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_3;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_3;
       unsigned char in_st_src;
     } fmt_stq_disp;
     struct { /* e.g. stq $st_src, $optdisp($abase) */
@@ -1224,9 +1252,9 @@ union sem_fields {
       SI * i_abase;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_3;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_3;
       unsigned char in_st_src;
     } fmt_stq_indirect_disp;
     struct { /* e.g. stq $st_src, $optdisp[$index*S$scale */
@@ -1235,9 +1263,9 @@ union sem_fields {
       UINT f_scale;
       SI * i_index;
       SI * i_st_src;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_3;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_3;
       unsigned char in_index;
       unsigned char in_st_src;
     } fmt_stq_index_disp;
@@ -1249,9 +1277,9 @@ union sem_fields {
       SI * i_index;
       SI * i_st_src;
       unsigned char in_abase;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_1;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_2;
-      unsigned char in_h_gr_add__VM_index_of_st_src_const__WI_3;
+      unsigned char in_h_gr_add__VM_index_of_st_src_1;
+      unsigned char in_h_gr_add__VM_index_of_st_src_2;
+      unsigned char in_h_gr_add__VM_index_of_st_src_3;
       unsigned char in_index;
       unsigned char in_st_src;
     } fmt_stq_indirect_index_disp;
index 2bb81eec04fe443600c34e60f2ceddbd8fb5f6a7..a3ac52347f28a1fc2acf4eee53098c010d89faae 100644 (file)
@@ -46,6 +46,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define FAST(fn)
 #endif
 
+/* The INSN_ prefix is not here and is instead part of the `insn' argument
+   to avoid collisions with header files (e.g. `AND' in ansidecl.h).  */
+#define IDX(insn) CONCAT2 (I960BASE_,insn)
+#define TYPE(insn) CONCAT2 (I960_,insn)
+
 /* The instruction descriptor array.
    This is computed at runtime.  Space for it is not malloc'd to save a
    teensy bit of cpu in the decoder.  Moving it to malloc space is trivial
@@ -53,11 +58,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
    addition of instructions nor an SMP machine with different cpus).  */
 static IDESC i960base_insn_data[I960BASE_INSN_MAX];
 
-/* The INSN_ prefix is not here and is instead part of the `insn' argument
-   to avoid collisions with header files (e.g. `AND' in ansidecl.h).  */
-#define IDX(insn) CONCAT2 (I960BASE_,insn)
-#define TYPE(insn) CONCAT2 (I960_,insn)
-
 /* Commas between elements are contained in the macros.
    Some of these are conditionally compiled out.  */
 
@@ -129,10 +129,18 @@ static const struct insn_sem i960base_insn_sem[] =
   { TYPE (INSN_NOR1), IDX (INSN_NOR1), FULL (nor1) FAST (nor1) },
   { TYPE (INSN_NOR2), IDX (INSN_NOR2), FULL (nor2) FAST (nor2) },
   { TYPE (INSN_NOR3), IDX (INSN_NOR3), FULL (nor3) FAST (nor3) },
+  { TYPE (INSN_XNOR), IDX (INSN_XNOR), FULL (xnor) FAST (xnor) },
+  { TYPE (INSN_XNOR1), IDX (INSN_XNOR1), FULL (xnor1) FAST (xnor1) },
+  { TYPE (INSN_XNOR2), IDX (INSN_XNOR2), FULL (xnor2) FAST (xnor2) },
+  { TYPE (INSN_XNOR3), IDX (INSN_XNOR3), FULL (xnor3) FAST (xnor3) },
   { TYPE (INSN_NOT), IDX (INSN_NOT), FULL (not) FAST (not) },
   { TYPE (INSN_NOT1), IDX (INSN_NOT1), FULL (not1) FAST (not1) },
   { TYPE (INSN_NOT2), IDX (INSN_NOT2), FULL (not2) FAST (not2) },
   { TYPE (INSN_NOT3), IDX (INSN_NOT3), FULL (not3) FAST (not3) },
+  { TYPE (INSN_ORNOT), IDX (INSN_ORNOT), FULL (ornot) FAST (ornot) },
+  { TYPE (INSN_ORNOT1), IDX (INSN_ORNOT1), FULL (ornot1) FAST (ornot1) },
+  { TYPE (INSN_ORNOT2), IDX (INSN_ORNOT2), FULL (ornot2) FAST (ornot2) },
+  { TYPE (INSN_ORNOT3), IDX (INSN_ORNOT3), FULL (ornot3) FAST (ornot3) },
   { TYPE (INSN_CLRBIT), IDX (INSN_CLRBIT), FULL (clrbit) FAST (clrbit) },
   { TYPE (INSN_CLRBIT1), IDX (INSN_CLRBIT1), FULL (clrbit1) FAST (clrbit1) },
   { TYPE (INSN_CLRBIT2), IDX (INSN_CLRBIT2), FULL (clrbit2) FAST (clrbit2) },
@@ -359,6 +367,9 @@ static const struct insn_sem i960base_insn_sem_invalid =
   VIRTUAL_INSN_X_INVALID, IDX (INSN_X_INVALID), FULL (x_invalid) FAST (x_invalid)
 };
 
+#undef FMT
+#undef FULL
+#undef FAST
 #undef IDX
 #undef TYPE
 
@@ -420,80 +431,6 @@ i960base_init_idesc_table (SIM_CPU *cpu)
   CPU_IDESC (cpu) = table;
 }
 
-/* Enum declaration for all instruction semantic formats.  */
-typedef enum sfmt {
-  FMT_EMPTY, FMT_MULO, FMT_MULO1, FMT_MULO2
- , FMT_MULO3, FMT_NOTBIT, FMT_NOTBIT1, FMT_NOTBIT2
- , FMT_NOTBIT3, FMT_NOT, FMT_NOT1, FMT_NOT2
- , FMT_NOT3, FMT_EMUL, FMT_EMUL1, FMT_EMUL2
- , FMT_EMUL3, FMT_MOVL, FMT_MOVL1, FMT_MOVT
- , FMT_MOVT1, FMT_MOVQ, FMT_MOVQ1, FMT_MODPC
- , FMT_LDA_OFFSET, FMT_LDA_INDIRECT_OFFSET, FMT_LDA_INDIRECT, FMT_LDA_INDIRECT_INDEX
- , FMT_LDA_DISP, FMT_LDA_INDIRECT_DISP, FMT_LDA_INDEX_DISP, FMT_LDA_INDIRECT_INDEX_DISP
- , FMT_LD_OFFSET, FMT_LD_INDIRECT_OFFSET, FMT_LD_INDIRECT, FMT_LD_INDIRECT_INDEX
- , FMT_LD_DISP, FMT_LD_INDIRECT_DISP, FMT_LD_INDEX_DISP, FMT_LD_INDIRECT_INDEX_DISP
- , FMT_LDOB_OFFSET, FMT_LDOB_INDIRECT_OFFSET, FMT_LDOB_INDIRECT, FMT_LDOB_INDIRECT_INDEX
- , FMT_LDOB_DISP, FMT_LDOB_INDIRECT_DISP, FMT_LDOB_INDEX_DISP, FMT_LDOB_INDIRECT_INDEX_DISP
- , FMT_LDOS_OFFSET, FMT_LDOS_INDIRECT_OFFSET, FMT_LDOS_INDIRECT, FMT_LDOS_INDIRECT_INDEX
- , FMT_LDOS_DISP, FMT_LDOS_INDIRECT_DISP, FMT_LDOS_INDEX_DISP, FMT_LDOS_INDIRECT_INDEX_DISP
- , FMT_LDIB_OFFSET, FMT_LDIB_INDIRECT_OFFSET, FMT_LDIB_INDIRECT, FMT_LDIB_INDIRECT_INDEX
- , FMT_LDIB_DISP, FMT_LDIB_INDIRECT_DISP, FMT_LDIB_INDEX_DISP, FMT_LDIB_INDIRECT_INDEX_DISP
- , FMT_LDIS_OFFSET, FMT_LDIS_INDIRECT_OFFSET, FMT_LDIS_INDIRECT, FMT_LDIS_INDIRECT_INDEX
- , FMT_LDIS_DISP, FMT_LDIS_INDIRECT_DISP, FMT_LDIS_INDEX_DISP, FMT_LDIS_INDIRECT_INDEX_DISP
- , FMT_LDL_OFFSET, FMT_LDL_INDIRECT_OFFSET, FMT_LDL_INDIRECT, FMT_LDL_INDIRECT_INDEX
- , FMT_LDL_DISP, FMT_LDL_INDIRECT_DISP, FMT_LDL_INDEX_DISP, FMT_LDL_INDIRECT_INDEX_DISP
- , FMT_LDT_OFFSET, FMT_LDT_INDIRECT_OFFSET, FMT_LDT_INDIRECT, FMT_LDT_INDIRECT_INDEX
- , FMT_LDT_DISP, FMT_LDT_INDIRECT_DISP, FMT_LDT_INDEX_DISP, FMT_LDT_INDIRECT_INDEX_DISP
- , FMT_LDQ_OFFSET, FMT_LDQ_INDIRECT_OFFSET, FMT_LDQ_INDIRECT, FMT_LDQ_INDIRECT_INDEX
- , FMT_LDQ_DISP, FMT_LDQ_INDIRECT_DISP, FMT_LDQ_INDEX_DISP, FMT_LDQ_INDIRECT_INDEX_DISP
- , FMT_ST_OFFSET, FMT_ST_INDIRECT_OFFSET, FMT_ST_INDIRECT, FMT_ST_INDIRECT_INDEX
- , FMT_ST_DISP, FMT_ST_INDIRECT_DISP, FMT_ST_INDEX_DISP, FMT_ST_INDIRECT_INDEX_DISP
- , FMT_STOB_OFFSET, FMT_STOB_INDIRECT_OFFSET, FMT_STOB_INDIRECT, FMT_STOB_INDIRECT_INDEX
- , FMT_STOB_DISP, FMT_STOB_INDIRECT_DISP, FMT_STOB_INDEX_DISP, FMT_STOB_INDIRECT_INDEX_DISP
- , FMT_STOS_OFFSET, FMT_STOS_INDIRECT_OFFSET, FMT_STOS_INDIRECT, FMT_STOS_INDIRECT_INDEX
- , FMT_STOS_DISP, FMT_STOS_INDIRECT_DISP, FMT_STOS_INDEX_DISP, FMT_STOS_INDIRECT_INDEX_DISP
- , FMT_STL_OFFSET, FMT_STL_INDIRECT_OFFSET, FMT_STL_INDIRECT, FMT_STL_INDIRECT_INDEX
- , FMT_STL_DISP, FMT_STL_INDIRECT_DISP, FMT_STL_INDEX_DISP, FMT_STL_INDIRECT_INDEX_DISP
- , FMT_STT_OFFSET, FMT_STT_INDIRECT_OFFSET, FMT_STT_INDIRECT, FMT_STT_INDIRECT_INDEX
- , FMT_STT_DISP, FMT_STT_INDIRECT_DISP, FMT_STT_INDEX_DISP, FMT_STT_INDIRECT_INDEX_DISP
- , FMT_STQ_OFFSET, FMT_STQ_INDIRECT_OFFSET, FMT_STQ_INDIRECT, FMT_STQ_INDIRECT_INDEX
- , FMT_STQ_DISP, FMT_STQ_INDIRECT_DISP, FMT_STQ_INDEX_DISP, FMT_STQ_INDIRECT_INDEX_DISP
- , FMT_CMPOBE_REG, FMT_CMPOBE_LIT, FMT_CMPOBL_REG, FMT_CMPOBL_LIT
- , FMT_BBC_REG, FMT_BBC_LIT, FMT_CMPI, FMT_CMPI1
- , FMT_CMPI2, FMT_CMPI3, FMT_CMPO, FMT_CMPO1
- , FMT_CMPO2, FMT_CMPO3, FMT_TESTNO_REG, FMT_BNO
- , FMT_B, FMT_BX_INDIRECT_OFFSET, FMT_BX_INDIRECT, FMT_BX_INDIRECT_INDEX
- , FMT_BX_DISP, FMT_BX_INDIRECT_DISP, FMT_CALLX_DISP, FMT_CALLX_INDIRECT
- , FMT_CALLX_INDIRECT_OFFSET, FMT_RET, FMT_CALLS, FMT_FMARK
- , FMT_FLUSHREG
-} SFMT;
-
-/* The decoder uses this to record insns and direct extraction handling.  */
-
-typedef struct {
-  const IDESC *idesc;
-#ifdef __GNUC__
-  void *sfmt;
-#else
-  enum sfmt sfmt;
-#endif
-} DECODE_DESC;
-
-/* Macro to go from decode phase to extraction phase.  */
-
-#ifdef __GNUC__
-#define GOTO_EXTRACT(id) goto *(id)->sfmt
-#else
-#define GOTO_EXTRACT(id) goto extract
-#endif
-
-/* The decoder needs a slightly different computed goto switch control.  */
-#ifdef __GNUC__
-#define DECODE_SWITCH(N, X) goto *labels_##N[X];
-#else
-#define DECODE_SWITCH(N, X) switch (X)
-#endif
-
 /* Given an instruction, return a pointer to its IDESC entry.  */
 
 const IDESC *
@@ -501,1409 +438,981 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
               CGEN_INSN_INT base_insn,
               ARGBUF *abuf)
 {
-  /* Result of decoder, used by extractor.  */
-  const DECODE_DESC *idecode;
-
-  /* First decode the instruction.  */
+  /* Result of decoder.  */
+  I960BASE_INSN_TYPE itype;
 
   {
-#define I(insn) & i960base_insn_data[CONCAT2 (I960BASE_,insn)]
-#ifdef __GNUC__
-#define E(fmt) && case_ex_##fmt
-#else
-#define E(fmt) fmt
-#endif
-    CGEN_INSN_INT insn = base_insn;
-    static const DECODE_DESC idecode_invalid = { I (INSN_X_INVALID), E (FMT_EMPTY) };
-
-    {
-#ifdef __GNUC__
-      static const void *labels_0[256] = {
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_48, && case_0_49, && case_0_50, && case_0_51, 
-        && case_0_52, && case_0_53, && case_0_54, && case_0_55, 
-        && default_0, && case_0_57, && case_0_58, && case_0_59, 
-        && case_0_60, && case_0_61, && case_0_62, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_88, && case_0_89, && case_0_90, && default_0, 
-        && case_0_92, && case_0_93, && case_0_94, && case_0_95, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && case_0_102, && case_0_103, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_112, && default_0, && default_0, && default_0, 
-        && case_0_116, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_128, && default_0, && case_0_130, && default_0, 
-        && case_0_132, && default_0, && case_0_134, && default_0, 
-        && case_0_136, && default_0, && case_0_138, && default_0, 
-        && case_0_140, && default_0, && default_0, && default_0, 
-        && case_0_144, && default_0, && case_0_146, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_152, && default_0, && case_0_154, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_160, && default_0, && case_0_162, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_176, && default_0, && case_0_178, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_192, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_200, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-      };
-#endif
-      static const DECODE_DESC insns[256] = {
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_B), E (FMT_B) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_RET), E (FMT_RET) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_BNO), E (FMT_BNO) }, { I (INSN_BG), E (FMT_BNO) }, 
-        { I (INSN_BE), E (FMT_BNO) }, { I (INSN_BGE), E (FMT_BNO) }, 
-        { I (INSN_BL), E (FMT_BNO) }, { I (INSN_BNE), E (FMT_BNO) }, 
-        { I (INSN_BLE), E (FMT_BNO) }, { I (INSN_BO), E (FMT_BNO) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_TESTNO_REG), E (FMT_TESTNO_REG) }, { I (INSN_TESTG_REG), E (FMT_TESTNO_REG) }, 
-        { I (INSN_TESTE_REG), E (FMT_TESTNO_REG) }, { I (INSN_TESTGE_REG), E (FMT_TESTNO_REG) }, 
-        { I (INSN_TESTL_REG), E (FMT_TESTNO_REG) }, { I (INSN_TESTNE_REG), E (FMT_TESTNO_REG) }, 
-        { I (INSN_TESTLE_REG), E (FMT_TESTNO_REG) }, { I (INSN_TESTO_REG), E (FMT_TESTNO_REG) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { 0 }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_MODAC), E (FMT_MODPC) }, { I (INSN_MODPC), E (FMT_MODPC) }, 
-        { 0 }, { 0 }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-      };
-      unsigned int val;
-      val = (((insn >> 24) & (255 << 0)));
-      DECODE_SWITCH (0, val)
+    CGEN_INSN_INT insn = base_insn;
+
+    {
+      unsigned int val = (((insn >> 24) & (255 << 0)));
+      switch (val)
+      {
+      case 8 : itype = I960BASE_INSN_B; goto extract_fmt_b;
+      case 10 : itype = I960BASE_INSN_RET; goto extract_fmt_ret;
+      case 16 : itype = I960BASE_INSN_BNO; goto extract_fmt_bno;
+      case 17 : itype = I960BASE_INSN_BG; goto extract_fmt_bno;
+      case 18 : itype = I960BASE_INSN_BE; goto extract_fmt_bno;
+      case 19 : itype = I960BASE_INSN_BGE; goto extract_fmt_bno;
+      case 20 : itype = I960BASE_INSN_BL; goto extract_fmt_bno;
+      case 21 : itype = I960BASE_INSN_BNE; goto extract_fmt_bno;
+      case 22 : itype = I960BASE_INSN_BLE; goto extract_fmt_bno;
+      case 23 : itype = I960BASE_INSN_BO; goto extract_fmt_bno;
+      case 32 : itype = I960BASE_INSN_TESTNO_REG; goto extract_fmt_testno_reg;
+      case 33 : itype = I960BASE_INSN_TESTG_REG; goto extract_fmt_testno_reg;
+      case 34 : itype = I960BASE_INSN_TESTE_REG; goto extract_fmt_testno_reg;
+      case 35 : itype = I960BASE_INSN_TESTGE_REG; goto extract_fmt_testno_reg;
+      case 36 : itype = I960BASE_INSN_TESTL_REG; goto extract_fmt_testno_reg;
+      case 37 : itype = I960BASE_INSN_TESTNE_REG; goto extract_fmt_testno_reg;
+      case 38 : itype = I960BASE_INSN_TESTLE_REG; goto extract_fmt_testno_reg;
+      case 39 : itype = I960BASE_INSN_TESTO_REG; goto extract_fmt_testno_reg;
+      case 48 :
         {
-        CASE (0, 48) :
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_BBC_REG), E (FMT_BBC_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_BBC_LIT), E (FMT_BBC_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_BBC_REG; goto extract_fmt_bbc_reg;
+          case 4 : itype = I960BASE_INSN_BBC_LIT; goto extract_fmt_bbc_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 49) :
+        }
+      case 49 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPOBG_REG), E (FMT_CMPOBL_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPOBG_LIT), E (FMT_CMPOBL_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPOBG_REG; goto extract_fmt_cmpobl_reg;
+          case 4 : itype = I960BASE_INSN_CMPOBG_LIT; goto extract_fmt_cmpobl_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 50) :
+        }
+      case 50 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPOBE_REG), E (FMT_CMPOBE_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPOBE_LIT), E (FMT_CMPOBE_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPOBE_REG; goto extract_fmt_cmpobe_reg;
+          case 4 : itype = I960BASE_INSN_CMPOBE_LIT; goto extract_fmt_cmpobe_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 51) :
+        }
+      case 51 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPOBGE_REG), E (FMT_CMPOBL_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPOBGE_LIT), E (FMT_CMPOBL_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPOBGE_REG; goto extract_fmt_cmpobl_reg;
+          case 4 : itype = I960BASE_INSN_CMPOBGE_LIT; goto extract_fmt_cmpobl_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 52) :
+        }
+      case 52 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPOBL_REG), E (FMT_CMPOBL_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPOBL_LIT), E (FMT_CMPOBL_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPOBL_REG; goto extract_fmt_cmpobl_reg;
+          case 4 : itype = I960BASE_INSN_CMPOBL_LIT; goto extract_fmt_cmpobl_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 53) :
+        }
+      case 53 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPOBNE_REG), E (FMT_CMPOBE_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPOBNE_LIT), E (FMT_CMPOBE_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPOBNE_REG; goto extract_fmt_cmpobe_reg;
+          case 4 : itype = I960BASE_INSN_CMPOBNE_LIT; goto extract_fmt_cmpobe_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 54) :
+        }
+      case 54 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPOBLE_REG), E (FMT_CMPOBL_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPOBLE_LIT), E (FMT_CMPOBL_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPOBLE_REG; goto extract_fmt_cmpobl_reg;
+          case 4 : itype = I960BASE_INSN_CMPOBLE_LIT; goto extract_fmt_cmpobl_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 55) :
+        }
+      case 55 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_BBS_REG), E (FMT_BBC_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_BBS_LIT), E (FMT_BBC_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_BBS_REG; goto extract_fmt_bbc_reg;
+          case 4 : itype = I960BASE_INSN_BBS_LIT; goto extract_fmt_bbc_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 57) :
+        }
+      case 57 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPIBG_REG), E (FMT_CMPOBE_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPIBG_LIT), E (FMT_CMPOBE_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPIBG_REG; goto extract_fmt_cmpobe_reg;
+          case 4 : itype = I960BASE_INSN_CMPIBG_LIT; goto extract_fmt_cmpobe_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 58) :
+        }
+      case 58 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPIBE_REG), E (FMT_CMPOBE_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPIBE_LIT), E (FMT_CMPOBE_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPIBE_REG; goto extract_fmt_cmpobe_reg;
+          case 4 : itype = I960BASE_INSN_CMPIBE_LIT; goto extract_fmt_cmpobe_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 59) :
+        }
+      case 59 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPIBGE_REG), E (FMT_CMPOBE_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPIBGE_LIT), E (FMT_CMPOBE_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPIBGE_REG; goto extract_fmt_cmpobe_reg;
+          case 4 : itype = I960BASE_INSN_CMPIBGE_LIT; goto extract_fmt_cmpobe_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 60) :
+        }
+      case 60 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPIBL_REG), E (FMT_CMPOBE_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPIBL_LIT), E (FMT_CMPOBE_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPIBL_REG; goto extract_fmt_cmpobe_reg;
+          case 4 : itype = I960BASE_INSN_CMPIBL_LIT; goto extract_fmt_cmpobe_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 61) :
+        }
+      case 61 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPIBNE_REG), E (FMT_CMPOBE_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPIBNE_LIT), E (FMT_CMPOBE_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPIBNE_REG; goto extract_fmt_cmpobe_reg;
+          case 4 : itype = I960BASE_INSN_CMPIBNE_LIT; goto extract_fmt_cmpobe_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 62) :
+        }
+      case 62 :
+        {
+          unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[8] = {
-              { I (INSN_CMPIBLE_REG), E (FMT_CMPOBE_REG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CMPIBLE_LIT), E (FMT_CMPOBE_LIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 11) & (1 << 2)) | ((insn >> 0) & (3 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_CMPIBLE_REG; goto extract_fmt_cmpobe_reg;
+          case 4 : itype = I960BASE_INSN_CMPIBLE_LIT; goto extract_fmt_cmpobe_lit;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 88) :
+        }
+      case 88 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-#ifdef __GNUC__
-            static const void *labels_0_88[16] = {
-              && case_0_88_0, && case_0_88_1, && case_0_88_2, && case_0_88_3, 
-              && case_0_88_4, && case_0_88_5, && case_0_88_6, && case_0_88_7, 
-              && default_0_88, && default_0_88, && default_0_88, && default_0_88, 
-              && default_0_88, && default_0_88, && default_0_88, && default_0_88, 
-            };
-#endif
-            static const DECODE_DESC insns[16] = {
-              { 0 }, { 0 }, 
-              { 0 }, { 0 }, 
-              { 0 }, { 0 }, 
-              { 0 }, { 0 }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val;
-            val = (((insn >> 10) & (15 << 0)));
-            DECODE_SWITCH (0_88, val)
+          case 0 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_NOTBIT; goto extract_fmt_notbit;
+              case 2 : itype = I960BASE_INSN_AND; goto extract_fmt_mulo;
+              case 4 : itype = I960BASE_INSN_ANDNOT; goto extract_fmt_mulo;
+              case 6 : itype = I960BASE_INSN_SETBIT; goto extract_fmt_notbit;
+              case 8 : itype = I960BASE_INSN_NOTAND; goto extract_fmt_mulo;
+              case 12 : itype = I960BASE_INSN_XOR; goto extract_fmt_mulo;
+              case 14 : itype = I960BASE_INSN_OR; goto extract_fmt_mulo;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 1 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_NOR; goto extract_fmt_mulo;
+              case 2 : itype = I960BASE_INSN_XNOR; goto extract_fmt_mulo;
+              case 4 : itype = I960BASE_INSN_NOT; goto extract_fmt_not;
+              case 6 : itype = I960BASE_INSN_ORNOT; goto extract_fmt_mulo;
+              case 8 : itype = I960BASE_INSN_CLRBIT; goto extract_fmt_notbit;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 2 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_NOTBIT1; goto extract_fmt_notbit1;
+              case 2 : itype = I960BASE_INSN_AND1; goto extract_fmt_mulo1;
+              case 4 : itype = I960BASE_INSN_ANDNOT1; goto extract_fmt_mulo1;
+              case 6 : itype = I960BASE_INSN_SETBIT1; goto extract_fmt_notbit1;
+              case 8 : itype = I960BASE_INSN_NOTAND1; goto extract_fmt_mulo1;
+              case 12 : itype = I960BASE_INSN_XOR1; goto extract_fmt_mulo1;
+              case 14 : itype = I960BASE_INSN_OR1; goto extract_fmt_mulo1;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 3 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_NOR1; goto extract_fmt_mulo1;
+              case 2 : itype = I960BASE_INSN_XNOR1; goto extract_fmt_mulo1;
+              case 4 : itype = I960BASE_INSN_NOT1; goto extract_fmt_not1;
+              case 6 : itype = I960BASE_INSN_ORNOT1; goto extract_fmt_mulo1;
+              case 8 : itype = I960BASE_INSN_CLRBIT1; goto extract_fmt_notbit1;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 4 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_NOTBIT2; goto extract_fmt_notbit2;
+              case 2 : itype = I960BASE_INSN_AND2; goto extract_fmt_mulo2;
+              case 4 : itype = I960BASE_INSN_ANDNOT2; goto extract_fmt_mulo2;
+              case 6 : itype = I960BASE_INSN_SETBIT2; goto extract_fmt_notbit2;
+              case 8 : itype = I960BASE_INSN_NOTAND2; goto extract_fmt_mulo2;
+              case 12 : itype = I960BASE_INSN_XOR2; goto extract_fmt_mulo2;
+              case 14 : itype = I960BASE_INSN_OR2; goto extract_fmt_mulo2;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 5 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_NOR2; goto extract_fmt_mulo2;
+              case 2 : itype = I960BASE_INSN_XNOR2; goto extract_fmt_mulo2;
+              case 4 : itype = I960BASE_INSN_NOT2; goto extract_fmt_not2;
+              case 6 : itype = I960BASE_INSN_ORNOT2; goto extract_fmt_mulo2;
+              case 8 : itype = I960BASE_INSN_CLRBIT2; goto extract_fmt_notbit2;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 6 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_NOTBIT3; goto extract_fmt_notbit3;
+              case 2 : itype = I960BASE_INSN_AND3; goto extract_fmt_mulo3;
+              case 4 : itype = I960BASE_INSN_ANDNOT3; goto extract_fmt_mulo3;
+              case 6 : itype = I960BASE_INSN_SETBIT3; goto extract_fmt_notbit3;
+              case 8 : itype = I960BASE_INSN_NOTAND3; goto extract_fmt_mulo3;
+              case 12 : itype = I960BASE_INSN_XOR3; goto extract_fmt_mulo3;
+              case 14 : itype = I960BASE_INSN_OR3; goto extract_fmt_mulo3;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 7 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
               {
-              CASE (0_88, 0) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_NOTBIT), E (FMT_NOTBIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_AND), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_ANDNOT), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SETBIT), E (FMT_NOTBIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_NOTAND), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_XOR), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_OR), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_88, 1) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_NOR), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_NOT), E (FMT_NOT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_CLRBIT), E (FMT_NOTBIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_88, 2) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_NOTBIT1), E (FMT_NOTBIT1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_AND1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_ANDNOT1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SETBIT1), E (FMT_NOTBIT1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_NOTAND1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_XOR1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_OR1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_88, 3) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_NOR1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_NOT1), E (FMT_NOT1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_CLRBIT1), E (FMT_NOTBIT1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_88, 4) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_NOTBIT2), E (FMT_NOTBIT2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_AND2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_ANDNOT2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SETBIT2), E (FMT_NOTBIT2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_NOTAND2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_XOR2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_OR2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_88, 5) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_NOR2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_NOT2), E (FMT_NOT2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_CLRBIT2), E (FMT_NOTBIT2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_88, 6) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_NOTBIT3), E (FMT_NOTBIT3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_AND3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_ANDNOT3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SETBIT3), E (FMT_NOTBIT3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_NOTAND3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_XOR3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_OR3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_88, 7) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_NOR3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_NOT3), E (FMT_NOT3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_CLRBIT3), E (FMT_NOTBIT3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              DEFAULT (0_88) :
-                idecode = &insns[val];
-                GOTO_EXTRACT (idecode);
+              case 0 : itype = I960BASE_INSN_NOR3; goto extract_fmt_mulo3;
+              case 2 : itype = I960BASE_INSN_XNOR3; goto extract_fmt_mulo3;
+              case 4 : itype = I960BASE_INSN_NOT3; goto extract_fmt_not3;
+              case 6 : itype = I960BASE_INSN_ORNOT3; goto extract_fmt_mulo3;
+              case 8 : itype = I960BASE_INSN_CLRBIT3; goto extract_fmt_notbit3;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
               }
-            ENDSWITCH (0_88)
+            }
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 89) :
+        }
+      case 89 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-#ifdef __GNUC__
-            static const void *labels_0_89[16] = {
-              && case_0_89_0, && case_0_89_1, && case_0_89_2, && case_0_89_3, 
-              && case_0_89_4, && case_0_89_5, && case_0_89_6, && case_0_89_7, 
-              && default_0_89, && default_0_89, && default_0_89, && default_0_89, 
-              && default_0_89, && default_0_89, && default_0_89, && default_0_89, 
-            };
-#endif
-            static const DECODE_DESC insns[16] = {
-              { 0 }, { 0 }, 
-              { 0 }, { 0 }, 
-              { 0 }, { 0 }, 
-              { 0 }, { 0 }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val;
-            val = (((insn >> 10) & (15 << 0)));
-            DECODE_SWITCH (0_89, val)
+          case 0 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_ADDO; goto extract_fmt_mulo;
+              case 4 : itype = I960BASE_INSN_SUBO; goto extract_fmt_mulo;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 1 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_SHRO; goto extract_fmt_shlo;
+              case 6 : itype = I960BASE_INSN_SHRI; goto extract_fmt_shlo;
+              case 8 : itype = I960BASE_INSN_SHLO; goto extract_fmt_shlo;
+              case 12 : itype = I960BASE_INSN_SHLI; goto extract_fmt_shlo;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 2 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_ADDO1; goto extract_fmt_mulo1;
+              case 4 : itype = I960BASE_INSN_SUBO1; goto extract_fmt_mulo1;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 3 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_SHRO1; goto extract_fmt_shlo1;
+              case 6 : itype = I960BASE_INSN_SHRI1; goto extract_fmt_shlo1;
+              case 8 : itype = I960BASE_INSN_SHLO1; goto extract_fmt_shlo1;
+              case 12 : itype = I960BASE_INSN_SHLI1; goto extract_fmt_shlo1;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 4 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_ADDO2; goto extract_fmt_mulo2;
+              case 4 : itype = I960BASE_INSN_SUBO2; goto extract_fmt_mulo2;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 5 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_SHRO2; goto extract_fmt_shlo2;
+              case 6 : itype = I960BASE_INSN_SHRI2; goto extract_fmt_shlo2;
+              case 8 : itype = I960BASE_INSN_SHLO2; goto extract_fmt_shlo2;
+              case 12 : itype = I960BASE_INSN_SHLI2; goto extract_fmt_shlo2;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 6 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_ADDO3; goto extract_fmt_mulo3;
+              case 4 : itype = I960BASE_INSN_SUBO3; goto extract_fmt_mulo3;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 7 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
               {
-              CASE (0_89, 0) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_ADDO), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SUBO), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_89, 1) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_SHRO), E (FMT_NOTBIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHRI), E (FMT_NOTBIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHLO), E (FMT_NOTBIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHLI), E (FMT_NOTBIT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_89, 2) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_ADDO1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SUBO1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_89, 3) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_SHRO1), E (FMT_NOTBIT1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHRI1), E (FMT_NOTBIT1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHLO1), E (FMT_NOTBIT1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHLI1), E (FMT_NOTBIT1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_89, 4) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_ADDO2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SUBO2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_89, 5) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_SHRO2), E (FMT_NOTBIT2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHRI2), E (FMT_NOTBIT2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHLO2), E (FMT_NOTBIT2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHLI2), E (FMT_NOTBIT2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_89, 6) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_ADDO3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SUBO3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_89, 7) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_SHRO3), E (FMT_NOTBIT3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHRI3), E (FMT_NOTBIT3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHLO3), E (FMT_NOTBIT3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_SHLI3), E (FMT_NOTBIT3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              DEFAULT (0_89) :
-                idecode = &insns[val];
-                GOTO_EXTRACT (idecode);
+              case 0 : itype = I960BASE_INSN_SHRO3; goto extract_fmt_shlo3;
+              case 6 : itype = I960BASE_INSN_SHRI3; goto extract_fmt_shlo3;
+              case 8 : itype = I960BASE_INSN_SHLO3; goto extract_fmt_shlo3;
+              case 12 : itype = I960BASE_INSN_SHLI3; goto extract_fmt_shlo3;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
               }
-            ENDSWITCH (0_89)
+            }
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 90) :
+        }
+      case 90 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-#ifdef __GNUC__
-            static const void *labels_0_90[16] = {
-              && default_0_90, && default_0_90, && default_0_90, && default_0_90, 
-              && default_0_90, && default_0_90, && default_0_90, && default_0_90, 
-              && case_0_90_8, && default_0_90, && case_0_90_10, && default_0_90, 
-              && case_0_90_12, && default_0_90, && case_0_90_14, && default_0_90, 
-            };
-#endif
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { 0 }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val;
-            val = (((insn >> 10) & (15 << 0)));
-            DECODE_SWITCH (0_90, val)
+          case 8 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_CMPO; goto extract_fmt_cmpo;
+              case 2 : itype = I960BASE_INSN_CMPI; goto extract_fmt_cmpi;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 10 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_CMPO1; goto extract_fmt_cmpo1;
+              case 2 : itype = I960BASE_INSN_CMPI1; goto extract_fmt_cmpi1;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 12 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_CMPO2; goto extract_fmt_cmpo2;
+              case 2 : itype = I960BASE_INSN_CMPI2; goto extract_fmt_cmpi2;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 14 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
               {
-              CASE (0_90, 8) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_CMPO), E (FMT_CMPO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_CMPI), E (FMT_CMPI) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_90, 10) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_CMPO1), E (FMT_CMPO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_CMPI1), E (FMT_CMPI1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_90, 12) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_CMPO2), E (FMT_CMPO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_CMPI2), E (FMT_CMPI2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_90, 14) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_CMPO3), E (FMT_CMPO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_CMPI3), E (FMT_CMPI3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              DEFAULT (0_90) :
-                idecode = &insns[val];
-                GOTO_EXTRACT (idecode);
+              case 0 : itype = I960BASE_INSN_CMPO3; goto extract_fmt_cmpo3;
+              case 2 : itype = I960BASE_INSN_CMPI3; goto extract_fmt_cmpi3;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
               }
-            ENDSWITCH (0_90)
+            }
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 92) :
+        }
+      case 92 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_MOV), E (FMT_NOT2) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_MOV1), E (FMT_NOT3) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 5 : itype = I960BASE_INSN_MOV; goto extract_fmt_not2;
+          case 7 : itype = I960BASE_INSN_MOV1; goto extract_fmt_not3;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 93) :
+        }
+      case 93 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_MOVL), E (FMT_MOVL) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_MOVL1), E (FMT_MOVL1) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 5 : itype = I960BASE_INSN_MOVL; goto extract_fmt_movl;
+          case 7 : itype = I960BASE_INSN_MOVL1; goto extract_fmt_movl1;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 94) :
+        }
+      case 94 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_MOVT), E (FMT_MOVT) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_MOVT1), E (FMT_MOVT1) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 5 : itype = I960BASE_INSN_MOVT; goto extract_fmt_movt;
+          case 7 : itype = I960BASE_INSN_MOVT1; goto extract_fmt_movt1;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 95) :
+        }
+      case 95 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_MOVQ), E (FMT_MOVQ) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_MOVQ1), E (FMT_MOVQ1) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 5 : itype = I960BASE_INSN_MOVQ; goto extract_fmt_movq;
+          case 7 : itype = I960BASE_INSN_MOVQ1; goto extract_fmt_movq1;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 102) :
+        }
+      case 100 : itype = I960BASE_INSN_MODAC; goto extract_fmt_modpc;
+      case 101 : itype = I960BASE_INSN_MODPC; goto extract_fmt_modpc;
+      case 102 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-#ifdef __GNUC__
-            static const void *labels_0_102[16] = {
-              && default_0_102, && default_0_102, && default_0_102, && default_0_102, 
-              && default_0_102, && default_0_102, && default_0_102, && default_0_102, 
-              && default_0_102, && default_0_102, && default_0_102, && default_0_102, 
-              && default_0_102, && default_0_102, && default_0_102, && case_0_102_15, 
-            };
-#endif
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CALLS), E (FMT_CALLS) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { 0 }, 
-            };
-            unsigned int val;
-            val = (((insn >> 10) & (15 << 0)));
-            DECODE_SWITCH (0_102, val)
+          case 12 : itype = I960BASE_INSN_CALLS; goto extract_fmt_calls;
+          case 15 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
               {
-              CASE (0_102, 15) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_FMARK), E (FMT_FMARK) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_FLUSHREG), E (FMT_FLUSHREG) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              DEFAULT (0_102) :
-                idecode = &insns[val];
-                GOTO_EXTRACT (idecode);
+              case 8 : itype = I960BASE_INSN_FMARK; goto extract_fmt_fmark;
+              case 10 : itype = I960BASE_INSN_FLUSHREG; goto extract_fmt_flushreg;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
               }
-            ENDSWITCH (0_102)
+            }
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 103) :
+        }
+      case 103 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_EMUL), E (FMT_EMUL) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_EMUL1), E (FMT_EMUL1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_EMUL2), E (FMT_EMUL2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_EMUL3), E (FMT_EMUL3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = I960BASE_INSN_EMUL; goto extract_fmt_emul;
+          case 2 : itype = I960BASE_INSN_EMUL1; goto extract_fmt_emul1;
+          case 4 : itype = I960BASE_INSN_EMUL2; goto extract_fmt_emul2;
+          case 6 : itype = I960BASE_INSN_EMUL3; goto extract_fmt_emul3;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 112) :
+        }
+      case 112 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-#ifdef __GNUC__
-            static const void *labels_0_112[16] = {
-              && default_0_112, && case_0_112_1, && default_0_112, && case_0_112_3, 
-              && default_0_112, && case_0_112_5, && default_0_112, && case_0_112_7, 
-              && default_0_112, && default_0_112, && default_0_112, && default_0_112, 
-              && default_0_112, && default_0_112, && default_0_112, && default_0_112, 
-            };
-#endif
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_MULO), E (FMT_MULO) }, { 0 }, 
-              { I (INSN_MULO1), E (FMT_MULO1) }, { 0 }, 
-              { I (INSN_MULO2), E (FMT_MULO2) }, { 0 }, 
-              { I (INSN_MULO3), E (FMT_MULO3) }, { 0 }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val;
-            val = (((insn >> 10) & (15 << 0)));
-            DECODE_SWITCH (0_112, val)
+          case 0 : itype = I960BASE_INSN_MULO; goto extract_fmt_mulo;
+          case 1 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_REMO; goto extract_fmt_mulo;
+              case 6 : itype = I960BASE_INSN_DIVO; goto extract_fmt_mulo;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 2 : itype = I960BASE_INSN_MULO1; goto extract_fmt_mulo1;
+          case 3 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_REMO1; goto extract_fmt_mulo1;
+              case 6 : itype = I960BASE_INSN_DIVO1; goto extract_fmt_mulo1;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 4 : itype = I960BASE_INSN_MULO2; goto extract_fmt_mulo2;
+          case 5 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
               {
-              CASE (0_112, 1) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_REMO), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_DIVO), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_112, 3) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_REMO1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_DIVO1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_112, 5) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_REMO2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_DIVO2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_112, 7) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_REMO3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_DIVO3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              DEFAULT (0_112) :
-                idecode = &insns[val];
-                GOTO_EXTRACT (idecode);
+              case 0 : itype = I960BASE_INSN_REMO2; goto extract_fmt_mulo2;
+              case 6 : itype = I960BASE_INSN_DIVO2; goto extract_fmt_mulo2;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
               }
-            ENDSWITCH (0_112)
+            }
+          case 6 : itype = I960BASE_INSN_MULO3; goto extract_fmt_mulo3;
+          case 7 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_REMO3; goto extract_fmt_mulo3;
+              case 6 : itype = I960BASE_INSN_DIVO3; goto extract_fmt_mulo3;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 116) :
+        }
+      case 116 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-#ifdef __GNUC__
-            static const void *labels_0_116[16] = {
-              && default_0_116, && case_0_116_1, && default_0_116, && case_0_116_3, 
-              && default_0_116, && case_0_116_5, && default_0_116, && case_0_116_7, 
-              && default_0_116, && default_0_116, && default_0_116, && default_0_116, 
-              && default_0_116, && default_0_116, && default_0_116, && default_0_116, 
-            };
-#endif
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { 0 }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { 0 }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { 0 }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { 0 }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val;
-            val = (((insn >> 10) & (15 << 0)));
-            DECODE_SWITCH (0_116, val)
+          case 1 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_REMI; goto extract_fmt_mulo;
+              case 6 : itype = I960BASE_INSN_DIVI; goto extract_fmt_mulo;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 3 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_REMI1; goto extract_fmt_mulo1;
+              case 6 : itype = I960BASE_INSN_DIVI1; goto extract_fmt_mulo1;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          case 5 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
               {
-              CASE (0_116, 1) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_REMI), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_DIVI), E (FMT_MULO) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_116, 3) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_REMI1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_DIVI1), E (FMT_MULO1) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_116, 5) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_REMI2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_DIVI2), E (FMT_MULO2) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              CASE (0_116, 7) :
-                {
-                  static const DECODE_DESC insns[16] = {
-                    { I (INSN_REMI3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_DIVI3), E (FMT_MULO3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                    { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-                  };
-                  unsigned int val = (((insn >> 6) & (15 << 0)));
-                  idecode = &insns[val];
-                  GOTO_EXTRACT (idecode);
-                }
-              DEFAULT (0_116) :
-                idecode = &insns[val];
-                GOTO_EXTRACT (idecode);
+              case 0 : itype = I960BASE_INSN_REMI2; goto extract_fmt_mulo2;
+              case 6 : itype = I960BASE_INSN_DIVI2; goto extract_fmt_mulo2;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
               }
-            ENDSWITCH (0_116)
+            }
+          case 7 :
+            {
+              unsigned int val = (((insn >> 6) & (15 << 0)));
+              switch (val)
+              {
+              case 0 : itype = I960BASE_INSN_REMI3; goto extract_fmt_mulo3;
+              case 6 : itype = I960BASE_INSN_DIVI3; goto extract_fmt_mulo3;
+              default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+              }
+            }
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 128) :
+        }
+      case 128 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_LDOB_OFFSET), E (FMT_LDOB_OFFSET) }, { I (INSN_LDOB_OFFSET), E (FMT_LDOB_OFFSET) }, 
-              { I (INSN_LDOB_OFFSET), E (FMT_LDOB_OFFSET) }, { I (INSN_LDOB_OFFSET), E (FMT_LDOB_OFFSET) }, 
-              { I (INSN_LDOB_INDIRECT), E (FMT_LDOB_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_LDOB_INDIRECT_INDEX), E (FMT_LDOB_INDIRECT_INDEX) }, 
-              { I (INSN_LDOB_INDIRECT_OFFSET), E (FMT_LDOB_INDIRECT_OFFSET) }, { I (INSN_LDOB_INDIRECT_OFFSET), E (FMT_LDOB_INDIRECT_OFFSET) }, 
-              { I (INSN_LDOB_INDIRECT_OFFSET), E (FMT_LDOB_INDIRECT_OFFSET) }, { I (INSN_LDOB_INDIRECT_OFFSET), E (FMT_LDOB_INDIRECT_OFFSET) }, 
-              { I (INSN_LDOB_DISP), E (FMT_LDOB_DISP) }, { I (INSN_LDOB_INDIRECT_DISP), E (FMT_LDOB_INDIRECT_DISP) }, 
-              { I (INSN_LDOB_INDEX_DISP), E (FMT_LDOB_INDEX_DISP) }, { I (INSN_LDOB_INDIRECT_INDEX_DISP), E (FMT_LDOB_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_LDOB_OFFSET; goto extract_fmt_ldob_offset;
+          case 4 : itype = I960BASE_INSN_LDOB_INDIRECT; goto extract_fmt_ldob_indirect;
+          case 7 : itype = I960BASE_INSN_LDOB_INDIRECT_INDEX; goto extract_fmt_ldob_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_LDOB_INDIRECT_OFFSET; goto extract_fmt_ldob_indirect_offset;
+          case 12 : itype = I960BASE_INSN_LDOB_DISP; goto extract_fmt_ldob_disp;
+          case 13 : itype = I960BASE_INSN_LDOB_INDIRECT_DISP; goto extract_fmt_ldob_indirect_disp;
+          case 14 : itype = I960BASE_INSN_LDOB_INDEX_DISP; goto extract_fmt_ldob_index_disp;
+          case 15 : itype = I960BASE_INSN_LDOB_INDIRECT_INDEX_DISP; goto extract_fmt_ldob_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 130) :
+        }
+      case 130 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_STOB_OFFSET), E (FMT_STOB_OFFSET) }, { I (INSN_STOB_OFFSET), E (FMT_STOB_OFFSET) }, 
-              { I (INSN_STOB_OFFSET), E (FMT_STOB_OFFSET) }, { I (INSN_STOB_OFFSET), E (FMT_STOB_OFFSET) }, 
-              { I (INSN_STOB_INDIRECT), E (FMT_STOB_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_STOB_INDIRECT_INDEX), E (FMT_STOB_INDIRECT_INDEX) }, 
-              { I (INSN_STOB_INDIRECT_OFFSET), E (FMT_STOB_INDIRECT_OFFSET) }, { I (INSN_STOB_INDIRECT_OFFSET), E (FMT_STOB_INDIRECT_OFFSET) }, 
-              { I (INSN_STOB_INDIRECT_OFFSET), E (FMT_STOB_INDIRECT_OFFSET) }, { I (INSN_STOB_INDIRECT_OFFSET), E (FMT_STOB_INDIRECT_OFFSET) }, 
-              { I (INSN_STOB_DISP), E (FMT_STOB_DISP) }, { I (INSN_STOB_INDIRECT_DISP), E (FMT_STOB_INDIRECT_DISP) }, 
-              { I (INSN_STOB_INDEX_DISP), E (FMT_STOB_INDEX_DISP) }, { I (INSN_STOB_INDIRECT_INDEX_DISP), E (FMT_STOB_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_STOB_OFFSET; goto extract_fmt_stob_offset;
+          case 4 : itype = I960BASE_INSN_STOB_INDIRECT; goto extract_fmt_stob_indirect;
+          case 7 : itype = I960BASE_INSN_STOB_INDIRECT_INDEX; goto extract_fmt_stob_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_STOB_INDIRECT_OFFSET; goto extract_fmt_stob_indirect_offset;
+          case 12 : itype = I960BASE_INSN_STOB_DISP; goto extract_fmt_stob_disp;
+          case 13 : itype = I960BASE_INSN_STOB_INDIRECT_DISP; goto extract_fmt_stob_indirect_disp;
+          case 14 : itype = I960BASE_INSN_STOB_INDEX_DISP; goto extract_fmt_stob_index_disp;
+          case 15 : itype = I960BASE_INSN_STOB_INDIRECT_INDEX_DISP; goto extract_fmt_stob_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 132) :
+        }
+      case 132 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_BX_INDIRECT), E (FMT_BX_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_BX_INDIRECT_INDEX), E (FMT_BX_INDIRECT_INDEX) }, 
-              { I (INSN_BX_INDIRECT_OFFSET), E (FMT_BX_INDIRECT_OFFSET) }, { I (INSN_BX_INDIRECT_OFFSET), E (FMT_BX_INDIRECT_OFFSET) }, 
-              { I (INSN_BX_INDIRECT_OFFSET), E (FMT_BX_INDIRECT_OFFSET) }, { I (INSN_BX_INDIRECT_OFFSET), E (FMT_BX_INDIRECT_OFFSET) }, 
-              { I (INSN_BX_DISP), E (FMT_BX_DISP) }, { I (INSN_BX_INDIRECT_DISP), E (FMT_BX_INDIRECT_DISP) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 4 : itype = I960BASE_INSN_BX_INDIRECT; goto extract_fmt_bx_indirect;
+          case 7 : itype = I960BASE_INSN_BX_INDIRECT_INDEX; goto extract_fmt_bx_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_BX_INDIRECT_OFFSET; goto extract_fmt_bx_indirect_offset;
+          case 12 : itype = I960BASE_INSN_BX_DISP; goto extract_fmt_bx_disp;
+          case 13 : itype = I960BASE_INSN_BX_INDIRECT_DISP; goto extract_fmt_bx_indirect_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 134) :
+        }
+      case 134 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CALLX_INDIRECT), E (FMT_CALLX_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_CALLX_INDIRECT_OFFSET), E (FMT_CALLX_INDIRECT_OFFSET) }, { I (INSN_CALLX_INDIRECT_OFFSET), E (FMT_CALLX_INDIRECT_OFFSET) }, 
-              { I (INSN_CALLX_INDIRECT_OFFSET), E (FMT_CALLX_INDIRECT_OFFSET) }, { I (INSN_CALLX_INDIRECT_OFFSET), E (FMT_CALLX_INDIRECT_OFFSET) }, 
-              { I (INSN_CALLX_DISP), E (FMT_CALLX_DISP) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 4 : itype = I960BASE_INSN_CALLX_INDIRECT; goto extract_fmt_callx_indirect;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_CALLX_INDIRECT_OFFSET; goto extract_fmt_callx_indirect_offset;
+          case 12 : itype = I960BASE_INSN_CALLX_DISP; goto extract_fmt_callx_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 136) :
+        }
+      case 136 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_LDOS_OFFSET), E (FMT_LDOS_OFFSET) }, { I (INSN_LDOS_OFFSET), E (FMT_LDOS_OFFSET) }, 
-              { I (INSN_LDOS_OFFSET), E (FMT_LDOS_OFFSET) }, { I (INSN_LDOS_OFFSET), E (FMT_LDOS_OFFSET) }, 
-              { I (INSN_LDOS_INDIRECT), E (FMT_LDOS_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_LDOS_INDIRECT_INDEX), E (FMT_LDOS_INDIRECT_INDEX) }, 
-              { I (INSN_LDOS_INDIRECT_OFFSET), E (FMT_LDOS_INDIRECT_OFFSET) }, { I (INSN_LDOS_INDIRECT_OFFSET), E (FMT_LDOS_INDIRECT_OFFSET) }, 
-              { I (INSN_LDOS_INDIRECT_OFFSET), E (FMT_LDOS_INDIRECT_OFFSET) }, { I (INSN_LDOS_INDIRECT_OFFSET), E (FMT_LDOS_INDIRECT_OFFSET) }, 
-              { I (INSN_LDOS_DISP), E (FMT_LDOS_DISP) }, { I (INSN_LDOS_INDIRECT_DISP), E (FMT_LDOS_INDIRECT_DISP) }, 
-              { I (INSN_LDOS_INDEX_DISP), E (FMT_LDOS_INDEX_DISP) }, { I (INSN_LDOS_INDIRECT_INDEX_DISP), E (FMT_LDOS_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_LDOS_OFFSET; goto extract_fmt_ldos_offset;
+          case 4 : itype = I960BASE_INSN_LDOS_INDIRECT; goto extract_fmt_ldos_indirect;
+          case 7 : itype = I960BASE_INSN_LDOS_INDIRECT_INDEX; goto extract_fmt_ldos_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_LDOS_INDIRECT_OFFSET; goto extract_fmt_ldos_indirect_offset;
+          case 12 : itype = I960BASE_INSN_LDOS_DISP; goto extract_fmt_ldos_disp;
+          case 13 : itype = I960BASE_INSN_LDOS_INDIRECT_DISP; goto extract_fmt_ldos_indirect_disp;
+          case 14 : itype = I960BASE_INSN_LDOS_INDEX_DISP; goto extract_fmt_ldos_index_disp;
+          case 15 : itype = I960BASE_INSN_LDOS_INDIRECT_INDEX_DISP; goto extract_fmt_ldos_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 138) :
+        }
+      case 138 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_STOS_OFFSET), E (FMT_STOS_OFFSET) }, { I (INSN_STOS_OFFSET), E (FMT_STOS_OFFSET) }, 
-              { I (INSN_STOS_OFFSET), E (FMT_STOS_OFFSET) }, { I (INSN_STOS_OFFSET), E (FMT_STOS_OFFSET) }, 
-              { I (INSN_STOS_INDIRECT), E (FMT_STOS_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_STOS_INDIRECT_INDEX), E (FMT_STOS_INDIRECT_INDEX) }, 
-              { I (INSN_STOS_INDIRECT_OFFSET), E (FMT_STOS_INDIRECT_OFFSET) }, { I (INSN_STOS_INDIRECT_OFFSET), E (FMT_STOS_INDIRECT_OFFSET) }, 
-              { I (INSN_STOS_INDIRECT_OFFSET), E (FMT_STOS_INDIRECT_OFFSET) }, { I (INSN_STOS_INDIRECT_OFFSET), E (FMT_STOS_INDIRECT_OFFSET) }, 
-              { I (INSN_STOS_DISP), E (FMT_STOS_DISP) }, { I (INSN_STOS_INDIRECT_DISP), E (FMT_STOS_INDIRECT_DISP) }, 
-              { I (INSN_STOS_INDEX_DISP), E (FMT_STOS_INDEX_DISP) }, { I (INSN_STOS_INDIRECT_INDEX_DISP), E (FMT_STOS_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_STOS_OFFSET; goto extract_fmt_stos_offset;
+          case 4 : itype = I960BASE_INSN_STOS_INDIRECT; goto extract_fmt_stos_indirect;
+          case 7 : itype = I960BASE_INSN_STOS_INDIRECT_INDEX; goto extract_fmt_stos_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_STOS_INDIRECT_OFFSET; goto extract_fmt_stos_indirect_offset;
+          case 12 : itype = I960BASE_INSN_STOS_DISP; goto extract_fmt_stos_disp;
+          case 13 : itype = I960BASE_INSN_STOS_INDIRECT_DISP; goto extract_fmt_stos_indirect_disp;
+          case 14 : itype = I960BASE_INSN_STOS_INDEX_DISP; goto extract_fmt_stos_index_disp;
+          case 15 : itype = I960BASE_INSN_STOS_INDIRECT_INDEX_DISP; goto extract_fmt_stos_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 140) :
+        }
+      case 140 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_LDA_OFFSET), E (FMT_LDA_OFFSET) }, { I (INSN_LDA_OFFSET), E (FMT_LDA_OFFSET) }, 
-              { I (INSN_LDA_OFFSET), E (FMT_LDA_OFFSET) }, { I (INSN_LDA_OFFSET), E (FMT_LDA_OFFSET) }, 
-              { I (INSN_LDA_INDIRECT), E (FMT_LDA_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_LDA_INDIRECT_INDEX), E (FMT_LDA_INDIRECT_INDEX) }, 
-              { I (INSN_LDA_INDIRECT_OFFSET), E (FMT_LDA_INDIRECT_OFFSET) }, { I (INSN_LDA_INDIRECT_OFFSET), E (FMT_LDA_INDIRECT_OFFSET) }, 
-              { I (INSN_LDA_INDIRECT_OFFSET), E (FMT_LDA_INDIRECT_OFFSET) }, { I (INSN_LDA_INDIRECT_OFFSET), E (FMT_LDA_INDIRECT_OFFSET) }, 
-              { I (INSN_LDA_DISP), E (FMT_LDA_DISP) }, { I (INSN_LDA_INDIRECT_DISP), E (FMT_LDA_INDIRECT_DISP) }, 
-              { I (INSN_LDA_INDEX_DISP), E (FMT_LDA_INDEX_DISP) }, { I (INSN_LDA_INDIRECT_INDEX_DISP), E (FMT_LDA_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_LDA_OFFSET; goto extract_fmt_lda_offset;
+          case 4 : itype = I960BASE_INSN_LDA_INDIRECT; goto extract_fmt_lda_indirect;
+          case 7 : itype = I960BASE_INSN_LDA_INDIRECT_INDEX; goto extract_fmt_lda_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_LDA_INDIRECT_OFFSET; goto extract_fmt_lda_indirect_offset;
+          case 12 : itype = I960BASE_INSN_LDA_DISP; goto extract_fmt_lda_disp;
+          case 13 : itype = I960BASE_INSN_LDA_INDIRECT_DISP; goto extract_fmt_lda_indirect_disp;
+          case 14 : itype = I960BASE_INSN_LDA_INDEX_DISP; goto extract_fmt_lda_index_disp;
+          case 15 : itype = I960BASE_INSN_LDA_INDIRECT_INDEX_DISP; goto extract_fmt_lda_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 144) :
+        }
+      case 144 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_LD_OFFSET), E (FMT_LD_OFFSET) }, { I (INSN_LD_OFFSET), E (FMT_LD_OFFSET) }, 
-              { I (INSN_LD_OFFSET), E (FMT_LD_OFFSET) }, { I (INSN_LD_OFFSET), E (FMT_LD_OFFSET) }, 
-              { I (INSN_LD_INDIRECT), E (FMT_LD_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_LD_INDIRECT_INDEX), E (FMT_LD_INDIRECT_INDEX) }, 
-              { I (INSN_LD_INDIRECT_OFFSET), E (FMT_LD_INDIRECT_OFFSET) }, { I (INSN_LD_INDIRECT_OFFSET), E (FMT_LD_INDIRECT_OFFSET) }, 
-              { I (INSN_LD_INDIRECT_OFFSET), E (FMT_LD_INDIRECT_OFFSET) }, { I (INSN_LD_INDIRECT_OFFSET), E (FMT_LD_INDIRECT_OFFSET) }, 
-              { I (INSN_LD_DISP), E (FMT_LD_DISP) }, { I (INSN_LD_INDIRECT_DISP), E (FMT_LD_INDIRECT_DISP) }, 
-              { I (INSN_LD_INDEX_DISP), E (FMT_LD_INDEX_DISP) }, { I (INSN_LD_INDIRECT_INDEX_DISP), E (FMT_LD_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_LD_OFFSET; goto extract_fmt_ld_offset;
+          case 4 : itype = I960BASE_INSN_LD_INDIRECT; goto extract_fmt_ld_indirect;
+          case 7 : itype = I960BASE_INSN_LD_INDIRECT_INDEX; goto extract_fmt_ld_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_LD_INDIRECT_OFFSET; goto extract_fmt_ld_indirect_offset;
+          case 12 : itype = I960BASE_INSN_LD_DISP; goto extract_fmt_ld_disp;
+          case 13 : itype = I960BASE_INSN_LD_INDIRECT_DISP; goto extract_fmt_ld_indirect_disp;
+          case 14 : itype = I960BASE_INSN_LD_INDEX_DISP; goto extract_fmt_ld_index_disp;
+          case 15 : itype = I960BASE_INSN_LD_INDIRECT_INDEX_DISP; goto extract_fmt_ld_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 146) :
+        }
+      case 146 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_ST_OFFSET), E (FMT_ST_OFFSET) }, { I (INSN_ST_OFFSET), E (FMT_ST_OFFSET) }, 
-              { I (INSN_ST_OFFSET), E (FMT_ST_OFFSET) }, { I (INSN_ST_OFFSET), E (FMT_ST_OFFSET) }, 
-              { I (INSN_ST_INDIRECT), E (FMT_ST_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_ST_INDIRECT_INDEX), E (FMT_ST_INDIRECT_INDEX) }, 
-              { I (INSN_ST_INDIRECT_OFFSET), E (FMT_ST_INDIRECT_OFFSET) }, { I (INSN_ST_INDIRECT_OFFSET), E (FMT_ST_INDIRECT_OFFSET) }, 
-              { I (INSN_ST_INDIRECT_OFFSET), E (FMT_ST_INDIRECT_OFFSET) }, { I (INSN_ST_INDIRECT_OFFSET), E (FMT_ST_INDIRECT_OFFSET) }, 
-              { I (INSN_ST_DISP), E (FMT_ST_DISP) }, { I (INSN_ST_INDIRECT_DISP), E (FMT_ST_INDIRECT_DISP) }, 
-              { I (INSN_ST_INDEX_DISP), E (FMT_ST_INDEX_DISP) }, { I (INSN_ST_INDIRECT_INDEX_DISP), E (FMT_ST_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_ST_OFFSET; goto extract_fmt_st_offset;
+          case 4 : itype = I960BASE_INSN_ST_INDIRECT; goto extract_fmt_st_indirect;
+          case 7 : itype = I960BASE_INSN_ST_INDIRECT_INDEX; goto extract_fmt_st_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_ST_INDIRECT_OFFSET; goto extract_fmt_st_indirect_offset;
+          case 12 : itype = I960BASE_INSN_ST_DISP; goto extract_fmt_st_disp;
+          case 13 : itype = I960BASE_INSN_ST_INDIRECT_DISP; goto extract_fmt_st_indirect_disp;
+          case 14 : itype = I960BASE_INSN_ST_INDEX_DISP; goto extract_fmt_st_index_disp;
+          case 15 : itype = I960BASE_INSN_ST_INDIRECT_INDEX_DISP; goto extract_fmt_st_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 152) :
+        }
+      case 152 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_LDL_OFFSET), E (FMT_LDL_OFFSET) }, { I (INSN_LDL_OFFSET), E (FMT_LDL_OFFSET) }, 
-              { I (INSN_LDL_OFFSET), E (FMT_LDL_OFFSET) }, { I (INSN_LDL_OFFSET), E (FMT_LDL_OFFSET) }, 
-              { I (INSN_LDL_INDIRECT), E (FMT_LDL_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_LDL_INDIRECT_INDEX), E (FMT_LDL_INDIRECT_INDEX) }, 
-              { I (INSN_LDL_INDIRECT_OFFSET), E (FMT_LDL_INDIRECT_OFFSET) }, { I (INSN_LDL_INDIRECT_OFFSET), E (FMT_LDL_INDIRECT_OFFSET) }, 
-              { I (INSN_LDL_INDIRECT_OFFSET), E (FMT_LDL_INDIRECT_OFFSET) }, { I (INSN_LDL_INDIRECT_OFFSET), E (FMT_LDL_INDIRECT_OFFSET) }, 
-              { I (INSN_LDL_DISP), E (FMT_LDL_DISP) }, { I (INSN_LDL_INDIRECT_DISP), E (FMT_LDL_INDIRECT_DISP) }, 
-              { I (INSN_LDL_INDEX_DISP), E (FMT_LDL_INDEX_DISP) }, { I (INSN_LDL_INDIRECT_INDEX_DISP), E (FMT_LDL_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_LDL_OFFSET; goto extract_fmt_ldl_offset;
+          case 4 : itype = I960BASE_INSN_LDL_INDIRECT; goto extract_fmt_ldl_indirect;
+          case 7 : itype = I960BASE_INSN_LDL_INDIRECT_INDEX; goto extract_fmt_ldl_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_LDL_INDIRECT_OFFSET; goto extract_fmt_ldl_indirect_offset;
+          case 12 : itype = I960BASE_INSN_LDL_DISP; goto extract_fmt_ldl_disp;
+          case 13 : itype = I960BASE_INSN_LDL_INDIRECT_DISP; goto extract_fmt_ldl_indirect_disp;
+          case 14 : itype = I960BASE_INSN_LDL_INDEX_DISP; goto extract_fmt_ldl_index_disp;
+          case 15 : itype = I960BASE_INSN_LDL_INDIRECT_INDEX_DISP; goto extract_fmt_ldl_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 154) :
+        }
+      case 154 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_STL_OFFSET), E (FMT_STL_OFFSET) }, { I (INSN_STL_OFFSET), E (FMT_STL_OFFSET) }, 
-              { I (INSN_STL_OFFSET), E (FMT_STL_OFFSET) }, { I (INSN_STL_OFFSET), E (FMT_STL_OFFSET) }, 
-              { I (INSN_STL_INDIRECT), E (FMT_STL_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_STL_INDIRECT_INDEX), E (FMT_STL_INDIRECT_INDEX) }, 
-              { I (INSN_STL_INDIRECT_OFFSET), E (FMT_STL_INDIRECT_OFFSET) }, { I (INSN_STL_INDIRECT_OFFSET), E (FMT_STL_INDIRECT_OFFSET) }, 
-              { I (INSN_STL_INDIRECT_OFFSET), E (FMT_STL_INDIRECT_OFFSET) }, { I (INSN_STL_INDIRECT_OFFSET), E (FMT_STL_INDIRECT_OFFSET) }, 
-              { I (INSN_STL_DISP), E (FMT_STL_DISP) }, { I (INSN_STL_INDIRECT_DISP), E (FMT_STL_INDIRECT_DISP) }, 
-              { I (INSN_STL_INDEX_DISP), E (FMT_STL_INDEX_DISP) }, { I (INSN_STL_INDIRECT_INDEX_DISP), E (FMT_STL_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_STL_OFFSET; goto extract_fmt_stl_offset;
+          case 4 : itype = I960BASE_INSN_STL_INDIRECT; goto extract_fmt_stl_indirect;
+          case 7 : itype = I960BASE_INSN_STL_INDIRECT_INDEX; goto extract_fmt_stl_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_STL_INDIRECT_OFFSET; goto extract_fmt_stl_indirect_offset;
+          case 12 : itype = I960BASE_INSN_STL_DISP; goto extract_fmt_stl_disp;
+          case 13 : itype = I960BASE_INSN_STL_INDIRECT_DISP; goto extract_fmt_stl_indirect_disp;
+          case 14 : itype = I960BASE_INSN_STL_INDEX_DISP; goto extract_fmt_stl_index_disp;
+          case 15 : itype = I960BASE_INSN_STL_INDIRECT_INDEX_DISP; goto extract_fmt_stl_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 160) :
+        }
+      case 160 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_LDT_OFFSET), E (FMT_LDT_OFFSET) }, { I (INSN_LDT_OFFSET), E (FMT_LDT_OFFSET) }, 
-              { I (INSN_LDT_OFFSET), E (FMT_LDT_OFFSET) }, { I (INSN_LDT_OFFSET), E (FMT_LDT_OFFSET) }, 
-              { I (INSN_LDT_INDIRECT), E (FMT_LDT_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_LDT_INDIRECT_INDEX), E (FMT_LDT_INDIRECT_INDEX) }, 
-              { I (INSN_LDT_INDIRECT_OFFSET), E (FMT_LDT_INDIRECT_OFFSET) }, { I (INSN_LDT_INDIRECT_OFFSET), E (FMT_LDT_INDIRECT_OFFSET) }, 
-              { I (INSN_LDT_INDIRECT_OFFSET), E (FMT_LDT_INDIRECT_OFFSET) }, { I (INSN_LDT_INDIRECT_OFFSET), E (FMT_LDT_INDIRECT_OFFSET) }, 
-              { I (INSN_LDT_DISP), E (FMT_LDT_DISP) }, { I (INSN_LDT_INDIRECT_DISP), E (FMT_LDT_INDIRECT_DISP) }, 
-              { I (INSN_LDT_INDEX_DISP), E (FMT_LDT_INDEX_DISP) }, { I (INSN_LDT_INDIRECT_INDEX_DISP), E (FMT_LDT_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_LDT_OFFSET; goto extract_fmt_ldt_offset;
+          case 4 : itype = I960BASE_INSN_LDT_INDIRECT; goto extract_fmt_ldt_indirect;
+          case 7 : itype = I960BASE_INSN_LDT_INDIRECT_INDEX; goto extract_fmt_ldt_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_LDT_INDIRECT_OFFSET; goto extract_fmt_ldt_indirect_offset;
+          case 12 : itype = I960BASE_INSN_LDT_DISP; goto extract_fmt_ldt_disp;
+          case 13 : itype = I960BASE_INSN_LDT_INDIRECT_DISP; goto extract_fmt_ldt_indirect_disp;
+          case 14 : itype = I960BASE_INSN_LDT_INDEX_DISP; goto extract_fmt_ldt_index_disp;
+          case 15 : itype = I960BASE_INSN_LDT_INDIRECT_INDEX_DISP; goto extract_fmt_ldt_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 162) :
+        }
+      case 162 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_STT_OFFSET), E (FMT_STT_OFFSET) }, { I (INSN_STT_OFFSET), E (FMT_STT_OFFSET) }, 
-              { I (INSN_STT_OFFSET), E (FMT_STT_OFFSET) }, { I (INSN_STT_OFFSET), E (FMT_STT_OFFSET) }, 
-              { I (INSN_STT_INDIRECT), E (FMT_STT_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_STT_INDIRECT_INDEX), E (FMT_STT_INDIRECT_INDEX) }, 
-              { I (INSN_STT_INDIRECT_OFFSET), E (FMT_STT_INDIRECT_OFFSET) }, { I (INSN_STT_INDIRECT_OFFSET), E (FMT_STT_INDIRECT_OFFSET) }, 
-              { I (INSN_STT_INDIRECT_OFFSET), E (FMT_STT_INDIRECT_OFFSET) }, { I (INSN_STT_INDIRECT_OFFSET), E (FMT_STT_INDIRECT_OFFSET) }, 
-              { I (INSN_STT_DISP), E (FMT_STT_DISP) }, { I (INSN_STT_INDIRECT_DISP), E (FMT_STT_INDIRECT_DISP) }, 
-              { I (INSN_STT_INDEX_DISP), E (FMT_STT_INDEX_DISP) }, { I (INSN_STT_INDIRECT_INDEX_DISP), E (FMT_STT_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_STT_OFFSET; goto extract_fmt_stt_offset;
+          case 4 : itype = I960BASE_INSN_STT_INDIRECT; goto extract_fmt_stt_indirect;
+          case 7 : itype = I960BASE_INSN_STT_INDIRECT_INDEX; goto extract_fmt_stt_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_STT_INDIRECT_OFFSET; goto extract_fmt_stt_indirect_offset;
+          case 12 : itype = I960BASE_INSN_STT_DISP; goto extract_fmt_stt_disp;
+          case 13 : itype = I960BASE_INSN_STT_INDIRECT_DISP; goto extract_fmt_stt_indirect_disp;
+          case 14 : itype = I960BASE_INSN_STT_INDEX_DISP; goto extract_fmt_stt_index_disp;
+          case 15 : itype = I960BASE_INSN_STT_INDIRECT_INDEX_DISP; goto extract_fmt_stt_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 176) :
+        }
+      case 176 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_LDQ_OFFSET), E (FMT_LDQ_OFFSET) }, { I (INSN_LDQ_OFFSET), E (FMT_LDQ_OFFSET) }, 
-              { I (INSN_LDQ_OFFSET), E (FMT_LDQ_OFFSET) }, { I (INSN_LDQ_OFFSET), E (FMT_LDQ_OFFSET) }, 
-              { I (INSN_LDQ_INDIRECT), E (FMT_LDQ_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_LDQ_INDIRECT_INDEX), E (FMT_LDQ_INDIRECT_INDEX) }, 
-              { I (INSN_LDQ_INDIRECT_OFFSET), E (FMT_LDQ_INDIRECT_OFFSET) }, { I (INSN_LDQ_INDIRECT_OFFSET), E (FMT_LDQ_INDIRECT_OFFSET) }, 
-              { I (INSN_LDQ_INDIRECT_OFFSET), E (FMT_LDQ_INDIRECT_OFFSET) }, { I (INSN_LDQ_INDIRECT_OFFSET), E (FMT_LDQ_INDIRECT_OFFSET) }, 
-              { I (INSN_LDQ_DISP), E (FMT_LDQ_DISP) }, { I (INSN_LDQ_INDIRECT_DISP), E (FMT_LDQ_INDIRECT_DISP) }, 
-              { I (INSN_LDQ_INDEX_DISP), E (FMT_LDQ_INDEX_DISP) }, { I (INSN_LDQ_INDIRECT_INDEX_DISP), E (FMT_LDQ_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_LDQ_OFFSET; goto extract_fmt_ldq_offset;
+          case 4 : itype = I960BASE_INSN_LDQ_INDIRECT; goto extract_fmt_ldq_indirect;
+          case 7 : itype = I960BASE_INSN_LDQ_INDIRECT_INDEX; goto extract_fmt_ldq_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_LDQ_INDIRECT_OFFSET; goto extract_fmt_ldq_indirect_offset;
+          case 12 : itype = I960BASE_INSN_LDQ_DISP; goto extract_fmt_ldq_disp;
+          case 13 : itype = I960BASE_INSN_LDQ_INDIRECT_DISP; goto extract_fmt_ldq_indirect_disp;
+          case 14 : itype = I960BASE_INSN_LDQ_INDEX_DISP; goto extract_fmt_ldq_index_disp;
+          case 15 : itype = I960BASE_INSN_LDQ_INDIRECT_INDEX_DISP; goto extract_fmt_ldq_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 178) :
+        }
+      case 178 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_STQ_OFFSET), E (FMT_STQ_OFFSET) }, { I (INSN_STQ_OFFSET), E (FMT_STQ_OFFSET) }, 
-              { I (INSN_STQ_OFFSET), E (FMT_STQ_OFFSET) }, { I (INSN_STQ_OFFSET), E (FMT_STQ_OFFSET) }, 
-              { I (INSN_STQ_INDIRECT), E (FMT_STQ_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_STQ_INDIRECT_INDEX), E (FMT_STQ_INDIRECT_INDEX) }, 
-              { I (INSN_STQ_INDIRECT_OFFSET), E (FMT_STQ_INDIRECT_OFFSET) }, { I (INSN_STQ_INDIRECT_OFFSET), E (FMT_STQ_INDIRECT_OFFSET) }, 
-              { I (INSN_STQ_INDIRECT_OFFSET), E (FMT_STQ_INDIRECT_OFFSET) }, { I (INSN_STQ_INDIRECT_OFFSET), E (FMT_STQ_INDIRECT_OFFSET) }, 
-              { I (INSN_STQ_DISP), E (FMT_STQ_DISP) }, { I (INSN_STQ_INDIRECT_DISP), E (FMT_STQ_INDIRECT_DISP) }, 
-              { I (INSN_STQ_INDEX_DISP), E (FMT_STQ_INDEX_DISP) }, { I (INSN_STQ_INDIRECT_INDEX_DISP), E (FMT_STQ_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_STQ_OFFSET; goto extract_fmt_stq_offset;
+          case 4 : itype = I960BASE_INSN_STQ_INDIRECT; goto extract_fmt_stq_indirect;
+          case 7 : itype = I960BASE_INSN_STQ_INDIRECT_INDEX; goto extract_fmt_stq_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_STQ_INDIRECT_OFFSET; goto extract_fmt_stq_indirect_offset;
+          case 12 : itype = I960BASE_INSN_STQ_DISP; goto extract_fmt_stq_disp;
+          case 13 : itype = I960BASE_INSN_STQ_INDIRECT_DISP; goto extract_fmt_stq_indirect_disp;
+          case 14 : itype = I960BASE_INSN_STQ_INDEX_DISP; goto extract_fmt_stq_index_disp;
+          case 15 : itype = I960BASE_INSN_STQ_INDIRECT_INDEX_DISP; goto extract_fmt_stq_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 192) :
+        }
+      case 192 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_LDIB_OFFSET), E (FMT_LDIB_OFFSET) }, { I (INSN_LDIB_OFFSET), E (FMT_LDIB_OFFSET) }, 
-              { I (INSN_LDIB_OFFSET), E (FMT_LDIB_OFFSET) }, { I (INSN_LDIB_OFFSET), E (FMT_LDIB_OFFSET) }, 
-              { I (INSN_LDIB_INDIRECT), E (FMT_LDIB_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_LDIB_INDIRECT_INDEX), E (FMT_LDIB_INDIRECT_INDEX) }, 
-              { I (INSN_LDIB_INDIRECT_OFFSET), E (FMT_LDIB_INDIRECT_OFFSET) }, { I (INSN_LDIB_INDIRECT_OFFSET), E (FMT_LDIB_INDIRECT_OFFSET) }, 
-              { I (INSN_LDIB_INDIRECT_OFFSET), E (FMT_LDIB_INDIRECT_OFFSET) }, { I (INSN_LDIB_INDIRECT_OFFSET), E (FMT_LDIB_INDIRECT_OFFSET) }, 
-              { I (INSN_LDIB_DISP), E (FMT_LDIB_DISP) }, { I (INSN_LDIB_INDIRECT_DISP), E (FMT_LDIB_INDIRECT_DISP) }, 
-              { I (INSN_LDIB_INDEX_DISP), E (FMT_LDIB_INDEX_DISP) }, { I (INSN_LDIB_INDIRECT_INDEX_DISP), E (FMT_LDIB_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_LDIB_OFFSET; goto extract_fmt_ldib_offset;
+          case 4 : itype = I960BASE_INSN_LDIB_INDIRECT; goto extract_fmt_ldib_indirect;
+          case 7 : itype = I960BASE_INSN_LDIB_INDIRECT_INDEX; goto extract_fmt_ldib_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_LDIB_INDIRECT_OFFSET; goto extract_fmt_ldib_indirect_offset;
+          case 12 : itype = I960BASE_INSN_LDIB_DISP; goto extract_fmt_ldib_disp;
+          case 13 : itype = I960BASE_INSN_LDIB_INDIRECT_DISP; goto extract_fmt_ldib_indirect_disp;
+          case 14 : itype = I960BASE_INSN_LDIB_INDEX_DISP; goto extract_fmt_ldib_index_disp;
+          case 15 : itype = I960BASE_INSN_LDIB_INDIRECT_INDEX_DISP; goto extract_fmt_ldib_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 200) :
+        }
+      case 200 :
+        {
+          unsigned int val = (((insn >> 10) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_LDIS_OFFSET), E (FMT_LDIS_OFFSET) }, { I (INSN_LDIS_OFFSET), E (FMT_LDIS_OFFSET) }, 
-              { I (INSN_LDIS_OFFSET), E (FMT_LDIS_OFFSET) }, { I (INSN_LDIS_OFFSET), E (FMT_LDIS_OFFSET) }, 
-              { I (INSN_LDIS_INDIRECT), E (FMT_LDIS_INDIRECT) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_LDIS_INDIRECT_INDEX), E (FMT_LDIS_INDIRECT_INDEX) }, 
-              { I (INSN_LDIS_INDIRECT_OFFSET), E (FMT_LDIS_INDIRECT_OFFSET) }, { I (INSN_LDIS_INDIRECT_OFFSET), E (FMT_LDIS_INDIRECT_OFFSET) }, 
-              { I (INSN_LDIS_INDIRECT_OFFSET), E (FMT_LDIS_INDIRECT_OFFSET) }, { I (INSN_LDIS_INDIRECT_OFFSET), E (FMT_LDIS_INDIRECT_OFFSET) }, 
-              { I (INSN_LDIS_DISP), E (FMT_LDIS_DISP) }, { I (INSN_LDIS_INDIRECT_DISP), E (FMT_LDIS_INDIRECT_DISP) }, 
-              { I (INSN_LDIS_INDEX_DISP), E (FMT_LDIS_INDEX_DISP) }, { I (INSN_LDIS_INDIRECT_INDEX_DISP), E (FMT_LDIS_INDIRECT_INDEX_DISP) }, 
-            };
-            unsigned int val = (((insn >> 10) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : /* fall through */
+          case 1 : /* fall through */
+          case 2 : /* fall through */
+          case 3 : itype = I960BASE_INSN_LDIS_OFFSET; goto extract_fmt_ldis_offset;
+          case 4 : itype = I960BASE_INSN_LDIS_INDIRECT; goto extract_fmt_ldis_indirect;
+          case 7 : itype = I960BASE_INSN_LDIS_INDIRECT_INDEX; goto extract_fmt_ldis_indirect_index;
+          case 8 : /* fall through */
+          case 9 : /* fall through */
+          case 10 : /* fall through */
+          case 11 : itype = I960BASE_INSN_LDIS_INDIRECT_OFFSET; goto extract_fmt_ldis_indirect_offset;
+          case 12 : itype = I960BASE_INSN_LDIS_DISP; goto extract_fmt_ldis_disp;
+          case 13 : itype = I960BASE_INSN_LDIS_INDIRECT_DISP; goto extract_fmt_ldis_indirect_disp;
+          case 14 : itype = I960BASE_INSN_LDIS_INDEX_DISP; goto extract_fmt_ldis_index_disp;
+          case 15 : itype = I960BASE_INSN_LDIS_INDIRECT_INDEX_DISP; goto extract_fmt_ldis_indirect_index_disp;
+          default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        DEFAULT (0) :
-          idecode = &insns[val];
-          GOTO_EXTRACT (idecode);
         }
-      ENDSWITCH (0)
+      default : itype = I960BASE_INSN_X_INVALID; goto extract_fmt_empty;
+      }
     }
-#undef I
-#undef E
   }
 
   /* The instruction has been decoded, now extract the fields.  */
 
- extract:
-  {
-#ifndef __GNUC__
-    switch (idecode->sfmt)
-#endif
-      {
-
-  CASE (ex, FMT_EMPTY) :
+ extract_fmt_empty:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_empty.f
   EXTRACT_IFMT_EMPTY_VARS /* */
@@ -1914,11 +1423,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_empty", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MULO) :
extract_fmt_mulo:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_mulo.f
   EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -1941,11 +1451,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MULO1) :
extract_fmt_mulo1:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_mulo1.f
   EXTRACT_IFMT_MULO1_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -1967,11 +1478,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MULO2) :
extract_fmt_mulo2:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_mulo2.f
   EXTRACT_IFMT_MULO2_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -1993,11 +1505,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MULO3) :
extract_fmt_mulo3:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_mulo3.f
   EXTRACT_IFMT_MULO3_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2018,11 +1531,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_NOTBIT) :
extract_fmt_notbit:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_notbit.f
   EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2045,11 +1559,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_NOTBIT1) :
extract_fmt_notbit1:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_notbit1.f
   EXTRACT_IFMT_MULO1_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2071,11 +1586,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_NOTBIT2) :
extract_fmt_notbit2:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_notbit2.f
   EXTRACT_IFMT_MULO2_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2097,11 +1613,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_NOTBIT3) :
extract_fmt_notbit3:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_notbit3.f
   EXTRACT_IFMT_MULO3_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2122,11 +1639,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_NOT) :
extract_fmt_not:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_not.f
   EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2147,11 +1665,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_NOT1) :
extract_fmt_not1:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_not1.f
   EXTRACT_IFMT_MULO1_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2171,11 +1690,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_NOT2) :
extract_fmt_not2:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_not2.f
   EXTRACT_IFMT_MULO2_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2196,11 +1716,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_NOT3) :
extract_fmt_not3:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_not3.f
   EXTRACT_IFMT_MULO3_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2220,11 +1741,120 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
+  }
+
+ extract_fmt_shlo:
+  {
+    const IDESC *idesc = &i960base_insn_data[itype];
+    CGEN_INSN_INT insn = base_insn;
+#define FLD(f) abuf->fields.fmt_shlo.f
+  EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
+
+  EXTRACT_IFMT_MULO_CODE
+
+  /* Record the fields for the semantic handler.  */
+  FLD (i_src1) = & CPU (h_gr)[f_src1];
+  FLD (i_src2) = & CPU (h_gr)[f_src2];
+  FLD (i_dst) = & CPU (h_gr)[f_srcdst];
+  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_shlo", "src1 0x%x", 'x', f_src1, "src2 0x%x", 'x', f_src2, "dst 0x%x", 'x', f_srcdst, (char *) 0));
+
+#if WITH_PROFILE_MODEL_P
+  /* Record the fields for profiling.  */
+  if (PROFILE_MODEL_P (current_cpu))
+    {
+      FLD (in_src1) = f_src1;
+      FLD (in_src2) = f_src2;
+      FLD (out_dst) = f_srcdst;
+    }
+#endif
+#undef FLD
+    return idesc;
+  }
+
+ extract_fmt_shlo1:
+  {
+    const IDESC *idesc = &i960base_insn_data[itype];
+    CGEN_INSN_INT insn = base_insn;
+#define FLD(f) abuf->fields.fmt_shlo1.f
+  EXTRACT_IFMT_MULO1_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
+
+  EXTRACT_IFMT_MULO1_CODE
+
+  /* Record the fields for the semantic handler.  */
+  FLD (f_src1) = f_src1;
+  FLD (i_src2) = & CPU (h_gr)[f_src2];
+  FLD (i_dst) = & CPU (h_gr)[f_srcdst];
+  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_shlo1", "f_src1 0x%x", 'x', f_src1, "src2 0x%x", 'x', f_src2, "dst 0x%x", 'x', f_srcdst, (char *) 0));
+
+#if WITH_PROFILE_MODEL_P
+  /* Record the fields for profiling.  */
+  if (PROFILE_MODEL_P (current_cpu))
+    {
+      FLD (in_src2) = f_src2;
+      FLD (out_dst) = f_srcdst;
+    }
+#endif
+#undef FLD
+    return idesc;
   }
 
 CASE (ex, FMT_EMUL) :
extract_fmt_shlo2:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
+    CGEN_INSN_INT insn = base_insn;
+#define FLD(f) abuf->fields.fmt_shlo2.f
+  EXTRACT_IFMT_MULO2_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
+
+  EXTRACT_IFMT_MULO2_CODE
+
+  /* Record the fields for the semantic handler.  */
+  FLD (f_src2) = f_src2;
+  FLD (i_src1) = & CPU (h_gr)[f_src1];
+  FLD (i_dst) = & CPU (h_gr)[f_srcdst];
+  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_shlo2", "f_src2 0x%x", 'x', f_src2, "src1 0x%x", 'x', f_src1, "dst 0x%x", 'x', f_srcdst, (char *) 0));
+
+#if WITH_PROFILE_MODEL_P
+  /* Record the fields for profiling.  */
+  if (PROFILE_MODEL_P (current_cpu))
+    {
+      FLD (in_src1) = f_src1;
+      FLD (out_dst) = f_srcdst;
+    }
+#endif
+#undef FLD
+    return idesc;
+  }
+
+ extract_fmt_shlo3:
+  {
+    const IDESC *idesc = &i960base_insn_data[itype];
+    CGEN_INSN_INT insn = base_insn;
+#define FLD(f) abuf->fields.fmt_shlo3.f
+  EXTRACT_IFMT_MULO3_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
+
+  EXTRACT_IFMT_MULO3_CODE
+
+  /* Record the fields for the semantic handler.  */
+  FLD (f_src1) = f_src1;
+  FLD (f_src2) = f_src2;
+  FLD (i_dst) = & CPU (h_gr)[f_srcdst];
+  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_shlo3", "f_src1 0x%x", 'x', f_src1, "f_src2 0x%x", 'x', f_src2, "dst 0x%x", 'x', f_srcdst, (char *) 0));
+
+#if WITH_PROFILE_MODEL_P
+  /* Record the fields for profiling.  */
+  if (PROFILE_MODEL_P (current_cpu))
+    {
+      FLD (out_dst) = f_srcdst;
+    }
+#endif
+#undef FLD
+    return idesc;
+  }
+
+ extract_fmt_emul:
+  {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_emul.f
   EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2245,15 +1875,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
       FLD (in_src1) = f_src1;
       FLD (in_src2) = f_src2;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_EMUL1) :
extract_fmt_emul1:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_emul1.f
   EXTRACT_IFMT_MULO1_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2273,15 +1904,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_src2) = f_src2;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_EMUL2) :
extract_fmt_emul2:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_emul2.f
   EXTRACT_IFMT_MULO2_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2301,15 +1933,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_src1) = f_src1;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_EMUL3) :
extract_fmt_emul3:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_emul3.f
   EXTRACT_IFMT_MULO3_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2328,15 +1961,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOVL) :
extract_fmt_movl:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_movl.f
   EXTRACT_IFMT_MULO2_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2354,18 +1988,19 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_src1_const__WI_1) = ((FLD (f_src1)) + (1));
+      FLD (in_h_gr_add__VM_index_of_src1_1) = ((FLD (f_src1)) + (1));
       FLD (in_src1) = f_src1;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOVL1) :
extract_fmt_movl1:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_movl1.f
   EXTRACT_IFMT_MULO3_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2383,15 +2018,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOVT) :
extract_fmt_movt:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_movt.f
   EXTRACT_IFMT_MULO2_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2409,20 +2045,21 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_src1_const__WI_1) = ((FLD (f_src1)) + (1));
-      FLD (in_h_gr_add__VM_index_of_src1_const__WI_2) = ((FLD (f_src1)) + (2));
+      FLD (in_h_gr_add__VM_index_of_src1_1) = ((FLD (f_src1)) + (1));
+      FLD (in_h_gr_add__VM_index_of_src1_2) = ((FLD (f_src1)) + (2));
       FLD (in_src1) = f_src1;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOVT1) :
extract_fmt_movt1:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_movt1.f
   EXTRACT_IFMT_MULO3_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2440,16 +2077,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOVQ) :
extract_fmt_movq:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_movq.f
   EXTRACT_IFMT_MULO2_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2467,22 +2105,23 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_src1_const__WI_1) = ((FLD (f_src1)) + (1));
-      FLD (in_h_gr_add__VM_index_of_src1_const__WI_2) = ((FLD (f_src1)) + (2));
-      FLD (in_h_gr_add__VM_index_of_src1_const__WI_3) = ((FLD (f_src1)) + (3));
+      FLD (in_h_gr_add__VM_index_of_src1_1) = ((FLD (f_src1)) + (1));
+      FLD (in_h_gr_add__VM_index_of_src1_2) = ((FLD (f_src1)) + (2));
+      FLD (in_h_gr_add__VM_index_of_src1_3) = ((FLD (f_src1)) + (3));
       FLD (in_src1) = f_src1;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_3) = ((FLD (f_srcdst)) + (3));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MOVQ1) :
extract_fmt_movq1:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_movq1.f
   EXTRACT_IFMT_MULO3_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2500,17 +2139,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_3) = ((FLD (f_srcdst)) + (3));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MODPC) :
extract_fmt_modpc:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_modpc.f
   EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -2531,11 +2171,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDA_OFFSET) :
extract_fmt_lda_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lda_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -2555,11 +2196,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDA_INDIRECT_OFFSET) :
extract_fmt_lda_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lda_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -2581,11 +2223,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDA_INDIRECT) :
extract_fmt_lda_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lda_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2606,11 +2249,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDA_INDIRECT_INDEX) :
extract_fmt_lda_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lda_indirect_index.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2634,11 +2278,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDA_DISP) :
extract_fmt_lda_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lda_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2658,11 +2303,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDA_INDIRECT_DISP) :
extract_fmt_lda_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lda_indirect_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2684,11 +2330,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDA_INDEX_DISP) :
extract_fmt_lda_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lda_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2711,11 +2358,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDA_INDIRECT_INDEX_DISP) :
extract_fmt_lda_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_lda_indirect_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2740,11 +2388,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD_OFFSET) :
extract_fmt_ld_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ld_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -2764,11 +2413,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD_INDIRECT_OFFSET) :
extract_fmt_ld_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ld_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -2790,11 +2440,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD_INDIRECT) :
extract_fmt_ld_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ld_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2815,11 +2466,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD_INDIRECT_INDEX) :
extract_fmt_ld_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ld_indirect_index.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2843,11 +2495,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD_DISP) :
extract_fmt_ld_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ld_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2867,11 +2520,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD_INDIRECT_DISP) :
extract_fmt_ld_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ld_indirect_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2893,11 +2547,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD_INDEX_DISP) :
extract_fmt_ld_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ld_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2920,11 +2575,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD_INDIRECT_INDEX_DISP) :
extract_fmt_ld_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ld_indirect_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -2949,11 +2605,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOB_OFFSET) :
extract_fmt_ldob_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldob_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -2973,11 +2630,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOB_INDIRECT_OFFSET) :
extract_fmt_ldob_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldob_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -2999,11 +2657,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOB_INDIRECT) :
extract_fmt_ldob_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldob_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3024,11 +2683,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOB_INDIRECT_INDEX) :
extract_fmt_ldob_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldob_indirect_index.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3052,11 +2712,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOB_DISP) :
extract_fmt_ldob_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldob_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3076,11 +2737,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOB_INDIRECT_DISP) :
extract_fmt_ldob_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldob_indirect_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3102,11 +2764,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOB_INDEX_DISP) :
extract_fmt_ldob_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldob_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3129,11 +2792,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOB_INDIRECT_INDEX_DISP) :
extract_fmt_ldob_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldob_indirect_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3158,11 +2822,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOS_OFFSET) :
extract_fmt_ldos_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldos_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -3182,11 +2847,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOS_INDIRECT_OFFSET) :
extract_fmt_ldos_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldos_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -3208,11 +2874,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOS_INDIRECT) :
extract_fmt_ldos_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldos_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3233,11 +2900,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOS_INDIRECT_INDEX) :
extract_fmt_ldos_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldos_indirect_index.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3261,11 +2929,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOS_DISP) :
extract_fmt_ldos_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldos_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3285,11 +2954,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOS_INDIRECT_DISP) :
extract_fmt_ldos_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldos_indirect_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3311,11 +2981,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOS_INDEX_DISP) :
extract_fmt_ldos_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldos_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3338,11 +3009,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDOS_INDIRECT_INDEX_DISP) :
extract_fmt_ldos_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldos_indirect_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3367,11 +3039,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIB_OFFSET) :
extract_fmt_ldib_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldib_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -3391,11 +3064,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIB_INDIRECT_OFFSET) :
extract_fmt_ldib_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldib_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -3417,11 +3091,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIB_INDIRECT) :
extract_fmt_ldib_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldib_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3442,11 +3117,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIB_INDIRECT_INDEX) :
extract_fmt_ldib_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldib_indirect_index.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3470,11 +3146,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIB_DISP) :
extract_fmt_ldib_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldib_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3494,11 +3171,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIB_INDIRECT_DISP) :
extract_fmt_ldib_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldib_indirect_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3520,11 +3198,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIB_INDEX_DISP) :
extract_fmt_ldib_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldib_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3547,11 +3226,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIB_INDIRECT_INDEX_DISP) :
extract_fmt_ldib_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldib_indirect_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3576,11 +3256,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIS_OFFSET) :
extract_fmt_ldis_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldis_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -3600,11 +3281,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIS_INDIRECT_OFFSET) :
extract_fmt_ldis_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldis_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -3626,11 +3308,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIS_INDIRECT) :
extract_fmt_ldis_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldis_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3651,11 +3334,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIS_INDIRECT_INDEX) :
extract_fmt_ldis_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldis_indirect_index.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3679,11 +3363,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIS_DISP) :
extract_fmt_ldis_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldis_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3703,11 +3388,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIS_INDIRECT_DISP) :
extract_fmt_ldis_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldis_indirect_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3729,11 +3415,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIS_INDEX_DISP) :
extract_fmt_ldis_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldis_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3756,11 +3443,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDIS_INDIRECT_INDEX_DISP) :
extract_fmt_ldis_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldis_indirect_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3785,11 +3473,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDL_OFFSET) :
extract_fmt_ldl_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldl_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -3807,15 +3496,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDL_INDIRECT_OFFSET) :
extract_fmt_ldl_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldl_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -3835,15 +3525,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_abase) = f_abase;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDL_INDIRECT) :
extract_fmt_ldl_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldl_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3862,15 +3553,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_abase) = f_abase;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDL_INDIRECT_INDEX) :
extract_fmt_ldl_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldl_indirect_index.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3892,15 +3584,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
       FLD (in_abase) = f_abase;
       FLD (in_index) = f_index;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDL_DISP) :
extract_fmt_ldl_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldl_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3918,15 +3611,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDL_INDIRECT_DISP) :
extract_fmt_ldl_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldl_indirect_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3946,15 +3640,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_abase) = f_abase;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDL_INDEX_DISP) :
extract_fmt_ldl_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldl_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -3975,15 +3670,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_index) = f_index;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDL_INDIRECT_INDEX_DISP) :
extract_fmt_ldl_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldl_indirect_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4006,15 +3702,16 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
       FLD (in_abase) = f_abase;
       FLD (in_index) = f_index;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDT_OFFSET) :
extract_fmt_ldt_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldt_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -4032,16 +3729,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDT_INDIRECT_OFFSET) :
extract_fmt_ldt_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldt_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -4061,16 +3759,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_abase) = f_abase;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDT_INDIRECT) :
extract_fmt_ldt_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldt_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4089,16 +3788,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_abase) = f_abase;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDT_INDIRECT_INDEX) :
extract_fmt_ldt_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldt_indirect_index.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4120,16 +3820,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
       FLD (in_abase) = f_abase;
       FLD (in_index) = f_index;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDT_DISP) :
extract_fmt_ldt_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldt_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4147,16 +3848,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDT_INDIRECT_DISP) :
extract_fmt_ldt_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldt_indirect_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4176,16 +3878,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_abase) = f_abase;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDT_INDEX_DISP) :
extract_fmt_ldt_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldt_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4206,16 +3909,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_index) = f_index;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDT_INDIRECT_INDEX_DISP) :
extract_fmt_ldt_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldt_indirect_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4238,16 +3942,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
       FLD (in_abase) = f_abase;
       FLD (in_index) = f_index;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDQ_OFFSET) :
extract_fmt_ldq_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldq_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -4265,17 +3970,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_3) = ((FLD (f_srcdst)) + (3));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDQ_INDIRECT_OFFSET) :
extract_fmt_ldq_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldq_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -4295,17 +4001,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_abase) = f_abase;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_3) = ((FLD (f_srcdst)) + (3));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDQ_INDIRECT) :
extract_fmt_ldq_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldq_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4324,17 +4031,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_abase) = f_abase;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_3) = ((FLD (f_srcdst)) + (3));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDQ_INDIRECT_INDEX) :
extract_fmt_ldq_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldq_indirect_index.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4356,17 +4064,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
       FLD (in_abase) = f_abase;
       FLD (in_index) = f_index;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_3) = ((FLD (f_srcdst)) + (3));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDQ_DISP) :
extract_fmt_ldq_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldq_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4384,17 +4093,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_3) = ((FLD (f_srcdst)) + (3));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDQ_INDIRECT_DISP) :
extract_fmt_ldq_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldq_indirect_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4414,17 +4124,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_abase) = f_abase;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_3) = ((FLD (f_srcdst)) + (3));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDQ_INDEX_DISP) :
extract_fmt_ldq_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldq_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4445,17 +4156,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     {
       FLD (in_index) = f_index;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_3) = ((FLD (f_srcdst)) + (3));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDQ_INDIRECT_INDEX_DISP) :
extract_fmt_ldq_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_ldq_indirect_index_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4478,17 +4190,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
       FLD (in_abase) = f_abase;
       FLD (in_index) = f_index;
       FLD (out_dst) = f_srcdst;
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (out_h_gr_add__VM_index_of_dst_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (out_h_gr_add__VM_index_of_dst_1) = ((FLD (f_srcdst)) + (1));
+      FLD (out_h_gr_add__VM_index_of_dst_2) = ((FLD (f_srcdst)) + (2));
+      FLD (out_h_gr_add__VM_index_of_dst_3) = ((FLD (f_srcdst)) + (3));
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST_OFFSET) :
extract_fmt_st_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_st_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -4508,11 +4221,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST_INDIRECT_OFFSET) :
extract_fmt_st_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_st_indirect_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -4534,11 +4248,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST_INDIRECT) :
extract_fmt_st_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_st_indirect.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4559,11 +4274,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST_INDIRECT_INDEX) :
extract_fmt_st_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_st_indirect_index.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4587,11 +4303,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST_DISP) :
extract_fmt_st_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_st_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4611,11 +4328,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST_INDIRECT_DISP) :
extract_fmt_st_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_st_indirect_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4637,11 +4355,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST_INDEX_DISP) :
extract_fmt_st_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_st_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4664,11 +4383,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST_INDIRECT_INDEX_DISP) :
extract_fmt_st_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_st_indirect_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4693,11 +4413,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOB_OFFSET) :
extract_fmt_stob_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stob_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -4717,11 +4438,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOB_INDIRECT_OFFSET) :
extract_fmt_stob_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stob_indirect_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -4743,11 +4465,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOB_INDIRECT) :
extract_fmt_stob_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stob_indirect.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4768,11 +4491,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOB_INDIRECT_INDEX) :
extract_fmt_stob_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stob_indirect_index.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4796,11 +4520,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOB_DISP) :
extract_fmt_stob_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stob_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4820,11 +4545,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOB_INDIRECT_DISP) :
extract_fmt_stob_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stob_indirect_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4846,11 +4572,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOB_INDEX_DISP) :
extract_fmt_stob_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stob_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4873,11 +4600,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOB_INDIRECT_INDEX_DISP) :
extract_fmt_stob_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stob_indirect_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4902,11 +4630,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOS_OFFSET) :
extract_fmt_stos_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stos_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -4926,11 +4655,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOS_INDIRECT_OFFSET) :
extract_fmt_stos_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stos_indirect_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -4952,11 +4682,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOS_INDIRECT) :
extract_fmt_stos_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stos_indirect.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -4977,11 +4708,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOS_INDIRECT_INDEX) :
extract_fmt_stos_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stos_indirect_index.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5005,11 +4737,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOS_DISP) :
extract_fmt_stos_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stos_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5029,11 +4762,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOS_INDIRECT_DISP) :
extract_fmt_stos_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stos_indirect_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5055,11 +4789,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOS_INDEX_DISP) :
extract_fmt_stos_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stos_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5082,11 +4817,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STOS_INDIRECT_INDEX_DISP) :
extract_fmt_stos_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stos_indirect_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5111,11 +4847,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STL_OFFSET) :
extract_fmt_stl_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stl_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -5132,16 +4869,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STL_INDIRECT_OFFSET) :
extract_fmt_stl_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stl_indirect_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -5160,16 +4898,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STL_INDIRECT) :
extract_fmt_stl_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stl_indirect.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5187,16 +4926,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STL_INDIRECT_INDEX) :
extract_fmt_stl_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stl_indirect_index.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5216,17 +4956,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
       FLD (in_index) = f_index;
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STL_DISP) :
extract_fmt_stl_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stl_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5243,16 +4984,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STL_INDIRECT_DISP) :
extract_fmt_stl_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stl_indirect_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5271,16 +5013,17 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STL_INDEX_DISP) :
extract_fmt_stl_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stl_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5299,17 +5042,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
       FLD (in_index) = f_index;
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STL_INDIRECT_INDEX_DISP) :
extract_fmt_stl_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stl_indirect_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5330,17 +5074,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
       FLD (in_index) = f_index;
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STT_OFFSET) :
extract_fmt_stt_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stt_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -5357,17 +5102,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STT_INDIRECT_OFFSET) :
extract_fmt_stt_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stt_indirect_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -5386,17 +5132,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STT_INDIRECT) :
extract_fmt_stt_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stt_indirect.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5414,17 +5161,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STT_INDIRECT_INDEX) :
extract_fmt_stt_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stt_indirect_index.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5444,18 +5192,19 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
       FLD (in_index) = f_index;
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STT_DISP) :
extract_fmt_stt_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stt_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5472,17 +5221,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STT_INDIRECT_DISP) :
extract_fmt_stt_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stt_indirect_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5501,17 +5251,18 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STT_INDEX_DISP) :
extract_fmt_stt_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stt_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5530,18 +5281,19 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
       FLD (in_index) = f_index;
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STT_INDIRECT_INDEX_DISP) :
extract_fmt_stt_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stt_indirect_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5562,18 +5314,19 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
       FLD (in_index) = f_index;
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STQ_OFFSET) :
extract_fmt_stq_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stq_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -5590,18 +5343,19 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_3) = ((FLD (f_srcdst)) + (3));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STQ_INDIRECT_OFFSET) :
extract_fmt_stq_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stq_indirect_offset.f
   EXTRACT_IFMT_ST_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -5620,18 +5374,19 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_3) = ((FLD (f_srcdst)) + (3));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STQ_INDIRECT) :
extract_fmt_stq_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stq_indirect.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5649,18 +5404,19 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_3) = ((FLD (f_srcdst)) + (3));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STQ_INDIRECT_INDEX) :
extract_fmt_stq_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stq_indirect_index.f
   EXTRACT_IFMT_ST_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5680,19 +5436,20 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_3) = ((FLD (f_srcdst)) + (3));
       FLD (in_index) = f_index;
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STQ_DISP) :
extract_fmt_stq_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stq_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5709,18 +5466,19 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_3) = ((FLD (f_srcdst)) + (3));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STQ_INDIRECT_DISP) :
extract_fmt_stq_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stq_indirect_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5739,18 +5497,19 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_3) = ((FLD (f_srcdst)) + (3));
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STQ_INDEX_DISP) :
extract_fmt_stq_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stq_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5769,19 +5528,20 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   /* Record the fields for profiling.  */
   if (PROFILE_MODEL_P (current_cpu))
     {
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_3) = ((FLD (f_srcdst)) + (3));
       FLD (in_index) = f_index;
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STQ_INDIRECT_INDEX_DISP) :
extract_fmt_stq_indirect_index_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_stq_indirect_index_disp.f
   EXTRACT_IFMT_ST_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -5802,19 +5562,20 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   if (PROFILE_MODEL_P (current_cpu))
     {
       FLD (in_abase) = f_abase;
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_1) = ((FLD (f_srcdst)) + (1));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_2) = ((FLD (f_srcdst)) + (2));
-      FLD (in_h_gr_add__VM_index_of_st_src_const__WI_3) = ((FLD (f_srcdst)) + (3));
+      FLD (in_h_gr_add__VM_index_of_st_src_1) = ((FLD (f_srcdst)) + (1));
+      FLD (in_h_gr_add__VM_index_of_st_src_2) = ((FLD (f_srcdst)) + (2));
+      FLD (in_h_gr_add__VM_index_of_st_src_3) = ((FLD (f_srcdst)) + (3));
       FLD (in_index) = f_index;
       FLD (in_st_src) = f_srcdst;
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPOBE_REG) :
extract_fmt_cmpobe_reg:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_reg.f
   EXTRACT_IFMT_CMPOBE_REG_VARS /* f-opcode f-br-src1 f-br-src2 f-br-m1 f-br-disp f-br-zero */
@@ -5837,11 +5598,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPOBE_LIT) :
extract_fmt_cmpobe_lit:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_lit.f
   EXTRACT_IFMT_CMPOBE_LIT_VARS /* f-opcode f-br-src1 f-br-src2 f-br-m1 f-br-disp f-br-zero */
@@ -5863,11 +5625,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPOBL_REG) :
extract_fmt_cmpobl_reg:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobl_reg.f
   EXTRACT_IFMT_CMPOBE_REG_VARS /* f-opcode f-br-src1 f-br-src2 f-br-m1 f-br-disp f-br-zero */
@@ -5890,11 +5653,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPOBL_LIT) :
extract_fmt_cmpobl_lit:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobl_lit.f
   EXTRACT_IFMT_CMPOBE_LIT_VARS /* f-opcode f-br-src1 f-br-src2 f-br-m1 f-br-disp f-br-zero */
@@ -5916,11 +5680,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BBC_REG) :
extract_fmt_bbc_reg:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bbc_reg.f
   EXTRACT_IFMT_CMPOBE_REG_VARS /* f-opcode f-br-src1 f-br-src2 f-br-m1 f-br-disp f-br-zero */
@@ -5943,11 +5708,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BBC_LIT) :
extract_fmt_bbc_lit:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bbc_lit.f
   EXTRACT_IFMT_CMPOBE_LIT_VARS /* f-opcode f-br-src1 f-br-src2 f-br-m1 f-br-disp f-br-zero */
@@ -5969,11 +5735,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPI) :
extract_fmt_cmpi:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmpi.f
   EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -5994,11 +5761,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPI1) :
extract_fmt_cmpi1:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmpi1.f
   EXTRACT_IFMT_MULO1_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -6018,11 +5786,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPI2) :
extract_fmt_cmpi2:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmpi2.f
   EXTRACT_IFMT_MULO2_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -6042,11 +5811,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPI3) :
extract_fmt_cmpi3:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmpi3.f
   EXTRACT_IFMT_MULO3_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -6065,11 +5835,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPO) :
extract_fmt_cmpo:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmpo.f
   EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -6090,11 +5861,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPO1) :
extract_fmt_cmpo1:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmpo1.f
   EXTRACT_IFMT_MULO1_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -6114,11 +5886,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPO2) :
extract_fmt_cmpo2:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmpo2.f
   EXTRACT_IFMT_MULO2_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -6138,11 +5911,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPO3) :
extract_fmt_cmpo3:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_cmpo3.f
   EXTRACT_IFMT_MULO3_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -6161,11 +5935,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_TESTNO_REG) :
extract_fmt_testno_reg:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_testno_reg.f
   EXTRACT_IFMT_CMPOBE_REG_VARS /* f-opcode f-br-src1 f-br-src2 f-br-m1 f-br-disp f-br-zero */
@@ -6184,11 +5959,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BNO) :
extract_fmt_bno:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bno.f
   EXTRACT_IFMT_BNO_VARS /* f-opcode f-ctrl-disp f-ctrl-zero */
@@ -6207,11 +5983,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_B) :
extract_fmt_b:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_b.f
   EXTRACT_IFMT_BNO_VARS /* f-opcode f-ctrl-disp f-ctrl-zero */
@@ -6230,11 +6007,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BX_INDIRECT_OFFSET) :
extract_fmt_bx_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bx_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -6255,11 +6033,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BX_INDIRECT) :
extract_fmt_bx_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bx_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -6279,11 +6058,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BX_INDIRECT_INDEX) :
extract_fmt_bx_indirect_index:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bx_indirect_index.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -6306,11 +6086,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BX_DISP) :
extract_fmt_bx_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bx_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -6329,11 +6110,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BX_INDIRECT_DISP) :
extract_fmt_bx_indirect_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bx_indirect_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -6354,11 +6136,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CALLX_DISP) :
extract_fmt_callx_disp:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_callx_disp.f
   EXTRACT_IFMT_LDA_DISP_VARS /* f-opcode f-optdisp f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -6411,11 +6194,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CALLX_INDIRECT) :
extract_fmt_callx_indirect:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_callx_indirect.f
   EXTRACT_IFMT_LDA_INDIRECT_VARS /* f-opcode f-srcdst f-abase f-modeb f-scale f-zerob f-index */
@@ -6469,11 +6253,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CALLX_INDIRECT_OFFSET) :
extract_fmt_callx_indirect_offset:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_callx_indirect_offset.f
   EXTRACT_IFMT_LDA_OFFSET_VARS /* f-opcode f-srcdst f-abase f-modea f-zeroa f-offset */
@@ -6528,11 +6313,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_RET) :
extract_fmt_ret:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_ret.f
   EXTRACT_IFMT_BNO_VARS /* f-opcode f-ctrl-disp f-ctrl-zero */
@@ -6570,11 +6356,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CALLS) :
extract_fmt_calls:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_calls.f
   EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -6594,11 +6381,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_FMARK) :
extract_fmt_fmark:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_fmark.f
   EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -6616,11 +6404,12 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_FLUSHREG) :
extract_fmt_flushreg:
   {
+    const IDESC *idesc = &i960base_insn_data[itype];
     CGEN_INSN_INT insn = base_insn;
 #define FLD(f) abuf->fields.fmt_flushreg.f
   EXTRACT_IFMT_MULO_VARS /* f-opcode f-srcdst f-src2 f-m3 f-m2 f-m1 f-opcode2 f-zero f-src1 */
@@ -6631,14 +6420,7 @@ i960base_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_flushreg", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
-  }
-
-
-      }
-    ENDSWITCH (ex)
-
+    return idesc;
   }
 
-  return idecode->idesc;
 }
index 6137217c2a8cd0d870d632735f1aec50d4a434f0..80fbde63a5c04c620a709e180f7fa5adcba1a5f4 100644 (file)
@@ -48,8 +48,10 @@ typedef enum i960base_insn_type {
  , I960BASE_INSN_NOTAND2, I960BASE_INSN_NOTAND3, I960BASE_INSN_XOR, I960BASE_INSN_XOR1
  , I960BASE_INSN_XOR2, I960BASE_INSN_XOR3, I960BASE_INSN_OR, I960BASE_INSN_OR1
  , I960BASE_INSN_OR2, I960BASE_INSN_OR3, I960BASE_INSN_NOR, I960BASE_INSN_NOR1
- , I960BASE_INSN_NOR2, I960BASE_INSN_NOR3, I960BASE_INSN_NOT, I960BASE_INSN_NOT1
- , I960BASE_INSN_NOT2, I960BASE_INSN_NOT3, I960BASE_INSN_CLRBIT, I960BASE_INSN_CLRBIT1
+ , I960BASE_INSN_NOR2, I960BASE_INSN_NOR3, I960BASE_INSN_XNOR, I960BASE_INSN_XNOR1
+ , I960BASE_INSN_XNOR2, I960BASE_INSN_XNOR3, I960BASE_INSN_NOT, I960BASE_INSN_NOT1
+ , I960BASE_INSN_NOT2, I960BASE_INSN_NOT3, I960BASE_INSN_ORNOT, I960BASE_INSN_ORNOT1
+ , I960BASE_INSN_ORNOT2, I960BASE_INSN_ORNOT3, I960BASE_INSN_CLRBIT, I960BASE_INSN_CLRBIT1
  , I960BASE_INSN_CLRBIT2, I960BASE_INSN_CLRBIT3, I960BASE_INSN_SHLO, I960BASE_INSN_SHLO1
  , I960BASE_INSN_SHLO2, I960BASE_INSN_SHLO3, I960BASE_INSN_SHRO, I960BASE_INSN_SHRO1
  , I960BASE_INSN_SHRO2, I960BASE_INSN_SHRO3, I960BASE_INSN_SHLI, I960BASE_INSN_SHLI1
@@ -192,10 +194,18 @@ SEM (nor)
 SEM (nor1)
 SEM (nor2)
 SEM (nor3)
+SEM (xnor)
+SEM (xnor1)
+SEM (xnor2)
+SEM (xnor3)
 SEM (not)
 SEM (not1)
 SEM (not2)
 SEM (not3)
+SEM (ornot)
+SEM (ornot1)
+SEM (ornot2)
+SEM (ornot3)
 SEM (clrbit)
 SEM (clrbit1)
 SEM (clrbit2)
index d34e6720201c30a8c2977469db68a22677354864..0a475691adf3004004bea419ac0b453387d0751e 100644 (file)
@@ -32,10 +32,8 @@ device i960_devices;
 int
 device_io_read_buffer (device *me, void *source, int space,
                       address_word addr, unsigned nr_bytes,
-                      SIM_CPU *cpu, sim_cia cia)
+                      SIM_DESC sd, SIM_CPU *cpu, sim_cia cia)
 {
-  SIM_DESC sd = CPU_STATE (cpu);
-
   if (STATE_ENVIRONMENT (sd) != OPERATING_ENVIRONMENT)
     return nr_bytes;
 
@@ -70,10 +68,8 @@ device_io_read_buffer (device *me, void *source, int space,
 int
 device_io_write_buffer (device *me, const void *source, int space,
                        address_word addr, unsigned nr_bytes,
-                       SIM_CPU *cpu, sim_cia cia)
+                       SIM_DESC sd, SIM_CPU *cpu, sim_cia cia)
 {
-  SIM_DESC sd = CPU_STATE (cpu);
-
 #if WITH_SCACHE
   /* MSPR support is deprecated but is kept in for upward compatibility
      with existing overlay support.  */
@@ -105,4 +101,7 @@ device_io_write_buffer (device *me, const void *source, int space,
   return nr_bytes;
 }
 
-void device_error () {}
+void
+device_error (device *me, char *message, ...)
+{
+}
index 6ea8fdc5b3ca72d4636995c8f2e5b4eccb801bd1..8c1ca649d495877389999d0f586f60d3cec43511 100644 (file)
@@ -25,6 +25,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "sysdep.h"
 #include <ctype.h>
 #include <stdio.h>
+#include <stdarg.h>
 #include "ansidecl.h"
 #include "bfd.h"
 #include "symcat.h"
@@ -50,15 +51,22 @@ static const CGEN_ATTR_ENTRY MACH_attr[] =
   { 0, 0 }
 };
 
+static const CGEN_ATTR_ENTRY ISA_attr[] =
+{
+  { "i960", ISA_I960 },
+  { "max", ISA_MAX },
+  { 0, 0 }
+};
+
 const CGEN_ATTR_TABLE i960_cgen_ifield_attr_table[] =
 {
   { "MACH", & MACH_attr[0] },
   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
-  { "UNSIGNED", &bool_attr[0], &bool_attr[0] },
   { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
   { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
   { "RESERVED", &bool_attr[0], &bool_attr[0] },
   { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
+  { "SIGNED", &bool_attr[0], &bool_attr[0] },
   { 0, 0, 0 }
 };
 
@@ -66,10 +74,7 @@ const CGEN_ATTR_TABLE i960_cgen_hardware_attr_table[] =
 {
   { "MACH", & MACH_attr[0] },
   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
-  { "UNSIGNED", &bool_attr[0], &bool_attr[0] },
-  { "SIGNED", &bool_attr[0], &bool_attr[0] },
   { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] },
-  { "FUN-ACCESS", &bool_attr[0], &bool_attr[0] },
   { "PC", &bool_attr[0], &bool_attr[0] },
   { "PROFILE", &bool_attr[0], &bool_attr[0] },
   { 0, 0, 0 }
@@ -79,10 +84,10 @@ const CGEN_ATTR_TABLE i960_cgen_operand_attr_table[] =
 {
   { "MACH", & MACH_attr[0] },
   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
-  { "UNSIGNED", &bool_attr[0], &bool_attr[0] },
   { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
   { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
   { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
+  { "SIGNED", &bool_attr[0], &bool_attr[0] },
   { "NEGATIVE", &bool_attr[0], &bool_attr[0] },
   { "RELAX", &bool_attr[0], &bool_attr[0] },
   { "SEM-ONLY", &bool_attr[0], &bool_attr[0] },
@@ -105,7 +110,22 @@ const CGEN_ATTR_TABLE i960_cgen_insn_attr_table[] =
   { 0, 0, 0 }
 };
 
-CGEN_KEYWORD_ENTRY i960_cgen_opval_h_gr_entries[] = 
+/* Instruction set variants.  */
+
+static const CGEN_ISA i960_cgen_isa_table[] = {
+  { "i960", 32, 32, 32, 64,  },
+  { 0 }
+};
+
+/* Machine variants.  */
+
+static const CGEN_MACH i960_cgen_mach_table[] = {
+  { "i960:ka_sa", "i960:ka_sa", MACH_I960_KA_SA },
+  { "i960:ca", "i960:ca", MACH_I960_CA },
+  { 0 }
+};
+
+static CGEN_KEYWORD_ENTRY i960_cgen_opval_h_gr_entries[] =
 {
   { "fp", 31 },
   { "sp", 1 },
@@ -143,18 +163,18 @@ CGEN_KEYWORD_ENTRY i960_cgen_opval_h_gr_entries[] =
   { "g15", 31 }
 };
 
-CGEN_KEYWORD i960_cgen_opval_h_gr = 
+CGEN_KEYWORD i960_cgen_opval_h_gr =
 {
   & i960_cgen_opval_h_gr_entries[0],
   34
 };
 
-CGEN_KEYWORD_ENTRY i960_cgen_opval_h_cc_entries[] = 
+static CGEN_KEYWORD_ENTRY i960_cgen_opval_h_cc_entries[] =
 {
   { "cc", 0 }
 };
 
-CGEN_KEYWORD i960_cgen_opval_h_cc = 
+CGEN_KEYWORD i960_cgen_opval_h_cc =
 {
   & i960_cgen_opval_h_cc_entries[0],
   1
@@ -164,57 +184,55 @@ CGEN_KEYWORD i960_cgen_opval_h_cc =
 
 /* The hardware table.  */
 
-#define A(a) (1 << (CONCAT2 (CGEN_HW_,a) - CGEN_ATTR_BOOL_OFFSET))
-#define HW_ENT(n) i960_cgen_hw_table[n]
+#define A(a) (1 << CONCAT2 (CGEN_HW_,a))
 
 const CGEN_HW_ENTRY i960_cgen_hw_table[] =
 {
-  { HW_H_PC, & HW_ENT (HW_H_PC + 1), "h-pc", CGEN_ASM_KEYWORD, (PTR) 0, { CGEN_HW_NBOOL_ATTRS, 0|A(PROFILE)|A(PC), { (1<<MACH_BASE) } } },
-  { HW_H_MEMORY, & HW_ENT (HW_H_MEMORY + 1), "h-memory", CGEN_ASM_KEYWORD, (PTR) 0, { CGEN_HW_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } } },
-  { HW_H_SINT, & HW_ENT (HW_H_SINT + 1), "h-sint", CGEN_ASM_KEYWORD, (PTR) 0, { CGEN_HW_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } } },
-  { HW_H_UINT, & HW_ENT (HW_H_UINT + 1), "h-uint", CGEN_ASM_KEYWORD, (PTR) 0, { CGEN_HW_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } } },
-  { HW_H_ADDR, & HW_ENT (HW_H_ADDR + 1), "h-addr", CGEN_ASM_KEYWORD, (PTR) 0, { CGEN_HW_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } } },
-  { HW_H_IADDR, & HW_ENT (HW_H_IADDR + 1), "h-iaddr", CGEN_ASM_KEYWORD, (PTR) 0, { CGEN_HW_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } } },
-  { HW_H_GR, & HW_ENT (HW_H_GR + 1), "h-gr", CGEN_ASM_KEYWORD, (PTR) & i960_cgen_opval_h_gr, { CGEN_HW_NBOOL_ATTRS, 0|A(CACHE_ADDR)|A(PROFILE), { (1<<MACH_BASE) } } },
-  { HW_H_CC, & HW_ENT (HW_H_CC + 1), "h-cc", CGEN_ASM_KEYWORD, (PTR) & i960_cgen_opval_h_cc, { CGEN_HW_NBOOL_ATTRS, 0|A(CACHE_ADDR)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { (1<<MACH_BASE) } } },
+  { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PROFILE)|A(PC), { (1<<MACH_BASE) } } },
+  { "h-gr", HW_H_GR, CGEN_ASM_KEYWORD, (PTR) & i960_cgen_opval_h_gr, { 0|A(CACHE_ADDR)|A(PROFILE), { (1<<MACH_BASE) } } },
+  { "h-cc", HW_H_CC, CGEN_ASM_KEYWORD, (PTR) & i960_cgen_opval_h_cc, { 0|A(CACHE_ADDR)|A(PROFILE), { (1<<MACH_BASE) } } },
   { 0 }
 };
 
-/* don't undef HW_ENT, used later */
 #undef A
 
 /* The instruction field table.  */
 
-#define A(a) (1 << (CONCAT2 (CGEN_IFLD_,a) - CGEN_ATTR_BOOL_OFFSET))
+#define A(a) (1 << CONCAT2 (CGEN_IFLD_,a))
 
 const CGEN_IFLD i960_cgen_ifld_table[] =
 {
-  { I960_F_NIL, "f-nil", 0, 0, 0, 0, { CGEN_IFLD_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }  },
-  { I960_F_OPCODE, "f-opcode", 0, 32, 0, 8, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_SRCDST, "f-srcdst", 0, 32, 8, 5, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_SRC2, "f-src2", 0, 32, 13, 5, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_M3, "f-m3", 0, 32, 18, 1, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_M2, "f-m2", 0, 32, 19, 1, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_M1, "f-m1", 0, 32, 20, 1, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_OPCODE2, "f-opcode2", 0, 32, 21, 4, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_ZERO, "f-zero", 0, 32, 25, 2, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_SRC1, "f-src1", 0, 32, 27, 5, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_ABASE, "f-abase", 0, 32, 13, 5, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_MODEA, "f-modea", 0, 32, 18, 1, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_ZEROA, "f-zeroa", 0, 32, 19, 1, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_OFFSET, "f-offset", 0, 32, 20, 12, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_MODEB, "f-modeb", 0, 32, 18, 4, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_SCALE, "f-scale", 0, 32, 22, 3, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_ZEROB, "f-zerob", 0, 32, 25, 2, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_INDEX, "f-index", 0, 32, 27, 5, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_OPTDISP, "f-optdisp", 32, 32, 0, 32, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_BR_SRC1, "f-br-src1", 0, 32, 8, 5, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_BR_SRC2, "f-br-src2", 0, 32, 13, 5, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_BR_M1, "f-br-m1", 0, 32, 18, 1, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_BR_DISP, "f-br-disp", 0, 32, 19, 11, { CGEN_IFLD_NBOOL_ATTRS, 0|A(PCREL_ADDR), { (1<<MACH_BASE) } }  },
-  { I960_F_BR_ZERO, "f-br-zero", 0, 32, 30, 2, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
-  { I960_F_CTRL_DISP, "f-ctrl-disp", 0, 32, 8, 22, { CGEN_IFLD_NBOOL_ATTRS, 0|A(PCREL_ADDR), { (1<<MACH_BASE) } }  },
-  { I960_F_CTRL_ZERO, "f-ctrl-zero", 0, 32, 30, 2, { CGEN_IFLD_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { I960_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_OPCODE, "f-opcode", 0, 32, 0, 8, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_SRCDST, "f-srcdst", 0, 32, 8, 5, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_SRC2, "f-src2", 0, 32, 13, 5, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_M3, "f-m3", 0, 32, 18, 1, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_M2, "f-m2", 0, 32, 19, 1, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_M1, "f-m1", 0, 32, 20, 1, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_OPCODE2, "f-opcode2", 0, 32, 21, 4, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_ZERO, "f-zero", 0, 32, 25, 2, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_SRC1, "f-src1", 0, 32, 27, 5, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_ABASE, "f-abase", 0, 32, 13, 5, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_MODEA, "f-modea", 0, 32, 18, 1, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_ZEROA, "f-zeroa", 0, 32, 19, 1, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_OFFSET, "f-offset", 0, 32, 20, 12, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_MODEB, "f-modeb", 0, 32, 18, 4, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_SCALE, "f-scale", 0, 32, 22, 3, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_ZEROB, "f-zerob", 0, 32, 25, 2, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_INDEX, "f-index", 0, 32, 27, 5, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_OPTDISP, "f-optdisp", 32, 32, 0, 32, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_BR_SRC1, "f-br-src1", 0, 32, 8, 5, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_BR_SRC2, "f-br-src2", 0, 32, 13, 5, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_BR_M1, "f-br-m1", 0, 32, 18, 1, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_BR_DISP, "f-br-disp", 0, 32, 19, 11, { 0|A(PCREL_ADDR), { (1<<MACH_BASE) } }  },
+  { I960_F_BR_ZERO, "f-br-zero", 0, 32, 30, 2, { 0, { (1<<MACH_BASE) } }  },
+  { I960_F_CTRL_DISP, "f-ctrl-disp", 0, 32, 8, 22, { 0|A(PCREL_ADDR), { (1<<MACH_BASE) } }  },
+  { I960_F_CTRL_ZERO, "f-ctrl-zero", 0, 32, 30, 2, { 0, { (1<<MACH_BASE) } }  },
   { 0 }
 };
 
@@ -222,67 +240,68 @@ const CGEN_IFLD i960_cgen_ifld_table[] =
 
 /* The operand table.  */
 
-#define A(a) (1 << (CONCAT2 (CGEN_OPERAND_,a) - CGEN_ATTR_BOOL_OFFSET))
+#define A(a) (1 << CONCAT2 (CGEN_OPERAND_,a))
 #define OPERAND(op) CONCAT2 (I960_OPERAND_,op)
 
-const CGEN_OPERAND i960_cgen_operand_table[MAX_OPERANDS] =
+const CGEN_OPERAND i960_cgen_operand_table[] =
 {
 /* pc: program counter */
-  { "pc", & HW_ENT (HW_H_PC), 0, 0,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
+  { "pc", I960_OPERAND_PC, HW_H_PC, 0, 0,
+    { 0|A(SEM_ONLY), { (1<<MACH_BASE) } }  },
 /* src1: source register 1 */
-  { "src1", & HW_ENT (HW_H_GR), 27, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "src1", I960_OPERAND_SRC1, HW_H_GR, 27, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* src2: source register 2 */
-  { "src2", & HW_ENT (HW_H_GR), 13, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "src2", I960_OPERAND_SRC2, HW_H_GR, 13, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* dst: source/dest register */
-  { "dst", & HW_ENT (HW_H_GR), 8, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "dst", I960_OPERAND_DST, HW_H_GR, 8, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* lit1: literal 1 */
-  { "lit1", & HW_ENT (HW_H_UINT), 27, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "lit1", I960_OPERAND_LIT1, HW_H_UINT, 27, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* lit2: literal 2 */
-  { "lit2", & HW_ENT (HW_H_UINT), 13, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "lit2", I960_OPERAND_LIT2, HW_H_UINT, 13, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* st_src: store src */
-  { "st_src", & HW_ENT (HW_H_GR), 8, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "st_src", I960_OPERAND_ST_SRC, HW_H_GR, 8, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* abase: abase */
-  { "abase", & HW_ENT (HW_H_GR), 13, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "abase", I960_OPERAND_ABASE, HW_H_GR, 13, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* offset: offset */
-  { "offset", & HW_ENT (HW_H_UINT), 20, 12,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "offset", I960_OPERAND_OFFSET, HW_H_UINT, 20, 12,
+    { 0, { (1<<MACH_BASE) } }  },
 /* scale: scale */
-  { "scale", & HW_ENT (HW_H_UINT), 22, 3,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "scale", I960_OPERAND_SCALE, HW_H_UINT, 22, 3,
+    { 0, { (1<<MACH_BASE) } }  },
 /* index: index */
-  { "index", & HW_ENT (HW_H_GR), 27, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "index", I960_OPERAND_INDEX, HW_H_GR, 27, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* optdisp: optional displacement */
-  { "optdisp", & HW_ENT (HW_H_UINT), 0, 32,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "optdisp", I960_OPERAND_OPTDISP, HW_H_UINT, 0, 32,
+    { 0, { (1<<MACH_BASE) } }  },
 /* br_src1: branch src1 */
-  { "br_src1", & HW_ENT (HW_H_GR), 8, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "br_src1", I960_OPERAND_BR_SRC1, HW_H_GR, 8, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* br_src2: branch src2 */
-  { "br_src2", & HW_ENT (HW_H_GR), 13, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "br_src2", I960_OPERAND_BR_SRC2, HW_H_GR, 13, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* br_disp: branch displacement */
-  { "br_disp", & HW_ENT (HW_H_IADDR), 19, 11,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(PCREL_ADDR), { (1<<MACH_BASE) } }  },
+  { "br_disp", I960_OPERAND_BR_DISP, HW_H_IADDR, 19, 11,
+    { 0|A(PCREL_ADDR), { (1<<MACH_BASE) } }  },
 /* br_lit1: branch literal 1 */
-  { "br_lit1", & HW_ENT (HW_H_UINT), 8, 5,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(UNSIGNED), { (1<<MACH_BASE) } }  },
+  { "br_lit1", I960_OPERAND_BR_LIT1, HW_H_UINT, 8, 5,
+    { 0, { (1<<MACH_BASE) } }  },
 /* ctrl_disp: ctrl branch disp */
-  { "ctrl_disp", & HW_ENT (HW_H_IADDR), 8, 22,
-    { CGEN_OPERAND_NBOOL_ATTRS, 0|A(PCREL_ADDR), { (1<<MACH_BASE) } }  },
+  { "ctrl_disp", I960_OPERAND_CTRL_DISP, HW_H_IADDR, 8, 22,
+    { 0|A(PCREL_ADDR), { (1<<MACH_BASE) } }  },
+  { 0 }
 };
 
 #undef A
 
-#define A(a) (1 << (CONCAT2 (CGEN_INSN_,a) - CGEN_ATTR_BOOL_OFFSET))
+#define A(a) (1 << CONCAT2 (CGEN_INSN_,a))
 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
 
 /* The instruction table.  */
@@ -296,1417 +315,1457 @@ static const CGEN_IBASE i960_cgen_insn_table[MAX_INSNS] =
 /* mulo $src1, $src2, $dst */
   {
     I960_INSN_MULO, "mulo", "mulo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* mulo $lit1, $src2, $dst */
   {
     I960_INSN_MULO1, "mulo1", "mulo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* mulo $src1, $lit2, $dst */
   {
     I960_INSN_MULO2, "mulo2", "mulo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* mulo $lit1, $lit2, $dst */
   {
     I960_INSN_MULO3, "mulo3", "mulo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* remo $src1, $src2, $dst */
   {
     I960_INSN_REMO, "remo", "remo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* remo $lit1, $src2, $dst */
   {
     I960_INSN_REMO1, "remo1", "remo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* remo $src1, $lit2, $dst */
   {
     I960_INSN_REMO2, "remo2", "remo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* remo $lit1, $lit2, $dst */
   {
     I960_INSN_REMO3, "remo3", "remo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* divo $src1, $src2, $dst */
   {
     I960_INSN_DIVO, "divo", "divo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* divo $lit1, $src2, $dst */
   {
     I960_INSN_DIVO1, "divo1", "divo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* divo $src1, $lit2, $dst */
   {
     I960_INSN_DIVO2, "divo2", "divo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* divo $lit1, $lit2, $dst */
   {
     I960_INSN_DIVO3, "divo3", "divo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* remi $src1, $src2, $dst */
   {
     I960_INSN_REMI, "remi", "remi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* remi $lit1, $src2, $dst */
   {
     I960_INSN_REMI1, "remi1", "remi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* remi $src1, $lit2, $dst */
   {
     I960_INSN_REMI2, "remi2", "remi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* remi $lit1, $lit2, $dst */
   {
     I960_INSN_REMI3, "remi3", "remi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* divi $src1, $src2, $dst */
   {
     I960_INSN_DIVI, "divi", "divi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* divi $lit1, $src2, $dst */
   {
     I960_INSN_DIVI1, "divi1", "divi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* divi $src1, $lit2, $dst */
   {
     I960_INSN_DIVI2, "divi2", "divi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* divi $lit1, $lit2, $dst */
   {
     I960_INSN_DIVI3, "divi3", "divi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* addo $src1, $src2, $dst */
   {
     I960_INSN_ADDO, "addo", "addo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* addo $lit1, $src2, $dst */
   {
     I960_INSN_ADDO1, "addo1", "addo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* addo $src1, $lit2, $dst */
   {
     I960_INSN_ADDO2, "addo2", "addo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* addo $lit1, $lit2, $dst */
   {
     I960_INSN_ADDO3, "addo3", "addo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* subo $src1, $src2, $dst */
   {
     I960_INSN_SUBO, "subo", "subo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* subo $lit1, $src2, $dst */
   {
     I960_INSN_SUBO1, "subo1", "subo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* subo $src1, $lit2, $dst */
   {
     I960_INSN_SUBO2, "subo2", "subo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* subo $lit1, $lit2, $dst */
   {
     I960_INSN_SUBO3, "subo3", "subo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* notbit $src1, $src2, $dst */
   {
     I960_INSN_NOTBIT, "notbit", "notbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* notbit $lit1, $src2, $dst */
   {
     I960_INSN_NOTBIT1, "notbit1", "notbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* notbit $src1, $lit2, $dst */
   {
     I960_INSN_NOTBIT2, "notbit2", "notbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* notbit $lit1, $lit2, $dst */
   {
     I960_INSN_NOTBIT3, "notbit3", "notbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* and $src1, $src2, $dst */
   {
     I960_INSN_AND, "and", "and", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* and $lit1, $src2, $dst */
   {
     I960_INSN_AND1, "and1", "and", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* and $src1, $lit2, $dst */
   {
     I960_INSN_AND2, "and2", "and", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* and $lit1, $lit2, $dst */
   {
     I960_INSN_AND3, "and3", "and", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* andnot $src1, $src2, $dst */
   {
     I960_INSN_ANDNOT, "andnot", "andnot", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* andnot $lit1, $src2, $dst */
   {
     I960_INSN_ANDNOT1, "andnot1", "andnot", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* andnot $src1, $lit2, $dst */
   {
     I960_INSN_ANDNOT2, "andnot2", "andnot", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* andnot $lit1, $lit2, $dst */
   {
     I960_INSN_ANDNOT3, "andnot3", "andnot", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* setbit $src1, $src2, $dst */
   {
     I960_INSN_SETBIT, "setbit", "setbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* setbit $lit1, $src2, $dst */
   {
     I960_INSN_SETBIT1, "setbit1", "setbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* setbit $src1, $lit2, $dst */
   {
     I960_INSN_SETBIT2, "setbit2", "setbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* setbit $lit1, $lit2, $dst */
   {
     I960_INSN_SETBIT3, "setbit3", "setbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* notand $src1, $src2, $dst */
   {
     I960_INSN_NOTAND, "notand", "notand", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* notand $lit1, $src2, $dst */
   {
     I960_INSN_NOTAND1, "notand1", "notand", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* notand $src1, $lit2, $dst */
   {
     I960_INSN_NOTAND2, "notand2", "notand", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* notand $lit1, $lit2, $dst */
   {
     I960_INSN_NOTAND3, "notand3", "notand", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* xor $src1, $src2, $dst */
   {
     I960_INSN_XOR, "xor", "xor", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* xor $lit1, $src2, $dst */
   {
     I960_INSN_XOR1, "xor1", "xor", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* xor $src1, $lit2, $dst */
   {
     I960_INSN_XOR2, "xor2", "xor", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* xor $lit1, $lit2, $dst */
   {
     I960_INSN_XOR3, "xor3", "xor", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* or $src1, $src2, $dst */
   {
     I960_INSN_OR, "or", "or", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* or $lit1, $src2, $dst */
   {
     I960_INSN_OR1, "or1", "or", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* or $src1, $lit2, $dst */
   {
     I960_INSN_OR2, "or2", "or", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* or $lit1, $lit2, $dst */
   {
     I960_INSN_OR3, "or3", "or", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* nor $src1, $src2, $dst */
   {
     I960_INSN_NOR, "nor", "nor", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* nor $lit1, $src2, $dst */
   {
     I960_INSN_NOR1, "nor1", "nor", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* nor $src1, $lit2, $dst */
   {
     I960_INSN_NOR2, "nor2", "nor", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* nor $lit1, $lit2, $dst */
   {
     I960_INSN_NOR3, "nor3", "nor", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
+  },
+/* xnor $src1, $src2, $dst */
+  {
+    I960_INSN_XNOR, "xnor", "xnor", 32,
+    { 0, { (1<<MACH_BASE) } }
+  },
+/* xnor $lit1, $src2, $dst */
+  {
+    I960_INSN_XNOR1, "xnor1", "xnor", 32,
+    { 0, { (1<<MACH_BASE) } }
+  },
+/* xnor $src1, $lit2, $dst */
+  {
+    I960_INSN_XNOR2, "xnor2", "xnor", 32,
+    { 0, { (1<<MACH_BASE) } }
+  },
+/* xnor $lit1, $lit2, $dst */
+  {
+    I960_INSN_XNOR3, "xnor3", "xnor", 32,
+    { 0, { (1<<MACH_BASE) } }
   },
 /* not $src1, $src2, $dst */
   {
     I960_INSN_NOT, "not", "not", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* not $lit1, $src2, $dst */
   {
     I960_INSN_NOT1, "not1", "not", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* not $src1, $lit2, $dst */
   {
     I960_INSN_NOT2, "not2", "not", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* not $lit1, $lit2, $dst */
   {
     I960_INSN_NOT3, "not3", "not", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
+  },
+/* ornot $src1, $src2, $dst */
+  {
+    I960_INSN_ORNOT, "ornot", "ornot", 32,
+    { 0, { (1<<MACH_BASE) } }
+  },
+/* ornot $lit1, $src2, $dst */
+  {
+    I960_INSN_ORNOT1, "ornot1", "ornot", 32,
+    { 0, { (1<<MACH_BASE) } }
+  },
+/* ornot $src1, $lit2, $dst */
+  {
+    I960_INSN_ORNOT2, "ornot2", "ornot", 32,
+    { 0, { (1<<MACH_BASE) } }
+  },
+/* ornot $lit1, $lit2, $dst */
+  {
+    I960_INSN_ORNOT3, "ornot3", "ornot", 32,
+    { 0, { (1<<MACH_BASE) } }
   },
 /* clrbit $src1, $src2, $dst */
   {
     I960_INSN_CLRBIT, "clrbit", "clrbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* clrbit $lit1, $src2, $dst */
   {
     I960_INSN_CLRBIT1, "clrbit1", "clrbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* clrbit $src1, $lit2, $dst */
   {
     I960_INSN_CLRBIT2, "clrbit2", "clrbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* clrbit $lit1, $lit2, $dst */
   {
     I960_INSN_CLRBIT3, "clrbit3", "clrbit", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shlo $src1, $src2, $dst */
   {
     I960_INSN_SHLO, "shlo", "shlo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shlo $lit1, $src2, $dst */
   {
     I960_INSN_SHLO1, "shlo1", "shlo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shlo $src1, $lit2, $dst */
   {
     I960_INSN_SHLO2, "shlo2", "shlo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shlo $lit1, $lit2, $dst */
   {
     I960_INSN_SHLO3, "shlo3", "shlo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shro $src1, $src2, $dst */
   {
     I960_INSN_SHRO, "shro", "shro", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shro $lit1, $src2, $dst */
   {
     I960_INSN_SHRO1, "shro1", "shro", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shro $src1, $lit2, $dst */
   {
     I960_INSN_SHRO2, "shro2", "shro", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shro $lit1, $lit2, $dst */
   {
     I960_INSN_SHRO3, "shro3", "shro", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shli $src1, $src2, $dst */
   {
     I960_INSN_SHLI, "shli", "shli", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shli $lit1, $src2, $dst */
   {
     I960_INSN_SHLI1, "shli1", "shli", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shli $src1, $lit2, $dst */
   {
     I960_INSN_SHLI2, "shli2", "shli", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shli $lit1, $lit2, $dst */
   {
     I960_INSN_SHLI3, "shli3", "shli", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shri $src1, $src2, $dst */
   {
     I960_INSN_SHRI, "shri", "shri", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shri $lit1, $src2, $dst */
   {
     I960_INSN_SHRI1, "shri1", "shri", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shri $src1, $lit2, $dst */
   {
     I960_INSN_SHRI2, "shri2", "shri", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* shri $lit1, $lit2, $dst */
   {
     I960_INSN_SHRI3, "shri3", "shri", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* emul $src1, $src2, $dst */
   {
     I960_INSN_EMUL, "emul", "emul", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* emul $lit1, $src2, $dst */
   {
     I960_INSN_EMUL1, "emul1", "emul", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* emul $src1, $lit2, $dst */
   {
     I960_INSN_EMUL2, "emul2", "emul", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* emul $lit1, $lit2, $dst */
   {
     I960_INSN_EMUL3, "emul3", "emul", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* mov $src1, $dst */
   {
     I960_INSN_MOV, "mov", "mov", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* mov $lit1, $dst */
   {
     I960_INSN_MOV1, "mov1", "mov", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* movl $src1, $dst */
   {
     I960_INSN_MOVL, "movl", "movl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* movl $lit1, $dst */
   {
     I960_INSN_MOVL1, "movl1", "movl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* movt $src1, $dst */
   {
     I960_INSN_MOVT, "movt", "movt", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* movt $lit1, $dst */
   {
     I960_INSN_MOVT1, "movt1", "movt", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* movq $src1, $dst */
   {
     I960_INSN_MOVQ, "movq", "movq", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* movq $lit1, $dst */
   {
     I960_INSN_MOVQ1, "movq1", "movq", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* modpc $src1, $src2, $dst */
   {
     I960_INSN_MODPC, "modpc", "modpc", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* modac $src1, $src2, $dst */
   {
     I960_INSN_MODAC, "modac", "modac", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* lda $offset, $dst */
   {
     I960_INSN_LDA_OFFSET, "lda-offset", "lda", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* lda $offset($abase), $dst */
   {
     I960_INSN_LDA_INDIRECT_OFFSET, "lda-indirect-offset", "lda", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* lda ($abase), $dst */
   {
     I960_INSN_LDA_INDIRECT, "lda-indirect", "lda", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* lda ($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDA_INDIRECT_INDEX, "lda-indirect-index", "lda", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* lda $optdisp, $dst */
   {
     I960_INSN_LDA_DISP, "lda-disp", "lda", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* lda $optdisp($abase), $dst */
   {
     I960_INSN_LDA_INDIRECT_DISP, "lda-indirect-disp", "lda", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* lda $optdisp[$index*S$scale], $dst */
   {
     I960_INSN_LDA_INDEX_DISP, "lda-index-disp", "lda", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* lda $optdisp($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDA_INDIRECT_INDEX_DISP, "lda-indirect-index-disp", "lda", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ld $offset, $dst */
   {
     I960_INSN_LD_OFFSET, "ld-offset", "ld", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ld $offset($abase), $dst */
   {
     I960_INSN_LD_INDIRECT_OFFSET, "ld-indirect-offset", "ld", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ld ($abase), $dst */
   {
     I960_INSN_LD_INDIRECT, "ld-indirect", "ld", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ld ($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LD_INDIRECT_INDEX, "ld-indirect-index", "ld", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ld $optdisp, $dst */
   {
     I960_INSN_LD_DISP, "ld-disp", "ld", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ld $optdisp($abase), $dst */
   {
     I960_INSN_LD_INDIRECT_DISP, "ld-indirect-disp", "ld", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ld $optdisp[$index*S$scale], $dst */
   {
     I960_INSN_LD_INDEX_DISP, "ld-index-disp", "ld", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ld $optdisp($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LD_INDIRECT_INDEX_DISP, "ld-indirect-index-disp", "ld", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldob $offset, $dst */
   {
     I960_INSN_LDOB_OFFSET, "ldob-offset", "ldob", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldob $offset($abase), $dst */
   {
     I960_INSN_LDOB_INDIRECT_OFFSET, "ldob-indirect-offset", "ldob", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldob ($abase), $dst */
   {
     I960_INSN_LDOB_INDIRECT, "ldob-indirect", "ldob", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldob ($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDOB_INDIRECT_INDEX, "ldob-indirect-index", "ldob", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldob $optdisp, $dst */
   {
     I960_INSN_LDOB_DISP, "ldob-disp", "ldob", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldob $optdisp($abase), $dst */
   {
     I960_INSN_LDOB_INDIRECT_DISP, "ldob-indirect-disp", "ldob", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldob $optdisp[$index*S$scale], $dst */
   {
     I960_INSN_LDOB_INDEX_DISP, "ldob-index-disp", "ldob", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldob $optdisp($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDOB_INDIRECT_INDEX_DISP, "ldob-indirect-index-disp", "ldob", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldos $offset, $dst */
   {
     I960_INSN_LDOS_OFFSET, "ldos-offset", "ldos", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldos $offset($abase), $dst */
   {
     I960_INSN_LDOS_INDIRECT_OFFSET, "ldos-indirect-offset", "ldos", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldos ($abase), $dst */
   {
     I960_INSN_LDOS_INDIRECT, "ldos-indirect", "ldos", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldos ($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDOS_INDIRECT_INDEX, "ldos-indirect-index", "ldos", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldos $optdisp, $dst */
   {
     I960_INSN_LDOS_DISP, "ldos-disp", "ldos", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldos $optdisp($abase), $dst */
   {
     I960_INSN_LDOS_INDIRECT_DISP, "ldos-indirect-disp", "ldos", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldos $optdisp[$index*S$scale], $dst */
   {
     I960_INSN_LDOS_INDEX_DISP, "ldos-index-disp", "ldos", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldos $optdisp($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDOS_INDIRECT_INDEX_DISP, "ldos-indirect-index-disp", "ldos", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldib $offset, $dst */
   {
     I960_INSN_LDIB_OFFSET, "ldib-offset", "ldib", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldib $offset($abase), $dst */
   {
     I960_INSN_LDIB_INDIRECT_OFFSET, "ldib-indirect-offset", "ldib", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldib ($abase), $dst */
   {
     I960_INSN_LDIB_INDIRECT, "ldib-indirect", "ldib", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldib ($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDIB_INDIRECT_INDEX, "ldib-indirect-index", "ldib", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldib $optdisp, $dst */
   {
     I960_INSN_LDIB_DISP, "ldib-disp", "ldib", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldib $optdisp($abase), $dst */
   {
     I960_INSN_LDIB_INDIRECT_DISP, "ldib-indirect-disp", "ldib", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldib $optdisp[$index*S$scale], $dst */
   {
     I960_INSN_LDIB_INDEX_DISP, "ldib-index-disp", "ldib", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldib $optdisp($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDIB_INDIRECT_INDEX_DISP, "ldib-indirect-index-disp", "ldib", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldis $offset, $dst */
   {
     I960_INSN_LDIS_OFFSET, "ldis-offset", "ldis", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldis $offset($abase), $dst */
   {
     I960_INSN_LDIS_INDIRECT_OFFSET, "ldis-indirect-offset", "ldis", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldis ($abase), $dst */
   {
     I960_INSN_LDIS_INDIRECT, "ldis-indirect", "ldis", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldis ($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDIS_INDIRECT_INDEX, "ldis-indirect-index", "ldis", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldis $optdisp, $dst */
   {
     I960_INSN_LDIS_DISP, "ldis-disp", "ldis", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldis $optdisp($abase), $dst */
   {
     I960_INSN_LDIS_INDIRECT_DISP, "ldis-indirect-disp", "ldis", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldis $optdisp[$index*S$scale], $dst */
   {
     I960_INSN_LDIS_INDEX_DISP, "ldis-index-disp", "ldis", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldis $optdisp($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDIS_INDIRECT_INDEX_DISP, "ldis-indirect-index-disp", "ldis", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldl $offset, $dst */
   {
     I960_INSN_LDL_OFFSET, "ldl-offset", "ldl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldl $offset($abase), $dst */
   {
     I960_INSN_LDL_INDIRECT_OFFSET, "ldl-indirect-offset", "ldl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldl ($abase), $dst */
   {
     I960_INSN_LDL_INDIRECT, "ldl-indirect", "ldl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldl ($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDL_INDIRECT_INDEX, "ldl-indirect-index", "ldl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldl $optdisp, $dst */
   {
     I960_INSN_LDL_DISP, "ldl-disp", "ldl", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldl $optdisp($abase), $dst */
   {
     I960_INSN_LDL_INDIRECT_DISP, "ldl-indirect-disp", "ldl", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldl $optdisp[$index*S$scale], $dst */
   {
     I960_INSN_LDL_INDEX_DISP, "ldl-index-disp", "ldl", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldl $optdisp($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDL_INDIRECT_INDEX_DISP, "ldl-indirect-index-disp", "ldl", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldt $offset, $dst */
   {
     I960_INSN_LDT_OFFSET, "ldt-offset", "ldt", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldt $offset($abase), $dst */
   {
     I960_INSN_LDT_INDIRECT_OFFSET, "ldt-indirect-offset", "ldt", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldt ($abase), $dst */
   {
     I960_INSN_LDT_INDIRECT, "ldt-indirect", "ldt", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldt ($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDT_INDIRECT_INDEX, "ldt-indirect-index", "ldt", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldt $optdisp, $dst */
   {
     I960_INSN_LDT_DISP, "ldt-disp", "ldt", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldt $optdisp($abase), $dst */
   {
     I960_INSN_LDT_INDIRECT_DISP, "ldt-indirect-disp", "ldt", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldt $optdisp[$index*S$scale], $dst */
   {
     I960_INSN_LDT_INDEX_DISP, "ldt-index-disp", "ldt", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldt $optdisp($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDT_INDIRECT_INDEX_DISP, "ldt-indirect-index-disp", "ldt", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldq $offset, $dst */
   {
     I960_INSN_LDQ_OFFSET, "ldq-offset", "ldq", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldq $offset($abase), $dst */
   {
     I960_INSN_LDQ_INDIRECT_OFFSET, "ldq-indirect-offset", "ldq", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldq ($abase), $dst */
   {
     I960_INSN_LDQ_INDIRECT, "ldq-indirect", "ldq", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldq ($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDQ_INDIRECT_INDEX, "ldq-indirect-index", "ldq", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldq $optdisp, $dst */
   {
     I960_INSN_LDQ_DISP, "ldq-disp", "ldq", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldq $optdisp($abase), $dst */
   {
     I960_INSN_LDQ_INDIRECT_DISP, "ldq-indirect-disp", "ldq", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldq $optdisp[$index*S$scale], $dst */
   {
     I960_INSN_LDQ_INDEX_DISP, "ldq-index-disp", "ldq", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* ldq $optdisp($abase)[$index*S$scale], $dst */
   {
     I960_INSN_LDQ_INDIRECT_INDEX_DISP, "ldq-indirect-index-disp", "ldq", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* st $st_src, $offset */
   {
     I960_INSN_ST_OFFSET, "st-offset", "st", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* st $st_src, $offset($abase) */
   {
     I960_INSN_ST_INDIRECT_OFFSET, "st-indirect-offset", "st", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* st $st_src, ($abase) */
   {
     I960_INSN_ST_INDIRECT, "st-indirect", "st", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* st $st_src, ($abase)[$index*S$scale] */
   {
     I960_INSN_ST_INDIRECT_INDEX, "st-indirect-index", "st", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* st $st_src, $optdisp */
   {
     I960_INSN_ST_DISP, "st-disp", "st", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* st $st_src, $optdisp($abase) */
   {
     I960_INSN_ST_INDIRECT_DISP, "st-indirect-disp", "st", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* st $st_src, $optdisp[$index*S$scale */
   {
     I960_INSN_ST_INDEX_DISP, "st-index-disp", "st", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* st $st_src, $optdisp($abase)[$index*S$scale] */
   {
     I960_INSN_ST_INDIRECT_INDEX_DISP, "st-indirect-index-disp", "st", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stob $st_src, $offset */
   {
     I960_INSN_STOB_OFFSET, "stob-offset", "stob", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stob $st_src, $offset($abase) */
   {
     I960_INSN_STOB_INDIRECT_OFFSET, "stob-indirect-offset", "stob", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stob $st_src, ($abase) */
   {
     I960_INSN_STOB_INDIRECT, "stob-indirect", "stob", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stob $st_src, ($abase)[$index*S$scale] */
   {
     I960_INSN_STOB_INDIRECT_INDEX, "stob-indirect-index", "stob", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stob $st_src, $optdisp */
   {
     I960_INSN_STOB_DISP, "stob-disp", "stob", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stob $st_src, $optdisp($abase) */
   {
     I960_INSN_STOB_INDIRECT_DISP, "stob-indirect-disp", "stob", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stob $st_src, $optdisp[$index*S$scale */
   {
     I960_INSN_STOB_INDEX_DISP, "stob-index-disp", "stob", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stob $st_src, $optdisp($abase)[$index*S$scale] */
   {
     I960_INSN_STOB_INDIRECT_INDEX_DISP, "stob-indirect-index-disp", "stob", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stos $st_src, $offset */
   {
     I960_INSN_STOS_OFFSET, "stos-offset", "stos", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stos $st_src, $offset($abase) */
   {
     I960_INSN_STOS_INDIRECT_OFFSET, "stos-indirect-offset", "stos", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stos $st_src, ($abase) */
   {
     I960_INSN_STOS_INDIRECT, "stos-indirect", "stos", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stos $st_src, ($abase)[$index*S$scale] */
   {
     I960_INSN_STOS_INDIRECT_INDEX, "stos-indirect-index", "stos", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stos $st_src, $optdisp */
   {
     I960_INSN_STOS_DISP, "stos-disp", "stos", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stos $st_src, $optdisp($abase) */
   {
     I960_INSN_STOS_INDIRECT_DISP, "stos-indirect-disp", "stos", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stos $st_src, $optdisp[$index*S$scale */
   {
     I960_INSN_STOS_INDEX_DISP, "stos-index-disp", "stos", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stos $st_src, $optdisp($abase)[$index*S$scale] */
   {
     I960_INSN_STOS_INDIRECT_INDEX_DISP, "stos-indirect-index-disp", "stos", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stl $st_src, $offset */
   {
     I960_INSN_STL_OFFSET, "stl-offset", "stl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stl $st_src, $offset($abase) */
   {
     I960_INSN_STL_INDIRECT_OFFSET, "stl-indirect-offset", "stl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stl $st_src, ($abase) */
   {
     I960_INSN_STL_INDIRECT, "stl-indirect", "stl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stl $st_src, ($abase)[$index*S$scale] */
   {
     I960_INSN_STL_INDIRECT_INDEX, "stl-indirect-index", "stl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stl $st_src, $optdisp */
   {
     I960_INSN_STL_DISP, "stl-disp", "stl", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stl $st_src, $optdisp($abase) */
   {
     I960_INSN_STL_INDIRECT_DISP, "stl-indirect-disp", "stl", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stl $st_src, $optdisp[$index*S$scale */
   {
     I960_INSN_STL_INDEX_DISP, "stl-index-disp", "stl", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stl $st_src, $optdisp($abase)[$index*S$scale] */
   {
     I960_INSN_STL_INDIRECT_INDEX_DISP, "stl-indirect-index-disp", "stl", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stt $st_src, $offset */
   {
     I960_INSN_STT_OFFSET, "stt-offset", "stt", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stt $st_src, $offset($abase) */
   {
     I960_INSN_STT_INDIRECT_OFFSET, "stt-indirect-offset", "stt", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stt $st_src, ($abase) */
   {
     I960_INSN_STT_INDIRECT, "stt-indirect", "stt", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stt $st_src, ($abase)[$index*S$scale] */
   {
     I960_INSN_STT_INDIRECT_INDEX, "stt-indirect-index", "stt", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stt $st_src, $optdisp */
   {
     I960_INSN_STT_DISP, "stt-disp", "stt", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stt $st_src, $optdisp($abase) */
   {
     I960_INSN_STT_INDIRECT_DISP, "stt-indirect-disp", "stt", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stt $st_src, $optdisp[$index*S$scale */
   {
     I960_INSN_STT_INDEX_DISP, "stt-index-disp", "stt", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stt $st_src, $optdisp($abase)[$index*S$scale] */
   {
     I960_INSN_STT_INDIRECT_INDEX_DISP, "stt-indirect-index-disp", "stt", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stq $st_src, $offset */
   {
     I960_INSN_STQ_OFFSET, "stq-offset", "stq", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stq $st_src, $offset($abase) */
   {
     I960_INSN_STQ_INDIRECT_OFFSET, "stq-indirect-offset", "stq", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stq $st_src, ($abase) */
   {
     I960_INSN_STQ_INDIRECT, "stq-indirect", "stq", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stq $st_src, ($abase)[$index*S$scale] */
   {
     I960_INSN_STQ_INDIRECT_INDEX, "stq-indirect-index", "stq", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stq $st_src, $optdisp */
   {
     I960_INSN_STQ_DISP, "stq-disp", "stq", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stq $st_src, $optdisp($abase) */
   {
     I960_INSN_STQ_INDIRECT_DISP, "stq-indirect-disp", "stq", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stq $st_src, $optdisp[$index*S$scale */
   {
     I960_INSN_STQ_INDEX_DISP, "stq-index-disp", "stq", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* stq $st_src, $optdisp($abase)[$index*S$scale] */
   {
     I960_INSN_STQ_INDIRECT_INDEX_DISP, "stq-indirect-index-disp", "stq", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* cmpobe $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBE_REG, "cmpobe-reg", "cmpobe", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpobe $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBE_LIT, "cmpobe-lit", "cmpobe", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpobne $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBNE_REG, "cmpobne-reg", "cmpobne", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpobne $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBNE_LIT, "cmpobne-lit", "cmpobne", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpobl $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBL_REG, "cmpobl-reg", "cmpobl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpobl $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBL_LIT, "cmpobl-lit", "cmpobl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpoble $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBLE_REG, "cmpoble-reg", "cmpoble", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpoble $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBLE_LIT, "cmpoble-lit", "cmpoble", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpobg $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBG_REG, "cmpobg-reg", "cmpobg", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpobg $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBG_LIT, "cmpobg-lit", "cmpobg", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpobge $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBGE_REG, "cmpobge-reg", "cmpobge", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpobge $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPOBGE_LIT, "cmpobge-lit", "cmpobge", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpibe $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBE_REG, "cmpibe-reg", "cmpibe", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpibe $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBE_LIT, "cmpibe-lit", "cmpibe", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpibne $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBNE_REG, "cmpibne-reg", "cmpibne", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpibne $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBNE_LIT, "cmpibne-lit", "cmpibne", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpibl $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBL_REG, "cmpibl-reg", "cmpibl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpibl $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBL_LIT, "cmpibl-lit", "cmpibl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpible $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBLE_REG, "cmpible-reg", "cmpible", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpible $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBLE_LIT, "cmpible-lit", "cmpible", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpibg $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBG_REG, "cmpibg-reg", "cmpibg", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpibg $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBG_LIT, "cmpibg-lit", "cmpibg", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpibge $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBGE_REG, "cmpibge-reg", "cmpibge", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpibge $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_CMPIBGE_LIT, "cmpibge-lit", "cmpibge", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* bbc $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_BBC_REG, "bbc-reg", "bbc", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* bbc $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_BBC_LIT, "bbc-lit", "bbc", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* bbs $br_src1, $br_src2, $br_disp */
   {
     I960_INSN_BBS_REG, "bbs-reg", "bbs", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* bbs $br_lit1, $br_src2, $br_disp */
   {
     I960_INSN_BBS_LIT, "bbs-lit", "bbs", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* cmpi $src1, $src2 */
   {
     I960_INSN_CMPI, "cmpi", "cmpi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* cmpi $lit1, $src2 */
   {
     I960_INSN_CMPI1, "cmpi1", "cmpi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* cmpi $src1, $lit2 */
   {
     I960_INSN_CMPI2, "cmpi2", "cmpi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* cmpi $lit1, $lit2 */
   {
     I960_INSN_CMPI3, "cmpi3", "cmpi", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* cmpo $src1, $src2 */
   {
     I960_INSN_CMPO, "cmpo", "cmpo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* cmpo $lit1, $src2 */
   {
     I960_INSN_CMPO1, "cmpo1", "cmpo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* cmpo $src1, $lit2 */
   {
     I960_INSN_CMPO2, "cmpo2", "cmpo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* cmpo $lit1, $lit2 */
   {
     I960_INSN_CMPO3, "cmpo3", "cmpo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* testno $br_src1 */
   {
     I960_INSN_TESTNO_REG, "testno-reg", "testno", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* testg $br_src1 */
   {
     I960_INSN_TESTG_REG, "testg-reg", "testg", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* teste $br_src1 */
   {
     I960_INSN_TESTE_REG, "teste-reg", "teste", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* testge $br_src1 */
   {
     I960_INSN_TESTGE_REG, "testge-reg", "testge", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* testl $br_src1 */
   {
     I960_INSN_TESTL_REG, "testl-reg", "testl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* testne $br_src1 */
   {
     I960_INSN_TESTNE_REG, "testne-reg", "testne", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* testle $br_src1 */
   {
     I960_INSN_TESTLE_REG, "testle-reg", "testle", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* testo $br_src1 */
   {
     I960_INSN_TESTO_REG, "testo-reg", "testo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 /* bno $ctrl_disp */
   {
     I960_INSN_BNO, "bno", "bno", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* bg $ctrl_disp */
   {
     I960_INSN_BG, "bg", "bg", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* be $ctrl_disp */
   {
     I960_INSN_BE, "be", "be", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* bge $ctrl_disp */
   {
     I960_INSN_BGE, "bge", "bge", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* bl $ctrl_disp */
   {
     I960_INSN_BL, "bl", "bl", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* bne $ctrl_disp */
   {
     I960_INSN_BNE, "bne", "bne", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* ble $ctrl_disp */
   {
     I960_INSN_BLE, "ble", "ble", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* bo $ctrl_disp */
   {
     I960_INSN_BO, "bo", "bo", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(COND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(COND_CTI), { (1<<MACH_BASE) } }
   },
 /* b $ctrl_disp */
   {
     I960_INSN_B, "b", "b", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* bx $offset($abase) */
   {
     I960_INSN_BX_INDIRECT_OFFSET, "bx-indirect-offset", "bx", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* bx ($abase) */
   {
     I960_INSN_BX_INDIRECT, "bx-indirect", "bx", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* bx ($abase)[$index*S$scale] */
   {
     I960_INSN_BX_INDIRECT_INDEX, "bx-indirect-index", "bx", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* bx $optdisp */
   {
     I960_INSN_BX_DISP, "bx-disp", "bx", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* bx $optdisp($abase) */
   {
     I960_INSN_BX_INDIRECT_DISP, "bx-indirect-disp", "bx", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* callx $optdisp */
   {
     I960_INSN_CALLX_DISP, "callx-disp", "callx", 64,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* callx ($abase) */
   {
     I960_INSN_CALLX_INDIRECT, "callx-indirect", "callx", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* callx $offset($abase) */
   {
     I960_INSN_CALLX_INDIRECT_OFFSET, "callx-indirect-offset", "callx", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* ret */
   {
     I960_INSN_RET, "ret", "ret", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* calls $src1 */
   {
     I960_INSN_CALLS, "calls", "calls", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* fmark */
   {
     I960_INSN_FMARK, "fmark", "fmark", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
+    { 0|A(UNCOND_CTI), { (1<<MACH_BASE) } }
   },
 /* flushreg */
   {
     I960_INSN_FLUSHREG, "flushreg", "flushreg", 32,
-    { CGEN_INSN_NBOOL_ATTRS, 0, { (1<<MACH_BASE) } }
+    { 0, { (1<<MACH_BASE) } }
   },
 };
 
@@ -1714,21 +1773,217 @@ static const CGEN_IBASE i960_cgen_insn_table[MAX_INSNS] =
 #undef MNEM
 #undef OP
 
+/* Initialize anything needed to be done once, before any cpu_open call.  */
+
 static void
 init_tables ()
 {
 }
 
+/* Subroutine of i960_cgen_cpu_open to look up a mach via its bfd name.  */
+
+static const CGEN_MACH *
+lookup_mach_via_bfd_name (table, name)
+     const CGEN_MACH *table;
+     const char *name;
+{
+  while (table->name)
+    {
+      if (strcmp (name, table->bfd_name) == 0)
+       return table;
+      ++table;
+    }
+  abort ();
+}
+
+/* Subroutine of i960_cgen_cpu_open to build the hardware table.  */
+
+static void
+build_hw_table (cd)
+     CGEN_CPU_TABLE *cd;
+{
+  int i;
+  int machs = cd->machs;
+  const CGEN_HW_ENTRY *init = & i960_cgen_hw_table[0];
+  /* MAX_HW is only an upper bound on the number of selected entries.
+     However each entry is indexed by it's enum so there can be holes in
+     the table.  */
+  const CGEN_HW_ENTRY **selected =
+    (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
+
+  cd->hw_table.init_entries = init;
+  cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
+  memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
+  /* ??? For now we just use machs to determine which ones we want.  */
+  for (i = 0; init[i].name != NULL; ++i)
+    if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
+       & machs)
+      selected[init[i].type] = &init[i];
+  cd->hw_table.entries = selected;
+  cd->hw_table.num_entries = MAX_HW;
+}
+
+/* Subroutine of i960_cgen_cpu_open to build the hardware table.  */
+
+static void
+build_ifield_table (cd)
+     CGEN_CPU_TABLE *cd;
+{
+  cd->ifld_table = & i960_cgen_ifld_table[0];
+}
+
+/* Subroutine of i960_cgen_cpu_open to build the hardware table.  */
+
+static void
+build_operand_table (cd)
+     CGEN_CPU_TABLE *cd;
+{
+  int i;
+  int machs = cd->machs;
+  const CGEN_OPERAND *init = & i960_cgen_operand_table[0];
+  /* MAX_OPERANDS is only an upper bound on the number of selected entries.
+     However each entry is indexed by it's enum so there can be holes in
+     the table.  */
+  const CGEN_OPERAND **selected =
+    (const CGEN_OPERAND **) xmalloc (MAX_OPERANDS * sizeof (CGEN_OPERAND *));
+
+  cd->operand_table.init_entries = init;
+  cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
+  memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
+  /* ??? For now we just use mach to determine which ones we want.  */
+  for (i = 0; init[i].name != NULL; ++i)
+    if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
+       & machs)
+      selected[init[i].type] = &init[i];
+  cd->operand_table.entries = selected;
+  cd->operand_table.num_entries = MAX_OPERANDS;
+}
+
+/* Subroutine of i960_cgen_cpu_open to build the hardware table.
+   ??? This could leave out insns not supported by the specified mach/isa,
+   but that would cause errors like "foo only supported by bar" to become
+   "unknown insn", so for now we include all insns and require the app to
+   do the checking later.
+   ??? On the other hand, parsing of such insns may require their hardware or
+   operand elements to be in the table [which they mightn't be].  */
+
+static void
+build_insn_table (cd)
+     CGEN_CPU_TABLE *cd;
+{
+  int i;
+  const CGEN_IBASE *ib = & i960_cgen_insn_table[0];
+  CGEN_INSN *insns = (CGEN_INSN *) xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
+
+  memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
+  for (i = 0; i < MAX_INSNS; ++i)
+    insns[i].base = &ib[i];
+  cd->insn_table.init_entries = insns;
+  cd->insn_table.entry_size = sizeof (CGEN_IBASE);
+  cd->insn_table.num_init_entries = MAX_INSNS;
+}
+
+/* Subroutine of i960_cgen_cpu_open to rebuild the tables.
+   This is also called by cgen_set_cpu (via an entry in CD).  */
+
+static void
+i960_cgen_rebuild_tables (cd)
+     CGEN_CPU_TABLE *cd;
+{
+  int i,n_isas,n_machs;
+  unsigned int isas = cd->isas;
+  unsigned int machs = cd->machs;
+
+  cd->int_insn_p = CGEN_INT_INSN_P;
+
+  /* Data derived from the isa spec.  */
+#define UNSET (CGEN_SIZE_UNKNOWN + 1)
+  cd->default_insn_bitsize = UNSET;
+  cd->base_insn_bitsize = UNSET;
+  cd->min_insn_bitsize = 65535; /* some ridiculously big number */
+  cd->max_insn_bitsize = 0;
+  for (i = 0; i < MAX_ISAS; ++i)
+    if (((1 << i) & isas) != 0)
+      {
+       const CGEN_ISA *isa = & i960_cgen_isa_table[i];
+
+       /* Default insn sizes of all selected isas must be equal or we set
+          the result to 0, meaning "unknown".  */
+       if (cd->default_insn_bitsize == UNSET)
+         cd->default_insn_bitsize = isa->default_insn_bitsize;
+       else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
+         ; /* this is ok */
+       else
+         cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
+
+       /* Base insn sizes of all selected isas must be equal or we set
+          the result to 0, meaning "unknown".  */
+       if (cd->base_insn_bitsize == UNSET)
+         cd->base_insn_bitsize = isa->base_insn_bitsize;
+       else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
+         ; /* this is ok */
+       else
+         cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
+
+       /* Set min,max insn sizes.  */
+       if (isa->min_insn_bitsize < cd->min_insn_bitsize)
+         cd->min_insn_bitsize = isa->min_insn_bitsize;
+       if (isa->max_insn_bitsize > cd->max_insn_bitsize)
+         cd->max_insn_bitsize = isa->max_insn_bitsize;
+
+       ++n_isas;
+      }
+
+  /* Data derived from the mach spec.  */
+  for (i = 0; i < MAX_MACHS; ++i)
+    if (((1 << i) & machs) != 0)
+      {
+       const CGEN_MACH *mach = & i960_cgen_mach_table[i];
+
+       ++n_machs;
+      }
+
+  /* Determine which hw elements are used by MACH.  */
+  build_hw_table (cd);
+
+  /* Build the ifield table.  */
+  build_ifield_table (cd);
+
+  /* Determine which operands are used by MACH/ISA.  */
+  build_operand_table (cd);
+
+  /* Build the instruction table.  */
+  build_insn_table (cd);
+}
+
 /* Initialize a cpu table and return a descriptor.
-   It's much like opening a file, and must be the first function called.  */
+   It's much like opening a file, and must be the first function called.
+   The arguments are a set of (type/value) pairs, terminated with
+   CGEN_CPU_OPEN_END.
+
+   Currently supported values:
+   CGEN_CPU_OPEN_ISAS:    bitmap of values in enum isa_attr
+   CGEN_CPU_OPEN_MACHS:   bitmap of values in enum mach_attr
+   CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
+   CGEN_CPU_OPEN_ENDIAN:  specify endian choice
+   CGEN_CPU_OPEN_END:     terminates arguments
+
+   ??? Simultaneous multiple isas might not make sense, but it's not (yet)
+   precluded.
+
+   ??? We only support ISO C stdargs here, not K&R.
+   Laziness, plus experiment to see if anything requires K&R - eventually
+   K&R will no longer be supported - e.g. GDB is currently trying this.  */
 
 CGEN_CPU_DESC
-i960_cgen_cpu_open (mach, endian)
-     int mach;
-     enum cgen_endian endian;
+i960_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
 {
   CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
   static int init_p;
+  unsigned int isas = 0;  /* 0 = "unspecified" */
+  unsigned int machs = 0; /* 0 = "unspecified" */
+  enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
+  va_list ap;
 
   if (! init_p)
     {
@@ -1738,7 +1993,55 @@ i960_cgen_cpu_open (mach, endian)
 
   memset (cd, 0, sizeof (*cd));
 
-  cd->mach = mach;
+  va_start (ap, arg_type);
+  while (arg_type != CGEN_CPU_OPEN_END)
+    {
+      switch (arg_type)
+       {
+       case CGEN_CPU_OPEN_ISAS :
+         isas = va_arg (ap, unsigned int);
+         break;
+       case CGEN_CPU_OPEN_MACHS :
+         machs = va_arg (ap, unsigned int);
+         break;
+       case CGEN_CPU_OPEN_BFDMACH :
+         {
+           const char *name = va_arg (ap, const char *);
+           const CGEN_MACH *mach =
+             lookup_mach_via_bfd_name (i960_cgen_mach_table, name);
+
+           machs |= mach->num << 1;
+           break;
+         }
+       case CGEN_CPU_OPEN_ENDIAN :
+         endian = va_arg (ap, enum cgen_endian);
+         break;
+       default :
+         fprintf (stderr, "i960_cgen_cpu_open: unsupported argument `%d'\n",
+                  arg_type);
+         abort (); /* ??? return NULL? */
+       }
+      arg_type = va_arg (ap, enum cgen_cpu_open_arg);
+    }
+  va_end (ap);
+
+  /* mach unspecified means "all" */
+  if (machs == 0)
+    machs = (1 << MAX_MACHS) - 1;
+  /* base mach is always selected */
+  machs |= 1;
+  /* isa unspecified means "all" */
+  if (isas == 0)
+    isas = (1 << MAX_ISAS) - 1;
+  if (endian == CGEN_ENDIAN_UNKNOWN)
+    {
+      /* ??? If target has only one, could have a default.  */
+      fprintf (stderr, "i960_cgen_cpu_open: no endianness specified\n");
+      abort ();
+    }
+
+  cd->isas = isas;
+  cd->machs = machs;
   cd->endian = endian;
   /* FIXME: for the sparc case we can determine insn-endianness statically.
      The worry here is where both data and insn endian can be independently
@@ -1746,32 +2049,30 @@ i960_cgen_cpu_open (mach, endian)
      Actually, will want to allow for more arguments in the future anyway.  */
   cd->insn_endian = endian;
 
-  cd->int_insn_p = CGEN_INT_INSN_P;
+  /* Table (re)builder.  */
+  cd->rebuild_tables = i960_cgen_rebuild_tables;
+  i960_cgen_rebuild_tables (cd);
 
-  cd->max_insn_size = CGEN_MAX_INSN_SIZE;
-
-  cd->hw_list = & i960_cgen_hw_table[0];
-
-  cd->ifld_table = & i960_cgen_ifld_table[0];
+  return (CGEN_CPU_DESC) cd;
+}
 
-  cd->operand_table = & i960_cgen_operand_table[0];
+/* Cover fn to i960_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
+   MACH_NAME is the bfd name of the mach.  */
 
-  {
-    int i;
-    const CGEN_IBASE *ib = & i960_cgen_insn_table[0];
-    CGEN_INSN *insns = (CGEN_INSN *) xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
-    memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
-    for (i = 0; i < MAX_INSNS; ++i)
-      insns[i].base = &ib[i];
-    cd->insn_table.init_entries = insns;
-  }
-  cd->insn_table.entry_size = sizeof (CGEN_IBASE);
-  cd->insn_table.num_init_entries = MAX_INSNS;
-
-  return (CGEN_CPU_DESC) cd;
+CGEN_CPU_DESC
+i960_cgen_cpu_open_1 (mach_name, endian)
+     const char *mach_name;
+     enum cgen_endian endian;
+{
+  return i960_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
+                              CGEN_CPU_OPEN_ENDIAN, endian,
+                              CGEN_CPU_OPEN_END);
 }
 
-/* Close a cpu table.  */
+/* Close a cpu table.
+   ??? This can live in a machine independent file, but there's currently
+   no place to put this file (there's no libcgen).  libopcodes is the wrong
+   place as some simulator ports use this but they don't use libopcodes.  */
 
 void
 i960_cgen_cpu_close (cd)
@@ -1779,6 +2080,8 @@ i960_cgen_cpu_close (cd)
 {
   if (cd->insn_table.init_entries)
     free ((CGEN_INSN *) cd->insn_table.init_entries);
+  if (cd->hw_table.entries)
+    free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
   free (cd);
 }
 
index 7a3310f52658d2ac9a0ea90ec4adc2f657163beb..75b3d63750d6c2494d5176a3e46a36b5ec364b9a 100644 (file)
@@ -34,15 +34,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define HAVE_CPU_I960BASE
 
 #define CGEN_INSN_LSB0_P 0
-#define CGEN_WORD_BITSIZE 32
-#define CGEN_DEFAULT_INSN_BITSIZE 32
-#define CGEN_BASE_INSN_BITSIZE 32
-#define CGEN_MIN_INSN_BITSIZE 32
-#define CGEN_MAX_INSN_BITSIZE 64
-#define CGEN_DEFAULT_INSN_SIZE (CGEN_DEFAULT_INSN_BITSIZE / 8)
-#define CGEN_BASE_INSN_SIZE (CGEN_BASE_INSN_BITSIZE / 8)
-#define CGEN_MIN_INSN_SIZE (CGEN_MIN_INSN_BITSIZE / 8)
-#define CGEN_MAX_INSN_SIZE (CGEN_MAX_INSN_BITSIZE / 8)
+
+/* Maximum size of any insn (in bytes).  */
+#define CGEN_MAX_INSN_SIZE 8
+
 #define CGEN_INT_INSN_P 0
 
 /* FIXME: Need to compute CGEN_MAX_SYNTAX_BYTES.  */
@@ -193,24 +188,6 @@ typedef enum insn_ctrl_zero {
   CTRL_ZERO_0
 } INSN_CTRL_ZERO;
 
-/* Enum declaration for general registers.  */
-typedef enum h_gr {
-  H_GR_FP = 31, H_GR_SP = 1, H_GR_R0 = 0, H_GR_R1 = 1
- , H_GR_R2 = 2, H_GR_R3 = 3, H_GR_R4 = 4, H_GR_R5 = 5
- , H_GR_R6 = 6, H_GR_R7 = 7, H_GR_R8 = 8, H_GR_R9 = 9
- , H_GR_R10 = 10, H_GR_R11 = 11, H_GR_R12 = 12, H_GR_R13 = 13
- , H_GR_R14 = 14, H_GR_R15 = 15, H_GR_G0 = 16, H_GR_G1 = 17
- , H_GR_G2 = 18, H_GR_G3 = 19, H_GR_G4 = 20, H_GR_G5 = 21
- , H_GR_G6 = 22, H_GR_G7 = 23, H_GR_G8 = 24, H_GR_G9 = 25
- , H_GR_G10 = 26, H_GR_G11 = 27, H_GR_G12 = 28, H_GR_G13 = 29
- , H_GR_G14 = 30, H_GR_G15 = 31
-} H_GR;
-
-/* Enum declaration for condition code.  */
-typedef enum h_cc {
-  H_CC_CC
-} H_CC;
-
 /* Attributes.  */
 
 /* Enum declaration for machine type selection.  */
@@ -218,7 +195,13 @@ typedef enum mach_attr {
   MACH_BASE, MACH_I960_KA_SA, MACH_I960_CA, MACH_MAX
 } MACH_ATTR;
 
+/* Enum declaration for instruction set selection.  */
+typedef enum isa_attr {
+  ISA_I960, ISA_MAX
+} ISA_ATTR;
+
 /* Number of architecture variants.  */
+#define MAX_ISAS  1
 #define MAX_MACHS ((int) MACH_MAX)
 
 /* Ifield support.  */
@@ -229,13 +212,13 @@ extern const struct cgen_ifld i960_cgen_ifld_table[];
 
 /* Enum declaration for cgen_ifld attrs.  */
 typedef enum cgen_ifld_attr {
-  CGEN_IFLD_MACH, CGEN_IFLD_NBOOLS, CGEN_IFLD_START_BOOL = 31, CGEN_IFLD_VIRTUAL
- , CGEN_IFLD_UNSIGNED, CGEN_IFLD_PCREL_ADDR, CGEN_IFLD_ABS_ADDR, CGEN_IFLD_RESERVED
- , CGEN_IFLD_SIGN_OPT
+  CGEN_IFLD_VIRTUAL, CGEN_IFLD_PCREL_ADDR, CGEN_IFLD_ABS_ADDR, CGEN_IFLD_RESERVED
+ , CGEN_IFLD_SIGN_OPT, CGEN_IFLD_SIGNED, CGEN_IFLD_END_BOOLS, CGEN_IFLD_START_NBOOLS = 31
+ , CGEN_IFLD_MACH, CGEN_IFLD_END_NBOOLS
 } CGEN_IFLD_ATTR;
 
-/* Number of non-boolean elements in cgen_ifld.  */
-#define CGEN_IFLD_NBOOL_ATTRS ((int) CGEN_IFLD_NBOOLS)
+/* Number of non-boolean elements in cgen_ifld_attr.  */
+#define CGEN_IFLD_NBOOL_ATTRS (CGEN_IFLD_END_NBOOLS - CGEN_IFLD_START_NBOOLS - 1)
 
 /* Enum declaration for i960 ifield types.  */
 typedef enum ifield_type {
@@ -254,20 +237,19 @@ typedef enum ifield_type {
 
 /* Enum declaration for cgen_hw attrs.  */
 typedef enum cgen_hw_attr {
-  CGEN_HW_MACH, CGEN_HW_NBOOLS, CGEN_HW_START_BOOL = 31, CGEN_HW_VIRTUAL
- , CGEN_HW_UNSIGNED, CGEN_HW_SIGNED, CGEN_HW_CACHE_ADDR, CGEN_HW_FUN_ACCESS
- , CGEN_HW_PC, CGEN_HW_PROFILE
+  CGEN_HW_VIRTUAL, CGEN_HW_CACHE_ADDR, CGEN_HW_PC, CGEN_HW_PROFILE
+ , CGEN_HW_END_BOOLS, CGEN_HW_START_NBOOLS = 31, CGEN_HW_MACH, CGEN_HW_END_NBOOLS
 } CGEN_HW_ATTR;
 
-/* Number of non-boolean elements in cgen_hw.  */
-#define CGEN_HW_NBOOL_ATTRS ((int) CGEN_HW_NBOOLS)
+/* Number of non-boolean elements in cgen_hw_attr.  */
+#define CGEN_HW_NBOOL_ATTRS (CGEN_HW_END_NBOOLS - CGEN_HW_START_NBOOLS - 1)
 
 /* Enum declaration for i960 hardware types.  */
-typedef enum hw_type {
-  HW_H_PC, HW_H_MEMORY, HW_H_SINT, HW_H_UINT
- , HW_H_ADDR, HW_H_IADDR, HW_H_GR, HW_H_CC
+typedef enum cgen_hw_type {
+  HW_H_MEMORY, HW_H_SINT, HW_H_UINT, HW_H_ADDR
+ , HW_H_IADDR, HW_H_PC, HW_H_GR, HW_H_CC
  , HW_MAX
-} HW_TYPE;
+} CGEN_HW_TYPE;
 
 #define MAX_HW ((int) HW_MAX)
 
@@ -275,13 +257,13 @@ typedef enum hw_type {
 
 /* Enum declaration for cgen_operand attrs.  */
 typedef enum cgen_operand_attr {
-  CGEN_OPERAND_MACH, CGEN_OPERAND_NBOOLS, CGEN_OPERAND_START_BOOL = 31, CGEN_OPERAND_VIRTUAL
- , CGEN_OPERAND_UNSIGNED, CGEN_OPERAND_PCREL_ADDR, CGEN_OPERAND_ABS_ADDR, CGEN_OPERAND_SIGN_OPT
- , CGEN_OPERAND_NEGATIVE, CGEN_OPERAND_RELAX, CGEN_OPERAND_SEM_ONLY
+  CGEN_OPERAND_VIRTUAL, CGEN_OPERAND_PCREL_ADDR, CGEN_OPERAND_ABS_ADDR, CGEN_OPERAND_SIGN_OPT
+ , CGEN_OPERAND_SIGNED, CGEN_OPERAND_NEGATIVE, CGEN_OPERAND_RELAX, CGEN_OPERAND_SEM_ONLY
+ , CGEN_OPERAND_END_BOOLS, CGEN_OPERAND_START_NBOOLS = 31, CGEN_OPERAND_MACH, CGEN_OPERAND_END_NBOOLS
 } CGEN_OPERAND_ATTR;
 
-/* Number of non-boolean elements in cgen_operand.  */
-#define CGEN_OPERAND_NBOOL_ATTRS ((int) CGEN_OPERAND_NBOOLS)
+/* Number of non-boolean elements in cgen_operand_attr.  */
+#define CGEN_OPERAND_NBOOL_ATTRS (CGEN_OPERAND_END_NBOOLS - CGEN_OPERAND_START_NBOOLS - 1)
 
 /* Enum declaration for i960 operand types.  */
 typedef enum cgen_operand_type {
@@ -302,20 +284,21 @@ typedef enum cgen_operand_type {
 
 /* Enum declaration for cgen_insn attrs.  */
 typedef enum cgen_insn_attr {
-  CGEN_INSN_MACH, CGEN_INSN_NBOOLS, CGEN_INSN_START_BOOL = 31, CGEN_INSN_ALIAS
- , CGEN_INSN_VIRTUAL, CGEN_INSN_UNCOND_CTI, CGEN_INSN_COND_CTI, CGEN_INSN_SKIP_CTI
- , CGEN_INSN_DELAY_SLOT, CGEN_INSN_RELAXABLE, CGEN_INSN_RELAX, CGEN_INSN_NO_DIS
- , CGEN_INSN_PBB
+  CGEN_INSN_ALIAS, CGEN_INSN_VIRTUAL, CGEN_INSN_UNCOND_CTI, CGEN_INSN_COND_CTI
+ , CGEN_INSN_SKIP_CTI, CGEN_INSN_DELAY_SLOT, CGEN_INSN_RELAXABLE, CGEN_INSN_RELAX
+ , CGEN_INSN_NO_DIS, CGEN_INSN_PBB, CGEN_INSN_END_BOOLS, CGEN_INSN_START_NBOOLS = 31
+ , CGEN_INSN_MACH, CGEN_INSN_END_NBOOLS
 } CGEN_INSN_ATTR;
 
-/* Number of non-boolean elements in cgen_insn.  */
-#define CGEN_INSN_NBOOL_ATTRS ((int) CGEN_INSN_NBOOLS)
+/* Number of non-boolean elements in cgen_insn_attr.  */
+#define CGEN_INSN_NBOOL_ATTRS (CGEN_INSN_END_NBOOLS - CGEN_INSN_START_NBOOLS - 1)
 
 /* cgen.h uses things we just defined.  */
 #include "opcode/cgen.h"
 
 /* Attributes.  */
-extern const CGEN_ATTR_TABLE i960_cgen_hw_attr_table[];
+extern const CGEN_ATTR_TABLE i960_cgen_hardware_attr_table[];
+extern const CGEN_ATTR_TABLE i960_cgen_ifield_attr_table[];
 extern const CGEN_ATTR_TABLE i960_cgen_operand_attr_table[];
 extern const CGEN_ATTR_TABLE i960_cgen_insn_attr_table[];
 
@@ -324,18 +307,6 @@ extern const CGEN_ATTR_TABLE i960_cgen_insn_attr_table[];
 extern CGEN_KEYWORD i960_cgen_opval_h_gr;
 extern CGEN_KEYWORD i960_cgen_opval_h_cc;
 
-#define CGEN_INIT_PARSE(od) \
-{\
-}
-#define CGEN_INIT_INSERT(od) \
-{\
-}
-#define CGEN_INIT_EXTRACT(od) \
-{\
-}
-#define CGEN_INIT_PRINT(od) \
-{\
-}
 
 
 
index a454ab371a037448268fd429d62d0641c51f99dc..0b9da780cf32e49cb1b7f1b3cb754f56b88fdda4 100644 (file)
@@ -54,8 +54,10 @@ typedef enum cgen_insn_type {
  , I960_INSN_NOTAND3, I960_INSN_XOR, I960_INSN_XOR1, I960_INSN_XOR2
  , I960_INSN_XOR3, I960_INSN_OR, I960_INSN_OR1, I960_INSN_OR2
  , I960_INSN_OR3, I960_INSN_NOR, I960_INSN_NOR1, I960_INSN_NOR2
- , I960_INSN_NOR3, I960_INSN_NOT, I960_INSN_NOT1, I960_INSN_NOT2
- , I960_INSN_NOT3, I960_INSN_CLRBIT, I960_INSN_CLRBIT1, I960_INSN_CLRBIT2
+ , I960_INSN_NOR3, I960_INSN_XNOR, I960_INSN_XNOR1, I960_INSN_XNOR2
+ , I960_INSN_XNOR3, I960_INSN_NOT, I960_INSN_NOT1, I960_INSN_NOT2
+ , I960_INSN_NOT3, I960_INSN_ORNOT, I960_INSN_ORNOT1, I960_INSN_ORNOT2
+ , I960_INSN_ORNOT3, I960_INSN_CLRBIT, I960_INSN_CLRBIT1, I960_INSN_CLRBIT2
  , I960_INSN_CLRBIT3, I960_INSN_SHLO, I960_INSN_SHLO1, I960_INSN_SHLO2
  , I960_INSN_SHLO3, I960_INSN_SHRO, I960_INSN_SHRO1, I960_INSN_SHRO2
  , I960_INSN_SHRO3, I960_INSN_SHLI, I960_INSN_SHLI1, I960_INSN_SHLI2
@@ -151,6 +153,18 @@ struct cgen_fields
   long f_ctrl_zero;
 };
 
+#define CGEN_INIT_PARSE(od) \
+{\
+}
+#define CGEN_INIT_INSERT(od) \
+{\
+}
+#define CGEN_INIT_EXTRACT(od) \
+{\
+}
+#define CGEN_INIT_PRINT(od) \
+{\
+}
 
 
 #endif /* I960_OPC_H */
index e4794daca311d88ca7faf34627a2a1fb5b7db21f..471b03e71376e835495379273152ef1204d6f68f 100644 (file)
 #define FP0_REGNUM 36   /* First floating point register */
 /* Some registers have more than one name */
 #define PC_REGNUM  IP_REGNUM    /* GDB refers to ip as the Program Counter */
+
+SI a_i960_h_gr_get (SIM_CPU *, UINT);
+void a_i960_h_gr_set (SIM_CPU *, UINT, SI);
+IADDR a_i960_h_pc_get (SIM_CPU *);
+void a_i960_h_pc_set (SIM_CPU *, IADDR);
 \f
 #define GETTWI GETTSI
 #define SETTWI SETTSI
index 9737c521011b6f4d724e5c484a33d6219fa6e0fe..78fac37e6bceafef4890bd44341bc25623aa6819 100644 (file)
@@ -68,6 +68,70 @@ i960base_store_register (SIM_CPU *current_cpu, int rn, unsigned char *buf,
   return -1; /*FIXME*/
 }
 \f
+/* Cover fns for mach independent register accesses.  */
+
+SI
+a_i960_h_gr_get (SIM_CPU *current_cpu, UINT regno)
+{
+  switch (MACH_NUM (CPU_MACH (current_cpu)))
+    {
+#ifdef HAVE_CPU_I960BASE
+    case MACH_I960_KA_SA :
+    case MACH_I960_CA :
+      return i960base_h_gr_get (current_cpu, regno);
+#endif
+    default :
+      abort ();
+    }
+}
+
+void
+a_i960_h_gr_set (SIM_CPU *current_cpu, UINT regno, SI newval)
+{
+  switch (MACH_NUM (CPU_MACH (current_cpu)))
+    {
+#ifdef HAVE_CPU_I960BASE
+    case MACH_I960_KA_SA :
+    case MACH_I960_CA :
+      i960base_h_gr_set (current_cpu, regno, newval);
+      break;
+#endif
+    default :
+      abort ();
+    }
+}
+
+IADDR
+a_i960_h_pc_get (SIM_CPU *current_cpu)
+{
+  switch (MACH_NUM (CPU_MACH (current_cpu)))
+    {
+#ifdef HAVE_CPU_I960BASE
+    case MACH_I960_KA_SA :
+    case MACH_I960_CA :
+      return i960base_h_pc_get (current_cpu);
+#endif
+    default :
+      abort ();
+    }
+}
+
+void
+a_i960_h_pc_set (SIM_CPU *current_cpu, IADDR newval)
+{
+  switch (MACH_NUM (CPU_MACH (current_cpu)))
+    {
+#ifdef HAVE_CPU_I960BASE
+    case MACH_I960_KA_SA :
+    case MACH_I960_CA :
+      i960base_h_pc_set (current_cpu, newval);
+      break;
+#endif
+    default :
+      abort ();
+    }
+}
+\f
 #if WITH_PROFILE_MODEL_P
 
 /* FIXME: Some of these should be inline or macros.  Later.  */
index 5069eb4e8763ef841ab56ef8f341cb12acf426b4..8881f3e43d2902e84477f863d07b67f188fbb599 100644 (file)
@@ -994,6 +994,70 @@ model_i960KA_nor3 (SIM_CPU *current_cpu, void *sem_arg)
 #undef FLD
 }
 
+static int
+model_i960KA_xnor (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960KA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960KA_xnor1 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo1.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960KA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960KA_xnor2 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo2.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960KA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960KA_xnor3 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo3.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960KA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
 static int
 model_i960KA_not (SIM_CPU *current_cpu, void *sem_arg)
 {
@@ -1058,6 +1122,70 @@ model_i960KA_not3 (SIM_CPU *current_cpu, void *sem_arg)
 #undef FLD
 }
 
+static int
+model_i960KA_ornot (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960KA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960KA_ornot1 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo1.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960KA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960KA_ornot2 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo2.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960KA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960KA_ornot3 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo3.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960KA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
 static int
 model_i960KA_clrbit (SIM_CPU *current_cpu, void *sem_arg)
 {
@@ -1125,7 +1253,7 @@ model_i960KA_clrbit3 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shlo (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1141,7 +1269,7 @@ model_i960KA_shlo (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shlo1 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1157,7 +1285,7 @@ model_i960KA_shlo1 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shlo2 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1173,7 +1301,7 @@ model_i960KA_shlo2 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shlo3 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1189,7 +1317,7 @@ model_i960KA_shlo3 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shro (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1205,7 +1333,7 @@ model_i960KA_shro (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shro1 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1221,7 +1349,7 @@ model_i960KA_shro1 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shro2 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1237,7 +1365,7 @@ model_i960KA_shro2 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shro3 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1253,7 +1381,7 @@ model_i960KA_shro3 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shli (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1269,7 +1397,7 @@ model_i960KA_shli (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shli1 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1285,7 +1413,7 @@ model_i960KA_shli1 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shli2 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1301,7 +1429,7 @@ model_i960KA_shli2 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shli3 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1317,7 +1445,7 @@ model_i960KA_shli3 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shri (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1333,7 +1461,7 @@ model_i960KA_shri (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shri1 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1349,7 +1477,7 @@ model_i960KA_shri1 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shri2 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -1365,7 +1493,7 @@ model_i960KA_shri2 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960KA_shri3 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5522,6 +5650,70 @@ model_i960CA_nor3 (SIM_CPU *current_cpu, void *sem_arg)
 #undef FLD
 }
 
+static int
+model_i960CA_xnor (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960CA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960CA_xnor1 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo1.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960CA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960CA_xnor2 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo2.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960CA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960CA_xnor3 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo3.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960CA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
 static int
 model_i960CA_not (SIM_CPU *current_cpu, void *sem_arg)
 {
@@ -5586,6 +5778,70 @@ model_i960CA_not3 (SIM_CPU *current_cpu, void *sem_arg)
 #undef FLD
 }
 
+static int
+model_i960CA_ornot (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960CA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960CA_ornot1 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo1.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960CA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960CA_ornot2 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo2.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960CA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
+static int
+model_i960CA_ornot3 (SIM_CPU *current_cpu, void *sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo3.f
+  const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
+  const IDESC * UNUSED idesc = abuf->idesc;
+  int cycles = 0;
+  {
+    int referenced = 0;
+    int UNUSED insn_referenced = abuf->written;
+    cycles += i960base_model_i960CA_u_exec (current_cpu, idesc, 0, referenced);
+  }
+  return cycles;
+#undef FLD
+}
+
 static int
 model_i960CA_clrbit (SIM_CPU *current_cpu, void *sem_arg)
 {
@@ -5653,7 +5909,7 @@ model_i960CA_clrbit3 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shlo (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5669,7 +5925,7 @@ model_i960CA_shlo (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shlo1 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5685,7 +5941,7 @@ model_i960CA_shlo1 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shlo2 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5701,7 +5957,7 @@ model_i960CA_shlo2 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shlo3 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5717,7 +5973,7 @@ model_i960CA_shlo3 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shro (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5733,7 +5989,7 @@ model_i960CA_shro (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shro1 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5749,7 +6005,7 @@ model_i960CA_shro1 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shro2 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5765,7 +6021,7 @@ model_i960CA_shro2 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shro3 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5781,7 +6037,7 @@ model_i960CA_shro3 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shli (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5797,7 +6053,7 @@ model_i960CA_shli (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shli1 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5813,7 +6069,7 @@ model_i960CA_shli1 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shli2 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5829,7 +6085,7 @@ model_i960CA_shli2 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shli3 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5845,7 +6101,7 @@ model_i960CA_shli3 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shri (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5861,7 +6117,7 @@ model_i960CA_shri (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shri1 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5877,7 +6133,7 @@ model_i960CA_shri1 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shri2 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -5893,7 +6149,7 @@ model_i960CA_shri2 (SIM_CPU *current_cpu, void *sem_arg)
 static int
 model_i960CA_shri3 (SIM_CPU *current_cpu, void *sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   const ARGBUF * UNUSED abuf = SEM_ARGBUF ((SEM_ARG) sem_arg);
   const IDESC * UNUSED idesc = abuf->idesc;
   int cycles = 0;
@@ -9162,10 +9418,18 @@ static const INSN_TIMING i960KA_timing[] = {
   { I960BASE_INSN_NOR1, model_i960KA_nor1, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOR2, model_i960KA_nor2, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOR3, model_i960KA_nor3, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_XNOR, model_i960KA_xnor, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_XNOR1, model_i960KA_xnor1, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_XNOR2, model_i960KA_xnor2, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_XNOR3, model_i960KA_xnor3, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOT, model_i960KA_not, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOT1, model_i960KA_not1, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOT2, model_i960KA_not2, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOT3, model_i960KA_not3, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_ORNOT, model_i960KA_ornot, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_ORNOT1, model_i960KA_ornot1, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_ORNOT2, model_i960KA_ornot2, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_ORNOT3, model_i960KA_ornot3, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_CLRBIT, model_i960KA_clrbit, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_CLRBIT1, model_i960KA_clrbit1, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_CLRBIT2, model_i960KA_clrbit2, { { (int) UNIT_I960KA_U_EXEC, 1, 1 } } },
@@ -9456,10 +9720,18 @@ static const INSN_TIMING i960CA_timing[] = {
   { I960BASE_INSN_NOR1, model_i960CA_nor1, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOR2, model_i960CA_nor2, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOR3, model_i960CA_nor3, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_XNOR, model_i960CA_xnor, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_XNOR1, model_i960CA_xnor1, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_XNOR2, model_i960CA_xnor2, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_XNOR3, model_i960CA_xnor3, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOT, model_i960CA_not, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOT1, model_i960CA_not1, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOT2, model_i960CA_not2, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_NOT3, model_i960CA_not3, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_ORNOT, model_i960CA_ornot, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_ORNOT1, model_i960CA_ornot1, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_ORNOT2, model_i960CA_ornot2, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
+  { I960BASE_INSN_ORNOT3, model_i960CA_ornot3, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_CLRBIT, model_i960CA_clrbit, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_CLRBIT1, model_i960CA_clrbit1, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
   { I960BASE_INSN_CLRBIT2, model_i960CA_clrbit2, { { (int) UNIT_I960CA_U_EXEC, 1, 1 } } },
@@ -9759,7 +10031,7 @@ i960_ka_sa_init_cpu (SIM_CPU *cpu)
 
 const MACH i960_ka_sa_mach =
 {
-  "i960:ka_sa", "i960:ka_sa",
+  "i960:ka_sa", "i960:ka_sa", MACH_I960_KA_SA,
   32, 32, & i960_ka_sa_models[0], & i960base_imp_properties,
   i960_ka_sa_init_cpu,
   i960base_prepare_run
@@ -9785,7 +10057,7 @@ i960_ca_init_cpu (SIM_CPU *cpu)
 
 const MACH i960_ca_mach =
 {
-  "i960:ca", "i960:ca",
+  "i960:ca", "i960:ca", MACH_I960_CA,
   32, 32, & i960_ca_models[0], & i960base_imp_properties,
   i960_ca_init_cpu,
   i960base_prepare_run
index 2ab52eb0382360937fa200f03877d32b88c7c896..b45109fecd9156853a0179e21d9d7df15e99d490 100644 (file)
@@ -98,10 +98,18 @@ with this program; if not, write to the Free Software Foundation, Inc.,
     { I960BASE_INSN_NOR1, && case_sem_INSN_NOR1 },
     { I960BASE_INSN_NOR2, && case_sem_INSN_NOR2 },
     { I960BASE_INSN_NOR3, && case_sem_INSN_NOR3 },
+    { I960BASE_INSN_XNOR, && case_sem_INSN_XNOR },
+    { I960BASE_INSN_XNOR1, && case_sem_INSN_XNOR1 },
+    { I960BASE_INSN_XNOR2, && case_sem_INSN_XNOR2 },
+    { I960BASE_INSN_XNOR3, && case_sem_INSN_XNOR3 },
     { I960BASE_INSN_NOT, && case_sem_INSN_NOT },
     { I960BASE_INSN_NOT1, && case_sem_INSN_NOT1 },
     { I960BASE_INSN_NOT2, && case_sem_INSN_NOT2 },
     { I960BASE_INSN_NOT3, && case_sem_INSN_NOT3 },
+    { I960BASE_INSN_ORNOT, && case_sem_INSN_ORNOT },
+    { I960BASE_INSN_ORNOT1, && case_sem_INSN_ORNOT1 },
+    { I960BASE_INSN_ORNOT2, && case_sem_INSN_ORNOT2 },
+    { I960BASE_INSN_ORNOT3, && case_sem_INSN_ORNOT3 },
     { I960BASE_INSN_CLRBIT, && case_sem_INSN_CLRBIT },
     { I960BASE_INSN_CLRBIT1, && case_sem_INSN_CLRBIT1 },
     { I960BASE_INSN_CLRBIT2, && case_sem_INSN_CLRBIT2 },
@@ -1648,6 +1656,82 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
 
+#undef FLD
+}
+  NEXT (vpc);
+
+  CASE (sem, INSN_XNOR) : /* xnor $src1, $src2, $dst */
+{
+  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+#define FLD(f) abuf->fields.fmt_mulo.f
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = INVSI (XORSI (* FLD (i_src1), * FLD (i_src2)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+#undef FLD
+}
+  NEXT (vpc);
+
+  CASE (sem, INSN_XNOR1) : /* xnor $lit1, $src2, $dst */
+{
+  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+#define FLD(f) abuf->fields.fmt_mulo1.f
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = INVSI (XORSI (FLD (f_src1), * FLD (i_src2)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+#undef FLD
+}
+  NEXT (vpc);
+
+  CASE (sem, INSN_XNOR2) : /* xnor $src1, $lit2, $dst */
+{
+  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+#define FLD(f) abuf->fields.fmt_mulo2.f
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = INVSI (XORSI (* FLD (i_src1), FLD (f_src2)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+#undef FLD
+}
+  NEXT (vpc);
+
+  CASE (sem, INSN_XNOR3) : /* xnor $lit1, $lit2, $dst */
+{
+  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+#define FLD(f) abuf->fields.fmt_mulo3.f
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = INVSI (XORSI (FLD (f_src1), FLD (f_src2)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
 #undef FLD
 }
   NEXT (vpc);
@@ -1724,6 +1808,82 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
 
+#undef FLD
+}
+  NEXT (vpc);
+
+  CASE (sem, INSN_ORNOT) : /* ornot $src1, $src2, $dst */
+{
+  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+#define FLD(f) abuf->fields.fmt_mulo.f
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = ORSI (* FLD (i_src2), INVSI (* FLD (i_src1)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+#undef FLD
+}
+  NEXT (vpc);
+
+  CASE (sem, INSN_ORNOT1) : /* ornot $lit1, $src2, $dst */
+{
+  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+#define FLD(f) abuf->fields.fmt_mulo1.f
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = ORSI (* FLD (i_src2), INVSI (FLD (f_src1)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+#undef FLD
+}
+  NEXT (vpc);
+
+  CASE (sem, INSN_ORNOT2) : /* ornot $src1, $lit2, $dst */
+{
+  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+#define FLD(f) abuf->fields.fmt_mulo2.f
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = ORSI (FLD (f_src2), INVSI (* FLD (i_src1)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+#undef FLD
+}
+  NEXT (vpc);
+
+  CASE (sem, INSN_ORNOT3) : /* ornot $lit1, $lit2, $dst */
+{
+  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+#define FLD(f) abuf->fields.fmt_mulo3.f
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = ORSI (FLD (f_src2), INVSI (FLD (f_src1)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
 #undef FLD
 }
   NEXT (vpc);
@@ -1808,13 +1968,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (* FLD (i_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1827,13 +1987,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (* FLD (i_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1846,13 +2006,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (FLD (f_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1865,13 +2025,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (FLD (f_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1884,13 +2044,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRLSI (* FLD (i_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SRLSI (* FLD (i_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1903,13 +2063,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRLSI (* FLD (i_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SRLSI (* FLD (i_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1922,13 +2082,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRLSI (FLD (f_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SRLSI (FLD (f_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1941,13 +2101,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRLSI (FLD (f_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SRLSI (FLD (f_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1960,13 +2120,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (* FLD (i_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1979,13 +2139,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (* FLD (i_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1998,13 +2158,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (FLD (f_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -2017,13 +2177,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (FLD (f_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -2036,13 +2196,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRASI (* FLD (i_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (SRASI (* FLD (i_src2), 31)) : (SRASI (* FLD (i_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -2055,13 +2215,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRASI (* FLD (i_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (SRASI (* FLD (i_src2), 31)) : (SRASI (* FLD (i_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -2074,13 +2234,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRASI (FLD (f_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (SRASI (FLD (f_src2), 31)) : (SRASI (FLD (f_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -2093,13 +2253,13 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 {
   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRASI (FLD (f_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (SRASI (FLD (f_src2), 31)) : (SRASI (FLD (f_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -2117,9 +2277,9 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   DI tmp_temp;
+  SI tmp_dregno;
   tmp_temp = MULDI (ZEXTSIDI (* FLD (i_src1)), ZEXTSIDI (* FLD (i_src2)));
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2130,9 +2290,9 @@ do {
   {
     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2147,9 +2307,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   DI tmp_temp;
+  SI tmp_dregno;
   tmp_temp = MULDI (ZEXTSIDI (FLD (f_src1)), ZEXTSIDI (* FLD (i_src2)));
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2160,9 +2320,9 @@ do {
   {
     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2177,9 +2337,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   DI tmp_temp;
+  SI tmp_dregno;
   tmp_temp = MULDI (ZEXTSIDI (* FLD (i_src1)), ZEXTSIDI (FLD (f_src2)));
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2190,9 +2350,9 @@ do {
   {
     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2207,9 +2367,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   DI tmp_temp;
+  SI tmp_dregno;
   tmp_temp = MULDI (ZEXTSIDI (FLD (f_src1)), ZEXTSIDI (FLD (f_src2)));
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2220,9 +2380,9 @@ do {
   {
     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2275,9 +2435,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_sregno;
+{
   SI tmp_dregno;
+  SI tmp_sregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_sregno = FLD (f_src1);
   {
@@ -2288,9 +2448,9 @@ do {
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2305,7 +2465,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2316,9 +2476,9 @@ do {
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2333,9 +2493,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_sregno;
+{
   SI tmp_dregno;
+  SI tmp_sregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_sregno = FLD (f_src1);
   {
@@ -2346,14 +2506,14 @@ do {
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (2))]);
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2368,7 +2528,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2379,14 +2539,14 @@ do {
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2401,9 +2561,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_sregno;
+{
   SI tmp_dregno;
+  SI tmp_sregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_sregno = FLD (f_src1);
   {
@@ -2414,19 +2574,19 @@ do {
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (2))]);
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (3))]);
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2441,7 +2601,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2452,19 +2612,19 @@ do {
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3429,9 +3589,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_offset);
   {
@@ -3442,9 +3602,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3459,9 +3619,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
   {
@@ -3472,9 +3632,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3489,9 +3649,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = * FLD (i_abase);
   {
@@ -3502,9 +3662,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3519,9 +3679,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -3532,9 +3692,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3549,9 +3709,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_optdisp);
   {
@@ -3562,9 +3722,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3579,9 +3739,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
   {
@@ -3592,9 +3752,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3609,9 +3769,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -3622,9 +3782,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3639,9 +3799,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
   {
@@ -3652,9 +3812,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3669,9 +3829,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_offset);
   {
@@ -3682,14 +3842,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3704,9 +3864,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
   {
@@ -3717,14 +3877,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3739,9 +3899,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = * FLD (i_abase);
   {
@@ -3752,14 +3912,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3774,9 +3934,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -3787,14 +3947,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3809,9 +3969,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_optdisp);
   {
@@ -3822,14 +3982,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3844,9 +4004,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
   {
@@ -3857,14 +4017,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3879,9 +4039,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -3892,14 +4052,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3914,9 +4074,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
   {
@@ -3927,14 +4087,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3949,9 +4109,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_offset);
   {
@@ -3962,19 +4122,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -3989,9 +4149,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
   {
@@ -4002,19 +4162,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4029,9 +4189,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = * FLD (i_abase);
   {
@@ -4042,19 +4202,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4069,9 +4229,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -4082,19 +4242,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4109,9 +4269,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_optdisp);
   {
@@ -4122,19 +4282,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4149,9 +4309,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
   {
@@ -4162,19 +4322,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4189,9 +4349,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -4202,19 +4362,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4229,9 +4389,9 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
   {
@@ -4242,19 +4402,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4725,7 +4885,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4738,7 +4898,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4753,7 +4913,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4766,7 +4926,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4781,7 +4941,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4794,7 +4954,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4809,7 +4969,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4822,7 +4982,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4837,7 +4997,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4850,7 +5010,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4865,7 +5025,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4878,7 +5038,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4893,7 +5053,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4906,7 +5066,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4921,7 +5081,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4934,7 +5094,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4949,7 +5109,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4967,7 +5127,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -4982,7 +5142,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5000,7 +5160,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5015,7 +5175,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5033,7 +5193,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5048,7 +5208,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5066,7 +5226,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5081,7 +5241,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5099,7 +5259,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5114,7 +5274,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5132,7 +5292,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5147,7 +5307,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5165,7 +5325,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5180,7 +5340,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5198,7 +5358,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5213,7 +5373,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5236,7 +5396,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5251,7 +5411,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5274,7 +5434,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5289,7 +5449,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5312,7 +5472,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5327,7 +5487,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5350,7 +5510,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5365,7 +5525,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5388,7 +5548,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5403,7 +5563,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5426,7 +5586,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5441,7 +5601,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5464,7 +5624,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -5479,7 +5639,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5502,7 +5662,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -6220,7 +6380,7 @@ if (NESI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
   {
     SI opval = (LTSI (* FLD (i_src1), * FLD (i_src2))) ? (4) : (EQSI (* FLD (i_src1), * FLD (i_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
 #undef FLD
@@ -6239,7 +6399,7 @@ if (NESI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
   {
     SI opval = (LTSI (FLD (f_src1), * FLD (i_src2))) ? (4) : (EQSI (FLD (f_src1), * FLD (i_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
 #undef FLD
@@ -6258,7 +6418,7 @@ if (NESI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
   {
     SI opval = (LTSI (* FLD (i_src1), FLD (f_src2))) ? (4) : (EQSI (* FLD (i_src1), FLD (f_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
 #undef FLD
@@ -6277,7 +6437,7 @@ if (NESI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
   {
     SI opval = (LTSI (FLD (f_src1), FLD (f_src2))) ? (4) : (EQSI (FLD (f_src1), FLD (f_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
 #undef FLD
@@ -6296,7 +6456,7 @@ if (NESI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
   {
     SI opval = (LTUSI (* FLD (i_src1), * FLD (i_src2))) ? (4) : (EQSI (* FLD (i_src1), * FLD (i_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
 #undef FLD
@@ -6315,7 +6475,7 @@ if (NESI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
   {
     SI opval = (LTUSI (FLD (f_src1), * FLD (i_src2))) ? (4) : (EQSI (FLD (f_src1), * FLD (i_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
 #undef FLD
@@ -6334,7 +6494,7 @@ if (NESI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
   {
     SI opval = (LTUSI (* FLD (i_src1), FLD (f_src2))) ? (4) : (EQSI (* FLD (i_src1), FLD (f_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
 #undef FLD
@@ -6353,7 +6513,7 @@ if (NESI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
   {
     SI opval = (LTUSI (FLD (f_src1), FLD (f_src2))) ? (4) : (EQSI (FLD (f_src1), FLD (f_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
 #undef FLD
@@ -6848,7 +7008,7 @@ if (NESI (ANDSI (CPU (h_cc), 7), 0)) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_temp;
   tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
   {
@@ -6908,7 +7068,7 @@ CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
     CPU (h_gr[((UINT) 1)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -6925,7 +7085,7 @@ CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_temp;
   tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
   {
@@ -6985,7 +7145,7 @@ CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
     CPU (h_gr[((UINT) 1)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -7002,7 +7162,7 @@ CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_temp;
   tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
   {
@@ -7062,7 +7222,7 @@ CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
     CPU (h_gr[((UINT) 1)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -7079,7 +7239,7 @@ CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   {
     SI opval = CPU (h_gr[((UINT) 0)]);
     CPU (h_gr[((UINT) 31)]) = opval;
@@ -7106,7 +7266,7 @@ CPU (h_gr[((UINT) 15)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
index e0621889de3b5983b24bb7255b3f0b69ecd4cc42..45f4f7f2f1f6cadc5a15bccb666b0c5b7101dde7 100644 (file)
@@ -1440,6 +1440,90 @@ SEM_FN_NAME (i960base,nor3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 #undef FLD
 }
 
+/* xnor: xnor $src1, $src2, $dst */
+
+SEM_PC
+SEM_FN_NAME (i960base,xnor) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo.f
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = INVSI (XORSI (* FLD (i_src1), * FLD (i_src2)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+  return vpc;
+#undef FLD
+}
+
+/* xnor1: xnor $lit1, $src2, $dst */
+
+SEM_PC
+SEM_FN_NAME (i960base,xnor1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo1.f
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = INVSI (XORSI (FLD (f_src1), * FLD (i_src2)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+  return vpc;
+#undef FLD
+}
+
+/* xnor2: xnor $src1, $lit2, $dst */
+
+SEM_PC
+SEM_FN_NAME (i960base,xnor2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo2.f
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = INVSI (XORSI (* FLD (i_src1), FLD (f_src2)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+  return vpc;
+#undef FLD
+}
+
+/* xnor3: xnor $lit1, $lit2, $dst */
+
+SEM_PC
+SEM_FN_NAME (i960base,xnor3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo3.f
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = INVSI (XORSI (FLD (f_src1), FLD (f_src2)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+  return vpc;
+#undef FLD
+}
+
 /* not: not $src1, $src2, $dst */
 
 SEM_PC
@@ -1524,6 +1608,90 @@ SEM_FN_NAME (i960base,not3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 #undef FLD
 }
 
+/* ornot: ornot $src1, $src2, $dst */
+
+SEM_PC
+SEM_FN_NAME (i960base,ornot) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo.f
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = ORSI (* FLD (i_src2), INVSI (* FLD (i_src1)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+  return vpc;
+#undef FLD
+}
+
+/* ornot1: ornot $lit1, $src2, $dst */
+
+SEM_PC
+SEM_FN_NAME (i960base,ornot1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo1.f
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = ORSI (* FLD (i_src2), INVSI (FLD (f_src1)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+  return vpc;
+#undef FLD
+}
+
+/* ornot2: ornot $src1, $lit2, $dst */
+
+SEM_PC
+SEM_FN_NAME (i960base,ornot2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo2.f
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = ORSI (FLD (f_src2), INVSI (* FLD (i_src1)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+  return vpc;
+#undef FLD
+}
+
+/* ornot3: ornot $lit1, $lit2, $dst */
+
+SEM_PC
+SEM_FN_NAME (i960base,ornot3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
+{
+#define FLD(f) abuf->fields.fmt_mulo3.f
+  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
+  int UNUSED written = 0;
+  IADDR UNUSED pc = abuf->addr;
+  SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
+
+  {
+    SI opval = ORSI (FLD (f_src2), INVSI (FLD (f_src1)));
+    * FLD (i_dst) = opval;
+    TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
+  }
+
+  return vpc;
+#undef FLD
+}
+
 /* clrbit: clrbit $src1, $src2, $dst */
 
 SEM_PC
@@ -1613,14 +1781,14 @@ SEM_FN_NAME (i960base,clrbit3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shlo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (* FLD (i_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1634,14 +1802,14 @@ SEM_FN_NAME (i960base,shlo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shlo1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (* FLD (i_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1655,14 +1823,14 @@ SEM_FN_NAME (i960base,shlo1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shlo2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (FLD (f_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1676,14 +1844,14 @@ SEM_FN_NAME (i960base,shlo2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shlo3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (FLD (f_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1697,14 +1865,14 @@ SEM_FN_NAME (i960base,shlo3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shro) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRLSI (* FLD (i_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SRLSI (* FLD (i_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1718,14 +1886,14 @@ SEM_FN_NAME (i960base,shro) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shro1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRLSI (* FLD (i_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SRLSI (* FLD (i_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1739,14 +1907,14 @@ SEM_FN_NAME (i960base,shro1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shro2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRLSI (FLD (f_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SRLSI (FLD (f_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1760,14 +1928,14 @@ SEM_FN_NAME (i960base,shro2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shro3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRLSI (FLD (f_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SRLSI (FLD (f_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1781,14 +1949,14 @@ SEM_FN_NAME (i960base,shro3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shli) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (* FLD (i_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1802,14 +1970,14 @@ SEM_FN_NAME (i960base,shli) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shli1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (* FLD (i_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (* FLD (i_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1823,14 +1991,14 @@ SEM_FN_NAME (i960base,shli1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shli2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (FLD (f_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1844,14 +2012,14 @@ SEM_FN_NAME (i960base,shli2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shli3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SLLSI (FLD (f_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (0) : (SLLSI (FLD (f_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1865,14 +2033,14 @@ SEM_FN_NAME (i960base,shli3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shri) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit.f
+#define FLD(f) abuf->fields.fmt_shlo.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRASI (* FLD (i_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (SRASI (* FLD (i_src2), 31)) : (SRASI (* FLD (i_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1886,14 +2054,14 @@ SEM_FN_NAME (i960base,shri) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shri1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit1.f
+#define FLD(f) abuf->fields.fmt_shlo1.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRASI (* FLD (i_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (SRASI (* FLD (i_src2), 31)) : (SRASI (* FLD (i_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1907,14 +2075,14 @@ SEM_FN_NAME (i960base,shri1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shri2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit2.f
+#define FLD(f) abuf->fields.fmt_shlo2.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRASI (FLD (f_src2), * FLD (i_src1));
+    SI opval = (GEUSI (* FLD (i_src1), 32)) ? (SRASI (FLD (f_src2), 31)) : (SRASI (FLD (f_src2), * FLD (i_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1928,14 +2096,14 @@ SEM_FN_NAME (i960base,shri2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 SEM_PC
 SEM_FN_NAME (i960base,shri3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
 {
-#define FLD(f) abuf->fields.fmt_notbit3.f
+#define FLD(f) abuf->fields.fmt_shlo3.f
   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
   int UNUSED written = 0;
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
   {
-    SI opval = SRASI (FLD (f_src2), FLD (f_src1));
+    SI opval = (GEUSI (FLD (f_src1), 32)) ? (SRASI (FLD (f_src2), 31)) : (SRASI (FLD (f_src2), FLD (f_src1)));
     * FLD (i_dst) = opval;
     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
   }
@@ -1955,9 +2123,9 @@ SEM_FN_NAME (i960base,emul) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   DI tmp_temp;
+  SI tmp_dregno;
   tmp_temp = MULDI (ZEXTSIDI (* FLD (i_src1)), ZEXTSIDI (* FLD (i_src2)));
   tmp_dregno = FLD (f_srcdst);
   {
@@ -1968,9 +2136,9 @@ do {
   {
     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1987,9 +2155,9 @@ SEM_FN_NAME (i960base,emul1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   DI tmp_temp;
+  SI tmp_dregno;
   tmp_temp = MULDI (ZEXTSIDI (FLD (f_src1)), ZEXTSIDI (* FLD (i_src2)));
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2000,9 +2168,9 @@ do {
   {
     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2019,9 +2187,9 @@ SEM_FN_NAME (i960base,emul2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   DI tmp_temp;
+  SI tmp_dregno;
   tmp_temp = MULDI (ZEXTSIDI (* FLD (i_src1)), ZEXTSIDI (FLD (f_src2)));
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2032,9 +2200,9 @@ do {
   {
     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2051,9 +2219,9 @@ SEM_FN_NAME (i960base,emul3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   DI tmp_temp;
+  SI tmp_dregno;
   tmp_temp = MULDI (ZEXTSIDI (FLD (f_src1)), ZEXTSIDI (FLD (f_src2)));
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2064,9 +2232,9 @@ do {
   {
     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2125,9 +2293,9 @@ SEM_FN_NAME (i960base,movl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_sregno;
+{
   SI tmp_dregno;
+  SI tmp_sregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_sregno = FLD (f_src1);
   {
@@ -2138,9 +2306,9 @@ do {
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2157,7 +2325,7 @@ SEM_FN_NAME (i960base,movl1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2168,9 +2336,9 @@ do {
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2187,9 +2355,9 @@ SEM_FN_NAME (i960base,movt) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_sregno;
+{
   SI tmp_dregno;
+  SI tmp_sregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_sregno = FLD (f_src1);
   {
@@ -2200,14 +2368,14 @@ do {
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (2))]);
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2224,7 +2392,7 @@ SEM_FN_NAME (i960base,movt1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2235,14 +2403,14 @@ do {
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2259,9 +2427,9 @@ SEM_FN_NAME (i960base,movq) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_sregno;
+{
   SI tmp_dregno;
+  SI tmp_sregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_sregno = FLD (f_src1);
   {
@@ -2272,19 +2440,19 @@ do {
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (2))]);
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = CPU (h_gr[((FLD (f_src1)) + (3))]);
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2301,7 +2469,7 @@ SEM_FN_NAME (i960base,movq1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   {
@@ -2312,19 +2480,19 @@ do {
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = 0;
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3391,9 +3559,9 @@ SEM_FN_NAME (i960base,ldl_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_offset);
   {
@@ -3404,9 +3572,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3423,9 +3591,9 @@ SEM_FN_NAME (i960base,ldl_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_ar
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
   {
@@ -3436,9 +3604,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3455,9 +3623,9 @@ SEM_FN_NAME (i960base,ldl_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = * FLD (i_abase);
   {
@@ -3468,9 +3636,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3487,9 +3655,9 @@ SEM_FN_NAME (i960base,ldl_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -3500,9 +3668,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3519,9 +3687,9 @@ SEM_FN_NAME (i960base,ldl_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_optdisp);
   {
@@ -3532,9 +3700,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3551,9 +3719,9 @@ SEM_FN_NAME (i960base,ldl_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
   {
@@ -3564,9 +3732,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3583,9 +3751,9 @@ SEM_FN_NAME (i960base,ldl_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -3596,9 +3764,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3615,9 +3783,9 @@ SEM_FN_NAME (i960base,ldl_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG se
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
   {
@@ -3628,9 +3796,9 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3647,9 +3815,9 @@ SEM_FN_NAME (i960base,ldt_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_offset);
   {
@@ -3660,14 +3828,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3684,9 +3852,9 @@ SEM_FN_NAME (i960base,ldt_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_ar
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
   {
@@ -3697,14 +3865,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3721,9 +3889,9 @@ SEM_FN_NAME (i960base,ldt_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = * FLD (i_abase);
   {
@@ -3734,14 +3902,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3758,9 +3926,9 @@ SEM_FN_NAME (i960base,ldt_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -3771,14 +3939,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3795,9 +3963,9 @@ SEM_FN_NAME (i960base,ldt_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_optdisp);
   {
@@ -3808,14 +3976,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3832,9 +4000,9 @@ SEM_FN_NAME (i960base,ldt_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
   {
@@ -3845,14 +4013,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3869,9 +4037,9 @@ SEM_FN_NAME (i960base,ldt_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -3882,14 +4050,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3906,9 +4074,9 @@ SEM_FN_NAME (i960base,ldt_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG se
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
   {
@@ -3919,14 +4087,14 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3943,9 +4111,9 @@ SEM_FN_NAME (i960base,ldq_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_offset);
   {
@@ -3956,19 +4124,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -3985,9 +4153,9 @@ SEM_FN_NAME (i960base,ldq_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_ar
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
   {
@@ -3998,19 +4166,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4027,9 +4195,9 @@ SEM_FN_NAME (i960base,ldq_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = * FLD (i_abase);
   {
@@ -4040,19 +4208,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4069,9 +4237,9 @@ SEM_FN_NAME (i960base,ldq_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -4082,19 +4250,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4111,9 +4279,9 @@ SEM_FN_NAME (i960base,ldq_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = FLD (f_optdisp);
   {
@@ -4124,19 +4292,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4153,9 +4321,9 @@ SEM_FN_NAME (i960base,ldq_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
   {
@@ -4166,19 +4334,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4195,9 +4363,9 @@ SEM_FN_NAME (i960base,ldq_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
   {
@@ -4208,19 +4376,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4237,9 +4405,9 @@ SEM_FN_NAME (i960base,ldq_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG se
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
-  SI tmp_dregno;
+{
   SI tmp_temp;
+  SI tmp_dregno;
   tmp_dregno = FLD (f_srcdst);
   tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
   {
@@ -4250,19 +4418,19 @@ do {
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-1", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-2", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
-    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-3", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4783,7 +4951,7 @@ SEM_FN_NAME (i960base,stl_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4796,7 +4964,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4813,7 +4981,7 @@ SEM_FN_NAME (i960base,stl_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_ar
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4826,7 +4994,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4843,7 +5011,7 @@ SEM_FN_NAME (i960base,stl_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4856,7 +5024,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4873,7 +5041,7 @@ SEM_FN_NAME (i960base,stl_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4886,7 +5054,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4903,7 +5071,7 @@ SEM_FN_NAME (i960base,stl_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4916,7 +5084,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4933,7 +5101,7 @@ SEM_FN_NAME (i960base,stl_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4946,7 +5114,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4963,7 +5131,7 @@ SEM_FN_NAME (i960base,stl_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -4976,7 +5144,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -4993,7 +5161,7 @@ SEM_FN_NAME (i960base,stl_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG se
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5006,7 +5174,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 4), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5023,7 +5191,7 @@ SEM_FN_NAME (i960base,stt_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5041,7 +5209,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5058,7 +5226,7 @@ SEM_FN_NAME (i960base,stt_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_ar
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5076,7 +5244,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5093,7 +5261,7 @@ SEM_FN_NAME (i960base,stt_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5111,7 +5279,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5128,7 +5296,7 @@ SEM_FN_NAME (i960base,stt_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5146,7 +5314,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5163,7 +5331,7 @@ SEM_FN_NAME (i960base,stt_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5181,7 +5349,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5198,7 +5366,7 @@ SEM_FN_NAME (i960base,stt_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5216,7 +5384,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5233,7 +5401,7 @@ SEM_FN_NAME (i960base,stt_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5251,7 +5419,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5268,7 +5436,7 @@ SEM_FN_NAME (i960base,stt_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG se
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5286,7 +5454,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 8), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5303,7 +5471,7 @@ SEM_FN_NAME (i960base,stq_offset) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5326,7 +5494,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5343,7 +5511,7 @@ SEM_FN_NAME (i960base,stq_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_ar
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5366,7 +5534,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5383,7 +5551,7 @@ SEM_FN_NAME (i960base,stq_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5406,7 +5574,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5423,7 +5591,7 @@ SEM_FN_NAME (i960base,stq_indirect_index) (SIM_CPU *current_cpu, SEM_ARG sem_arg
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5446,7 +5614,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5463,7 +5631,7 @@ SEM_FN_NAME (i960base,stq_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5486,7 +5654,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5503,7 +5671,7 @@ SEM_FN_NAME (i960base,stq_indirect_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5526,7 +5694,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5543,7 +5711,7 @@ SEM_FN_NAME (i960base,stq_index_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5566,7 +5734,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -5583,7 +5751,7 @@ SEM_FN_NAME (i960base,stq_indirect_index_disp) (SIM_CPU *current_cpu, SEM_ARG se
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_sregno;
   tmp_sregno = FLD (f_srcdst);
   {
@@ -5606,7 +5774,7 @@ do {
     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 12), opval);
     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -6382,7 +6550,7 @@ SEM_FN_NAME (i960base,cmpi) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   {
     SI opval = (LTSI (* FLD (i_src1), * FLD (i_src2))) ? (4) : (EQSI (* FLD (i_src1), * FLD (i_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
   return vpc;
@@ -6403,7 +6571,7 @@ SEM_FN_NAME (i960base,cmpi1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   {
     SI opval = (LTSI (FLD (f_src1), * FLD (i_src2))) ? (4) : (EQSI (FLD (f_src1), * FLD (i_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
   return vpc;
@@ -6424,7 +6592,7 @@ SEM_FN_NAME (i960base,cmpi2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   {
     SI opval = (LTSI (* FLD (i_src1), FLD (f_src2))) ? (4) : (EQSI (* FLD (i_src1), FLD (f_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
   return vpc;
@@ -6445,7 +6613,7 @@ SEM_FN_NAME (i960base,cmpi3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   {
     SI opval = (LTSI (FLD (f_src1), FLD (f_src2))) ? (4) : (EQSI (FLD (f_src1), FLD (f_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
   return vpc;
@@ -6466,7 +6634,7 @@ SEM_FN_NAME (i960base,cmpo) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   {
     SI opval = (LTUSI (* FLD (i_src1), * FLD (i_src2))) ? (4) : (EQSI (* FLD (i_src1), * FLD (i_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
   return vpc;
@@ -6487,7 +6655,7 @@ SEM_FN_NAME (i960base,cmpo1) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   {
     SI opval = (LTUSI (FLD (f_src1), * FLD (i_src2))) ? (4) : (EQSI (FLD (f_src1), * FLD (i_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
   return vpc;
@@ -6508,7 +6676,7 @@ SEM_FN_NAME (i960base,cmpo2) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   {
     SI opval = (LTUSI (* FLD (i_src1), FLD (f_src2))) ? (4) : (EQSI (* FLD (i_src1), FLD (f_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
   return vpc;
@@ -6529,7 +6697,7 @@ SEM_FN_NAME (i960base,cmpo3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   {
     SI opval = (LTUSI (FLD (f_src1), FLD (f_src2))) ? (4) : (EQSI (FLD (f_src1), FLD (f_src2))) ? (2) : (1);
     CPU (h_cc) = opval;
-    TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "cc", 'x', opval);
   }
 
   return vpc;
@@ -7070,7 +7238,7 @@ SEM_FN_NAME (i960base,callx_disp) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
 
-do {
+{
   SI tmp_temp;
   tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
   {
@@ -7130,7 +7298,7 @@ CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
     CPU (h_gr[((UINT) 1)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -7149,7 +7317,7 @@ SEM_FN_NAME (i960base,callx_indirect) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_temp;
   tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
   {
@@ -7209,7 +7377,7 @@ CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
     CPU (h_gr[((UINT) 1)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -7228,7 +7396,7 @@ SEM_FN_NAME (i960base,callx_indirect_offset) (SIM_CPU *current_cpu, SEM_ARG sem_
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   SI tmp_temp;
   tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
   {
@@ -7288,7 +7456,7 @@ CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
     CPU (h_gr[((UINT) 1)]) = opval;
     TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -7307,7 +7475,7 @@ SEM_FN_NAME (i960base,ret) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   {
     SI opval = CPU (h_gr[((UINT) 0)]);
     CPU (h_gr[((UINT) 31)]) = opval;
@@ -7334,7 +7502,7 @@ CPU (h_gr[((UINT) 15)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
index 3a58548bcbf5575cfb249815e5de3af3b3e10d4f..6179739b3c26145a8c1a915c9a787c903cf69142 100644 (file)
@@ -31,7 +31,7 @@ static void free_state (SIM_DESC);
    disassembler.  */
 static CGEN_DISASSEMBLER i960_disassemble_insn;
 
-/* Records simulator descriptor so utilities like m32r_dump_regs can be
+/* Records simulator descriptor so utilities like i960_dump_regs can be
    called from gdb.  */
 SIM_DESC current_state;
 \f
@@ -145,8 +145,8 @@ sim_open (kind, callback, abfd, argv)
 
   /* Open a copy of the cpu descriptor table.  */
   {
-    CGEN_CPU_DESC cd = i960_cgen_cpu_open (STATE_ARCHITECTURE (sd)->mach,
-                                          CGEN_ENDIAN_LITTLE);
+    CGEN_CPU_DESC cd = i960_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd)->printable_name,
+                                            CGEN_ENDIAN_LITTLE);
     for (i = 0; i < MAX_NR_PROCESSORS; ++i)
       {
        SIM_CPU *cpu = STATE_CPU (sd, i);
@@ -156,10 +156,10 @@ sim_open (kind, callback, abfd, argv)
   }
 
   /* Initialize various cgen things not done by common framework.
-     Must be done after m32r_cgen_cpu_open.  */
+     Must be done after i960_cgen_cpu_open.  */
   cgen_init (sd);
 
-  /* Store in a global so things like sparc32_dump_regs can be invoked
+  /* Store in a global so things like i960_dump_regs can be invoked
      from the gdb command line.  */
   current_state = sd;
 
index aba789a00ae33292e3b25e419b20c96418f38829..010f2a4d1c0a04a9990eaf91a709fc7397b3e6e4 100644 (file)
@@ -1,3 +1,45 @@
+Fri Apr 16 16:47:43 1999  Doug Evans  <devans@charmed.cygnus.com>
+
+       * devices.c (device_io_read_buffer): New arg `sd'.
+       (device_io_write_buffer): New arg `sd'.
+       (device_error): Give proper arg spec.
+
+1999-04-10  Doug Evans  <devans@casey.cygnus.com>
+
+       * sem-switch.c,sem.c: Rebuild.
+
+1999-03-27  Doug Evans  <devans@casey.cygnus.com>
+
+       * decode.c: Rebuild.
+
+1999-03-26  Doug Evans  <devans@casey.cygnus.com>
+
+       * m32r-sim.h (M32R_DEVICE_LEN): Fix off by one error.
+
+1999-03-22  Doug Evans  <devans@casey.cygnus.com>
+
+       * arch.c,arch.h,model.c: Rebuild.
+       * m32r-sim.h (a_m32r_h_gr_get,a_m32r_h_gr_set): Declare.
+       (a_m32r_h_cr_get,a_m32r_h_cr_set): Declare.
+       * m32r.c (m32rbf_fetch_register): Replace calls to a_m32r_h_pc_get,
+       a_m32r_h_accum_get with appropriate calls to m32rbf_*.
+       (m32rbf_store_register): Ditto.
+       (a_m32r_h_gr_get,a_m32r_h_gr_set): New functions.
+       (a_m32r_h_cr_get,a_m32r_h_cr_set): Ditto.
+       * sim-if.c (sim_open): Update call to m32r_cgen_cpu_open.
+       * traps.c (m32r_core_signal): Replace calls to a_m32r_h_*,
+       with appropriate calls to m32rbf_*.
+
+1999-03-11  Doug Evans  <devans@casey.cygnus.com>
+
+       * arch.c,arch.h,cpu.c,cpu.h,sem.c,sem-switch.c: Rebuild.
+       * m32r-sim.h (GET_H_*,SET_H_*, except GET_H_SM): Delete.
+       * sim-if.c (sim_open): Update call to m32r_cgen_cpu_open.
+
+1999-02-25  Doug Evans  <devans@casey.cygnus.com>
+
+       * cpu.c,cpu.h: Rebuild.
+
 1999-02-09  Doug Evans  <devans@casey.cygnus.com>
 
        * Makefile.in (SIM_EXTRA_DEPS): Add m32r-desc.h, delete cpu-opc.h.
index 2caa3004649634cd9b504462de2b41814a146bab..c6da47ce9c9c854ff166f0751211a973ce78a630 100644 (file)
@@ -33,324 +33,3 @@ const MACH *sim_machs[] =
   0
 };
 
-/* Get the value of h-pc.  */
-
-USI
-a_m32r_h_pc_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      return m32rbf_h_pc_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-pc.  */
-
-void
-a_m32r_h_pc_set (SIM_CPU *current_cpu, USI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      m32rbf_h_pc_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-gr.  */
-
-SI
-a_m32r_h_gr_get (SIM_CPU *current_cpu, UINT regno)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      return m32rbf_h_gr_get (current_cpu, regno);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-gr.  */
-
-void
-a_m32r_h_gr_set (SIM_CPU *current_cpu, UINT regno, SI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      m32rbf_h_gr_set (current_cpu, regno, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-cr.  */
-
-USI
-a_m32r_h_cr_get (SIM_CPU *current_cpu, UINT regno)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      return m32rbf_h_cr_get (current_cpu, regno);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-cr.  */
-
-void
-a_m32r_h_cr_set (SIM_CPU *current_cpu, UINT regno, USI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      m32rbf_h_cr_set (current_cpu, regno, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-accum.  */
-
-DI
-a_m32r_h_accum_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      return m32rbf_h_accum_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-accum.  */
-
-void
-a_m32r_h_accum_set (SIM_CPU *current_cpu, DI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      m32rbf_h_accum_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-accums.  */
-
-DI
-a_m32r_h_accums_get (SIM_CPU *current_cpu, UINT regno)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-accums.  */
-
-void
-a_m32r_h_accums_set (SIM_CPU *current_cpu, UINT regno, DI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-cond.  */
-
-BI
-a_m32r_h_cond_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      return m32rbf_h_cond_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-cond.  */
-
-void
-a_m32r_h_cond_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      m32rbf_h_cond_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-psw.  */
-
-UQI
-a_m32r_h_psw_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      return m32rbf_h_psw_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-psw.  */
-
-void
-a_m32r_h_psw_set (SIM_CPU *current_cpu, UQI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      m32rbf_h_psw_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-bpsw.  */
-
-UQI
-a_m32r_h_bpsw_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      return m32rbf_h_bpsw_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-bpsw.  */
-
-void
-a_m32r_h_bpsw_set (SIM_CPU *current_cpu, UQI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      m32rbf_h_bpsw_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-bbpsw.  */
-
-UQI
-a_m32r_h_bbpsw_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      return m32rbf_h_bbpsw_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-bbpsw.  */
-
-void
-a_m32r_h_bbpsw_set (SIM_CPU *current_cpu, UQI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      m32rbf_h_bbpsw_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Get the value of h-lock.  */
-
-BI
-a_m32r_h_lock_get (SIM_CPU *current_cpu)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      return m32rbf_h_lock_get (current_cpu);
-#endif
-    default :
-      abort ();
-    }
-}
-
-/* Set a value for h-lock.  */
-
-void
-a_m32r_h_lock_set (SIM_CPU *current_cpu, BI newval)
-{
-  switch (STATE_ARCHITECTURE (CPU_STATE (current_cpu))->mach)
-    {
-#ifdef HAVE_CPU_M32RBF
-    case bfd_mach_m32r : 
-      m32rbf_h_lock_set (current_cpu, newval);
-      break;
-#endif
-    default :
-      abort ();
-    }
-}
-
index ace8104e0651c603d6e0a2de2ab53e1b15c20542..f5ea3b2d9c8d204bbc2586fd28fda58f34668b9a 100644 (file)
@@ -27,28 +27,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #define TARGET_BIG_ENDIAN 1
 
-/* Cover fns for register access.  */
-USI a_m32r_h_pc_get (SIM_CPU *);
-void a_m32r_h_pc_set (SIM_CPU *, USI);
-SI a_m32r_h_gr_get (SIM_CPU *, UINT);
-void a_m32r_h_gr_set (SIM_CPU *, UINT, SI);
-USI a_m32r_h_cr_get (SIM_CPU *, UINT);
-void a_m32r_h_cr_set (SIM_CPU *, UINT, USI);
-DI a_m32r_h_accum_get (SIM_CPU *);
-void a_m32r_h_accum_set (SIM_CPU *, DI);
-DI a_m32r_h_accums_get (SIM_CPU *, UINT);
-void a_m32r_h_accums_set (SIM_CPU *, UINT, DI);
-BI a_m32r_h_cond_get (SIM_CPU *);
-void a_m32r_h_cond_set (SIM_CPU *, BI);
-UQI a_m32r_h_psw_get (SIM_CPU *);
-void a_m32r_h_psw_set (SIM_CPU *, UQI);
-UQI a_m32r_h_bpsw_get (SIM_CPU *);
-void a_m32r_h_bpsw_set (SIM_CPU *, UQI);
-UQI a_m32r_h_bbpsw_get (SIM_CPU *);
-void a_m32r_h_bbpsw_set (SIM_CPU *, UQI);
-BI a_m32r_h_lock_get (SIM_CPU *);
-void a_m32r_h_lock_set (SIM_CPU *, BI);
-
 /* Enum declaration for model types.  */
 typedef enum model_type {
   MODEL_M32R_D, MODEL_TEST
index fb856f53f71938607c14eec9f39f1d0b837d45c5..f6474a08a996bd9adf6ded0e5a8ad84cc07908cd 100644 (file)
@@ -26,6 +26,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define WANT_CPU_M32RBF
 
 #include "sim-main.h"
+#include "cgen-ops.h"
 
 /* Get the value of h-pc.  */
 
@@ -91,22 +92,6 @@ m32rbf_h_accum_set (SIM_CPU *current_cpu, DI newval)
   SET_H_ACCUM (newval);
 }
 
-/* Get the value of h-accums.  */
-
-DI
-m32rbf_h_accums_get (SIM_CPU *current_cpu, UINT regno)
-{
-  return GET_H_ACCUMS (regno);
-}
-
-/* Set a value for h-accums.  */
-
-void
-m32rbf_h_accums_set (SIM_CPU *current_cpu, UINT regno, DI newval)
-{
-  SET_H_ACCUMS (regno, newval);
-}
-
 /* Get the value of h-cond.  */
 
 BI
index ccb4676e5582ceec6c0d378a435078d99ada806a..6ebe19999d3cb14426ec084f8b48c5c453369716 100644 (file)
@@ -46,20 +46,29 @@ typedef struct {
 #define SET_H_GR(a1, x) (CPU (h_gr)[a1] = (x))
   /* control registers */
   USI h_cr[16];
-/* GET_H_CR macro user-written */
-/* SET_H_CR macro user-written */
+#define GET_H_CR(index) m32rbf_h_cr_get_handler (current_cpu, index)
+#define SET_H_CR(index, x) \
+do { \
+m32rbf_h_cr_set_handler (current_cpu, (index), (x));\
+} while (0)
   /* accumulator */
   DI h_accum;
-/* GET_H_ACCUM macro user-written */
-/* SET_H_ACCUM macro user-written */
+#define GET_H_ACCUM() m32rbf_h_accum_get_handler (current_cpu)
+#define SET_H_ACCUM(x) \
+do { \
+m32rbf_h_accum_set_handler (current_cpu, (x));\
+} while (0)
   /* condition bit */
   BI h_cond;
 #define GET_H_COND() CPU (h_cond)
 #define SET_H_COND(x) (CPU (h_cond) = (x))
   /* psw part of psw */
   UQI h_psw;
-/* GET_H_PSW macro user-written */
-/* SET_H_PSW macro user-written */
+#define GET_H_PSW() m32rbf_h_psw_get_handler (current_cpu)
+#define SET_H_PSW(x) \
+do { \
+m32rbf_h_psw_set_handler (current_cpu, (x));\
+} while (0)
   /* backup psw */
   UQI h_bpsw;
 #define GET_H_BPSW() CPU (h_bpsw)
@@ -85,8 +94,6 @@ USI m32rbf_h_cr_get (SIM_CPU *, UINT);
 void m32rbf_h_cr_set (SIM_CPU *, UINT, USI);
 DI m32rbf_h_accum_get (SIM_CPU *);
 void m32rbf_h_accum_set (SIM_CPU *, DI);
-DI m32rbf_h_accums_get (SIM_CPU *, UINT);
-void m32rbf_h_accums_set (SIM_CPU *, UINT, DI);
 BI m32rbf_h_cond_get (SIM_CPU *);
 void m32rbf_h_cond_set (SIM_CPU *, BI);
 UQI m32rbf_h_psw_get (SIM_CPU *);
index 63913af680c54cf8edb5fa8d17441700a4bea3cb..8bac0ef9e836c87e9b7ecf7627b4d382a26ecd55 100644 (file)
@@ -46,6 +46,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #define FAST(fn)
 #endif
 
+/* The INSN_ prefix is not here and is instead part of the `insn' argument
+   to avoid collisions with header files (e.g. `AND' in ansidecl.h).  */
+#define IDX(insn) CONCAT2 (M32RBF_,insn)
+#define TYPE(insn) CONCAT2 (M32R_,insn)
+
 /* The instruction descriptor array.
    This is computed at runtime.  Space for it is not malloc'd to save a
    teensy bit of cpu in the decoder.  Moving it to malloc space is trivial
@@ -53,11 +58,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
    addition of instructions nor an SMP machine with different cpus).  */
 static IDESC m32rbf_insn_data[M32RBF_INSN_MAX];
 
-/* The INSN_ prefix is not here and is instead part of the `insn' argument
-   to avoid collisions with header files (e.g. `AND' in ansidecl.h).  */
-#define IDX(insn) CONCAT2 (M32RBF_,insn)
-#define TYPE(insn) CONCAT2 (M32R_,insn)
-
 /* Commas between elements are contained in the macros.
    Some of these are conditionally compiled out.  */
 
@@ -175,6 +175,9 @@ static const struct insn_sem m32rbf_insn_sem_invalid =
   VIRTUAL_INSN_X_INVALID, IDX (INSN_X_INVALID), FULL (x_invalid) FAST (x_invalid)
 };
 
+#undef FMT
+#undef FULL
+#undef FAST
 #undef IDX
 #undef TYPE
 
@@ -236,50 +239,6 @@ m32rbf_init_idesc_table (SIM_CPU *cpu)
   CPU_IDESC (cpu) = table;
 }
 
-/* Enum declaration for all instruction semantic formats.  */
-typedef enum sfmt {
-  FMT_EMPTY, FMT_ADD, FMT_ADD3, FMT_AND3
- , FMT_OR3, FMT_ADDI, FMT_ADDV, FMT_ADDV3
- , FMT_ADDX, FMT_BC8, FMT_BC24, FMT_BEQ
- , FMT_BEQZ, FMT_BL8, FMT_BL24, FMT_BRA8
- , FMT_BRA24, FMT_CMP, FMT_CMPI, FMT_DIV
- , FMT_JL, FMT_JMP, FMT_LD, FMT_LD_D
- , FMT_LDB, FMT_LDB_D, FMT_LDH, FMT_LDH_D
- , FMT_LD_PLUS, FMT_LD24, FMT_LDI8, FMT_LDI16
- , FMT_LOCK, FMT_MACHI, FMT_MULHI, FMT_MV
- , FMT_MVFACHI, FMT_MVFC, FMT_MVTACHI, FMT_MVTC
- , FMT_NOP, FMT_RAC, FMT_RTE, FMT_SETH
- , FMT_SLL3, FMT_SLLI, FMT_ST, FMT_ST_D
- , FMT_STB, FMT_STB_D, FMT_STH, FMT_STH_D
- , FMT_ST_PLUS, FMT_TRAP, FMT_UNLOCK
-} SFMT;
-
-/* The decoder uses this to record insns and direct extraction handling.  */
-
-typedef struct {
-  const IDESC *idesc;
-#ifdef __GNUC__
-  void *sfmt;
-#else
-  enum sfmt sfmt;
-#endif
-} DECODE_DESC;
-
-/* Macro to go from decode phase to extraction phase.  */
-
-#ifdef __GNUC__
-#define GOTO_EXTRACT(id) goto *(id)->sfmt
-#else
-#define GOTO_EXTRACT(id) goto extract
-#endif
-
-/* The decoder needs a slightly different computed goto switch control.  */
-#ifdef __GNUC__
-#define DECODE_SWITCH(N, X) goto *labels_##N[X];
-#else
-#define DECODE_SWITCH(N, X) switch (X)
-#endif
-
 /* Given an instruction, return a pointer to its IDESC entry.  */
 
 const IDESC *
@@ -287,370 +246,254 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
               CGEN_INSN_INT base_insn, CGEN_INSN_INT entire_insn,
               ARGBUF *abuf)
 {
-  /* Result of decoder, used by extractor.  */
-  const DECODE_DESC *idecode;
-
-  /* First decode the instruction.  */
+  /* Result of decoder.  */
+  M32RBF_INSN_TYPE itype;
 
   {
-#define I(insn) & m32rbf_insn_data[CONCAT2 (M32RBF_,insn)]
-#ifdef __GNUC__
-#define E(fmt) && case_ex_##fmt
-#else
-#define E(fmt) fmt
-#endif
     CGEN_INSN_INT insn = base_insn;
-    static const DECODE_DESC idecode_invalid = { I (INSN_X_INVALID), E (FMT_EMPTY) };
 
     {
-#ifdef __GNUC__
-      static const void *labels_0[256] = {
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_28, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && case_0_87, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && case_0_95, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_112, && case_0_113, && case_0_114, && case_0_115, 
-        && case_0_116, && case_0_117, && case_0_118, && case_0_119, 
-        && case_0_120, && case_0_121, && case_0_122, && case_0_123, 
-        && case_0_124, && case_0_125, && case_0_126, && case_0_127, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && default_0, && default_0, && default_0, && default_0, 
-        && case_0_240, && case_0_241, && case_0_242, && case_0_243, 
-        && case_0_244, && case_0_245, && case_0_246, && case_0_247, 
-        && case_0_248, && case_0_249, && case_0_250, && case_0_251, 
-        && case_0_252, && case_0_253, && case_0_254, && case_0_255, 
-      };
-#endif
-      static const DECODE_DESC insns[256] = {
-        { I (INSN_SUBV), E (FMT_ADDV) }, { I (INSN_SUBX), E (FMT_ADDX) }, 
-        { I (INSN_SUB), E (FMT_ADD) }, { I (INSN_NEG), E (FMT_MV) }, 
-        { I (INSN_CMP), E (FMT_CMP) }, { I (INSN_CMPU), E (FMT_CMP) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_ADDV), E (FMT_ADDV) }, { I (INSN_ADDX), E (FMT_ADDX) }, 
-        { I (INSN_ADD), E (FMT_ADD) }, { I (INSN_NOT), E (FMT_MV) }, 
-        { I (INSN_AND), E (FMT_ADD) }, { I (INSN_XOR), E (FMT_ADD) }, 
-        { I (INSN_OR), E (FMT_ADD) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_SRL), E (FMT_ADD) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_SRA), E (FMT_ADD) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_SLL), E (FMT_ADD) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_MUL), E (FMT_ADD) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_MV), E (FMT_MV) }, { I (INSN_MVFC), E (FMT_MVFC) }, 
-        { I (INSN_MVTC), E (FMT_MVTC) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { 0 }, { I (INSN_RTE), E (FMT_RTE) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_TRAP), E (FMT_TRAP) }, 
-        { I (INSN_STB), E (FMT_STB) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_STH), E (FMT_STH) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_ST), E (FMT_ST) }, { I (INSN_UNLOCK), E (FMT_UNLOCK) }, 
-        { I (INSN_ST_PLUS), E (FMT_ST_PLUS) }, { I (INSN_ST_MINUS), E (FMT_ST_PLUS) }, 
-        { I (INSN_LDB), E (FMT_LDB) }, { I (INSN_LDUB), E (FMT_LDB) }, 
-        { I (INSN_LDH), E (FMT_LDH) }, { I (INSN_LDUH), E (FMT_LDH) }, 
-        { I (INSN_LD), E (FMT_LD) }, { I (INSN_LOCK), E (FMT_LOCK) }, 
-        { I (INSN_LD_PLUS), E (FMT_LD_PLUS) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_MULHI), E (FMT_MULHI) }, { I (INSN_MULLO), E (FMT_MULHI) }, 
-        { I (INSN_MULWHI), E (FMT_MULHI) }, { I (INSN_MULWLO), E (FMT_MULHI) }, 
-        { I (INSN_MACHI), E (FMT_MACHI) }, { I (INSN_MACLO), E (FMT_MACHI) }, 
-        { I (INSN_MACWHI), E (FMT_MACHI) }, { I (INSN_MACWLO), E (FMT_MACHI) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_ADDI), E (FMT_ADDI) }, { I (INSN_ADDI), E (FMT_ADDI) }, 
-        { I (INSN_ADDI), E (FMT_ADDI) }, { I (INSN_ADDI), E (FMT_ADDI) }, 
-        { I (INSN_ADDI), E (FMT_ADDI) }, { I (INSN_ADDI), E (FMT_ADDI) }, 
-        { I (INSN_ADDI), E (FMT_ADDI) }, { I (INSN_ADDI), E (FMT_ADDI) }, 
-        { I (INSN_ADDI), E (FMT_ADDI) }, { I (INSN_ADDI), E (FMT_ADDI) }, 
-        { I (INSN_ADDI), E (FMT_ADDI) }, { I (INSN_ADDI), E (FMT_ADDI) }, 
-        { I (INSN_ADDI), E (FMT_ADDI) }, { I (INSN_ADDI), E (FMT_ADDI) }, 
-        { I (INSN_ADDI), E (FMT_ADDI) }, { I (INSN_ADDI), E (FMT_ADDI) }, 
-        { I (INSN_SRLI), E (FMT_SLLI) }, { I (INSN_SRLI), E (FMT_SLLI) }, 
-        { I (INSN_SRAI), E (FMT_SLLI) }, { I (INSN_SRAI), E (FMT_SLLI) }, 
-        { I (INSN_SLLI), E (FMT_SLLI) }, { I (INSN_SLLI), E (FMT_SLLI) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { 0 }, 
-        { I (INSN_RACH), E (FMT_RAC) }, { I (INSN_RAC), E (FMT_RAC) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { 0 }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_CMPI), E (FMT_CMPI) }, { I (INSN_CMPUI), E (FMT_CMPI) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_ADDV3), E (FMT_ADDV3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_ADD3), E (FMT_ADD3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_AND3), E (FMT_AND3) }, { I (INSN_XOR3), E (FMT_AND3) }, 
-        { I (INSN_OR3), E (FMT_OR3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_DIV), E (FMT_DIV) }, { I (INSN_DIVU), E (FMT_DIV) }, 
-        { I (INSN_REM), E (FMT_DIV) }, { I (INSN_REMU), E (FMT_DIV) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_SRL3), E (FMT_SLL3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_SRA3), E (FMT_SLL3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_SLL3), E (FMT_SLL3) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_LDI16), E (FMT_LDI16) }, 
-        { I (INSN_STB_D), E (FMT_STB_D) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_STH_D), E (FMT_STH_D) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_ST_D), E (FMT_ST_D) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_LDB_D), E (FMT_LDB_D) }, { I (INSN_LDUB_D), E (FMT_LDB_D) }, 
-        { I (INSN_LDH_D), E (FMT_LDH_D) }, { I (INSN_LDUH_D), E (FMT_LDH_D) }, 
-        { I (INSN_LD_D), E (FMT_LD_D) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_BEQ), E (FMT_BEQ) }, { I (INSN_BNE), E (FMT_BEQ) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_BEQZ), E (FMT_BEQZ) }, { I (INSN_BNEZ), E (FMT_BEQZ) }, 
-        { I (INSN_BLTZ), E (FMT_BEQZ) }, { I (INSN_BGEZ), E (FMT_BEQZ) }, 
-        { I (INSN_BLEZ), E (FMT_BEQZ) }, { I (INSN_BGTZ), E (FMT_BEQZ) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_SETH), E (FMT_SETH) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-        { I (INSN_LD24), E (FMT_LD24) }, { I (INSN_LD24), E (FMT_LD24) }, 
-        { I (INSN_LD24), E (FMT_LD24) }, { I (INSN_LD24), E (FMT_LD24) }, 
-        { I (INSN_LD24), E (FMT_LD24) }, { I (INSN_LD24), E (FMT_LD24) }, 
-        { I (INSN_LD24), E (FMT_LD24) }, { I (INSN_LD24), E (FMT_LD24) }, 
-        { I (INSN_LD24), E (FMT_LD24) }, { I (INSN_LD24), E (FMT_LD24) }, 
-        { I (INSN_LD24), E (FMT_LD24) }, { I (INSN_LD24), E (FMT_LD24) }, 
-        { I (INSN_LD24), E (FMT_LD24) }, { I (INSN_LD24), E (FMT_LD24) }, 
-        { I (INSN_LD24), E (FMT_LD24) }, { I (INSN_LD24), E (FMT_LD24) }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-        { 0 }, { 0 }, 
-      };
-      unsigned int val;
-      val = (((insn >> 8) & (15 << 4)) | ((insn >> 4) & (15 << 0)));
-      DECODE_SWITCH (0, val)
+      unsigned int val = (((insn >> 8) & (15 << 4)) | ((insn >> 4) & (15 << 0)));
+      switch (val)
+      {
+      case 0 : itype = M32RBF_INSN_SUBV; goto extract_fmt_addv;
+      case 1 : itype = M32RBF_INSN_SUBX; goto extract_fmt_addx;
+      case 2 : itype = M32RBF_INSN_SUB; goto extract_fmt_add;
+      case 3 : itype = M32RBF_INSN_NEG; goto extract_fmt_mv;
+      case 4 : itype = M32RBF_INSN_CMP; goto extract_fmt_cmp;
+      case 5 : itype = M32RBF_INSN_CMPU; goto extract_fmt_cmp;
+      case 8 : itype = M32RBF_INSN_ADDV; goto extract_fmt_addv;
+      case 9 : itype = M32RBF_INSN_ADDX; goto extract_fmt_addx;
+      case 10 : itype = M32RBF_INSN_ADD; goto extract_fmt_add;
+      case 11 : itype = M32RBF_INSN_NOT; goto extract_fmt_mv;
+      case 12 : itype = M32RBF_INSN_AND; goto extract_fmt_add;
+      case 13 : itype = M32RBF_INSN_XOR; goto extract_fmt_add;
+      case 14 : itype = M32RBF_INSN_OR; goto extract_fmt_add;
+      case 16 : itype = M32RBF_INSN_SRL; goto extract_fmt_add;
+      case 18 : itype = M32RBF_INSN_SRA; goto extract_fmt_add;
+      case 20 : itype = M32RBF_INSN_SLL; goto extract_fmt_add;
+      case 22 : itype = M32RBF_INSN_MUL; goto extract_fmt_add;
+      case 24 : itype = M32RBF_INSN_MV; goto extract_fmt_mv;
+      case 25 : itype = M32RBF_INSN_MVFC; goto extract_fmt_mvfc;
+      case 26 : itype = M32RBF_INSN_MVTC; goto extract_fmt_mvtc;
+      case 28 :
         {
-        CASE (0, 28) :
+          unsigned int val = (((insn >> 8) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_JL), E (FMT_JL) }, { I (INSN_JMP), E (FMT_JMP) }, 
-            };
-            unsigned int val = (((insn >> 8) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 14 : itype = M32RBF_INSN_JL; goto extract_fmt_jl;
+          case 15 : itype = M32RBF_INSN_JMP; goto extract_fmt_jmp;
+          default : itype = M32RBF_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 87) :
+        }
+      case 29 : itype = M32RBF_INSN_RTE; goto extract_fmt_rte;
+      case 31 : itype = M32RBF_INSN_TRAP; goto extract_fmt_trap;
+      case 32 : itype = M32RBF_INSN_STB; goto extract_fmt_stb;
+      case 34 : itype = M32RBF_INSN_STH; goto extract_fmt_sth;
+      case 36 : itype = M32RBF_INSN_ST; goto extract_fmt_st;
+      case 37 : itype = M32RBF_INSN_UNLOCK; goto extract_fmt_unlock;
+      case 38 : itype = M32RBF_INSN_ST_PLUS; goto extract_fmt_st_plus;
+      case 39 : itype = M32RBF_INSN_ST_MINUS; goto extract_fmt_st_plus;
+      case 40 : itype = M32RBF_INSN_LDB; goto extract_fmt_ldb;
+      case 41 : itype = M32RBF_INSN_LDUB; goto extract_fmt_ldb;
+      case 42 : itype = M32RBF_INSN_LDH; goto extract_fmt_ldh;
+      case 43 : itype = M32RBF_INSN_LDUH; goto extract_fmt_ldh;
+      case 44 : itype = M32RBF_INSN_LD; goto extract_fmt_ld;
+      case 45 : itype = M32RBF_INSN_LOCK; goto extract_fmt_lock;
+      case 46 : itype = M32RBF_INSN_LD_PLUS; goto extract_fmt_ld_plus;
+      case 48 : itype = M32RBF_INSN_MULHI; goto extract_fmt_mulhi;
+      case 49 : itype = M32RBF_INSN_MULLO; goto extract_fmt_mulhi;
+      case 50 : itype = M32RBF_INSN_MULWHI; goto extract_fmt_mulhi;
+      case 51 : itype = M32RBF_INSN_MULWLO; goto extract_fmt_mulhi;
+      case 52 : itype = M32RBF_INSN_MACHI; goto extract_fmt_machi;
+      case 53 : itype = M32RBF_INSN_MACLO; goto extract_fmt_machi;
+      case 54 : itype = M32RBF_INSN_MACWHI; goto extract_fmt_machi;
+      case 55 : itype = M32RBF_INSN_MACWLO; goto extract_fmt_machi;
+      case 64 : /* fall through */
+      case 65 : /* fall through */
+      case 66 : /* fall through */
+      case 67 : /* fall through */
+      case 68 : /* fall through */
+      case 69 : /* fall through */
+      case 70 : /* fall through */
+      case 71 : /* fall through */
+      case 72 : /* fall through */
+      case 73 : /* fall through */
+      case 74 : /* fall through */
+      case 75 : /* fall through */
+      case 76 : /* fall through */
+      case 77 : /* fall through */
+      case 78 : /* fall through */
+      case 79 : itype = M32RBF_INSN_ADDI; goto extract_fmt_addi;
+      case 80 : /* fall through */
+      case 81 : itype = M32RBF_INSN_SRLI; goto extract_fmt_slli;
+      case 82 : /* fall through */
+      case 83 : itype = M32RBF_INSN_SRAI; goto extract_fmt_slli;
+      case 84 : /* fall through */
+      case 85 : itype = M32RBF_INSN_SLLI; goto extract_fmt_slli;
+      case 87 :
+        {
+          unsigned int val = (((insn >> 0) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_MVTACHI), E (FMT_MVTACHI) }, { I (INSN_MVTACLO), E (FMT_MVTACHI) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 0) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = M32RBF_INSN_MVTACHI; goto extract_fmt_mvtachi;
+          case 1 : itype = M32RBF_INSN_MVTACLO; goto extract_fmt_mvtachi;
+          default : itype = M32RBF_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 95) :
+        }
+      case 88 : itype = M32RBF_INSN_RACH; goto extract_fmt_rac;
+      case 89 : itype = M32RBF_INSN_RAC; goto extract_fmt_rac;
+      case 95 :
+        {
+          unsigned int val = (((insn >> 0) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_MVFACHI), E (FMT_MVFACHI) }, { I (INSN_MVFACLO), E (FMT_MVFACHI) }, 
-              { I (INSN_MVFACMI), E (FMT_MVFACHI) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-            };
-            unsigned int val = (((insn >> 0) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = M32RBF_INSN_MVFACHI; goto extract_fmt_mvfachi;
+          case 1 : itype = M32RBF_INSN_MVFACLO; goto extract_fmt_mvfachi;
+          case 2 : itype = M32RBF_INSN_MVFACMI; goto extract_fmt_mvfachi;
+          default : itype = M32RBF_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 112) :
+        }
+      case 96 : /* fall through */
+      case 97 : /* fall through */
+      case 98 : /* fall through */
+      case 99 : /* fall through */
+      case 100 : /* fall through */
+      case 101 : /* fall through */
+      case 102 : /* fall through */
+      case 103 : /* fall through */
+      case 104 : /* fall through */
+      case 105 : /* fall through */
+      case 106 : /* fall through */
+      case 107 : /* fall through */
+      case 108 : /* fall through */
+      case 109 : /* fall through */
+      case 110 : /* fall through */
+      case 111 : itype = M32RBF_INSN_LDI8; goto extract_fmt_ldi8;
+      case 112 :
+        {
+          unsigned int val = (((insn >> 8) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_NOP), E (FMT_NOP) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_BC8), E (FMT_BC8) }, { I (INSN_BNC8), E (FMT_BC8) }, 
-              { I (INSN_BL8), E (FMT_BL8) }, { I (INSN_BRA8), E (FMT_BRA8) }, 
-            };
-            unsigned int val = (((insn >> 8) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 0 : itype = M32RBF_INSN_NOP; goto extract_fmt_nop;
+          case 12 : itype = M32RBF_INSN_BC8; goto extract_fmt_bc8;
+          case 13 : itype = M32RBF_INSN_BNC8; goto extract_fmt_bc8;
+          case 14 : itype = M32RBF_INSN_BL8; goto extract_fmt_bl8;
+          case 15 : itype = M32RBF_INSN_BRA8; goto extract_fmt_bra8;
+          default : itype = M32RBF_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 113) : /* fall through */
-        CASE (0, 114) : /* fall through */
-        CASE (0, 115) : /* fall through */
-        CASE (0, 116) : /* fall through */
-        CASE (0, 117) : /* fall through */
-        CASE (0, 118) : /* fall through */
-        CASE (0, 119) : /* fall through */
-        CASE (0, 120) : /* fall through */
-        CASE (0, 121) : /* fall through */
-        CASE (0, 122) : /* fall through */
-        CASE (0, 123) : /* fall through */
-        CASE (0, 124) : /* fall through */
-        CASE (0, 125) : /* fall through */
-        CASE (0, 126) : /* fall through */
-        CASE (0, 127) :
+        }
+      case 113 : /* fall through */
+      case 114 : /* fall through */
+      case 115 : /* fall through */
+      case 116 : /* fall through */
+      case 117 : /* fall through */
+      case 118 : /* fall through */
+      case 119 : /* fall through */
+      case 120 : /* fall through */
+      case 121 : /* fall through */
+      case 122 : /* fall through */
+      case 123 : /* fall through */
+      case 124 : /* fall through */
+      case 125 : /* fall through */
+      case 126 : /* fall through */
+      case 127 :
+        {
+          unsigned int val = (((insn >> 8) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_BC8), E (FMT_BC8) }, { I (INSN_BNC8), E (FMT_BC8) }, 
-              { I (INSN_BL8), E (FMT_BL8) }, { I (INSN_BRA8), E (FMT_BRA8) }, 
-            };
-            unsigned int val = (((insn >> 8) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 12 : itype = M32RBF_INSN_BC8; goto extract_fmt_bc8;
+          case 13 : itype = M32RBF_INSN_BNC8; goto extract_fmt_bc8;
+          case 14 : itype = M32RBF_INSN_BL8; goto extract_fmt_bl8;
+          case 15 : itype = M32RBF_INSN_BRA8; goto extract_fmt_bra8;
+          default : itype = M32RBF_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        CASE (0, 240) : /* fall through */
-        CASE (0, 241) : /* fall through */
-        CASE (0, 242) : /* fall through */
-        CASE (0, 243) : /* fall through */
-        CASE (0, 244) : /* fall through */
-        CASE (0, 245) : /* fall through */
-        CASE (0, 246) : /* fall through */
-        CASE (0, 247) : /* fall through */
-        CASE (0, 248) : /* fall through */
-        CASE (0, 249) : /* fall through */
-        CASE (0, 250) : /* fall through */
-        CASE (0, 251) : /* fall through */
-        CASE (0, 252) : /* fall through */
-        CASE (0, 253) : /* fall through */
-        CASE (0, 254) : /* fall through */
-        CASE (0, 255) :
+        }
+      case 132 : itype = M32RBF_INSN_CMPI; goto extract_fmt_cmpi;
+      case 133 : itype = M32RBF_INSN_CMPUI; goto extract_fmt_cmpi;
+      case 136 : itype = M32RBF_INSN_ADDV3; goto extract_fmt_addv3;
+      case 138 : itype = M32RBF_INSN_ADD3; goto extract_fmt_add3;
+      case 140 : itype = M32RBF_INSN_AND3; goto extract_fmt_and3;
+      case 141 : itype = M32RBF_INSN_XOR3; goto extract_fmt_and3;
+      case 142 : itype = M32RBF_INSN_OR3; goto extract_fmt_or3;
+      case 144 : itype = M32RBF_INSN_DIV; goto extract_fmt_div;
+      case 145 : itype = M32RBF_INSN_DIVU; goto extract_fmt_div;
+      case 146 : itype = M32RBF_INSN_REM; goto extract_fmt_div;
+      case 147 : itype = M32RBF_INSN_REMU; goto extract_fmt_div;
+      case 152 : itype = M32RBF_INSN_SRL3; goto extract_fmt_sll3;
+      case 154 : itype = M32RBF_INSN_SRA3; goto extract_fmt_sll3;
+      case 156 : itype = M32RBF_INSN_SLL3; goto extract_fmt_sll3;
+      case 159 : itype = M32RBF_INSN_LDI16; goto extract_fmt_ldi16;
+      case 160 : itype = M32RBF_INSN_STB_D; goto extract_fmt_stb_d;
+      case 162 : itype = M32RBF_INSN_STH_D; goto extract_fmt_sth_d;
+      case 164 : itype = M32RBF_INSN_ST_D; goto extract_fmt_st_d;
+      case 168 : itype = M32RBF_INSN_LDB_D; goto extract_fmt_ldb_d;
+      case 169 : itype = M32RBF_INSN_LDUB_D; goto extract_fmt_ldb_d;
+      case 170 : itype = M32RBF_INSN_LDH_D; goto extract_fmt_ldh_d;
+      case 171 : itype = M32RBF_INSN_LDUH_D; goto extract_fmt_ldh_d;
+      case 172 : itype = M32RBF_INSN_LD_D; goto extract_fmt_ld_d;
+      case 176 : itype = M32RBF_INSN_BEQ; goto extract_fmt_beq;
+      case 177 : itype = M32RBF_INSN_BNE; goto extract_fmt_beq;
+      case 184 : itype = M32RBF_INSN_BEQZ; goto extract_fmt_beqz;
+      case 185 : itype = M32RBF_INSN_BNEZ; goto extract_fmt_beqz;
+      case 186 : itype = M32RBF_INSN_BLTZ; goto extract_fmt_beqz;
+      case 187 : itype = M32RBF_INSN_BGEZ; goto extract_fmt_beqz;
+      case 188 : itype = M32RBF_INSN_BLEZ; goto extract_fmt_beqz;
+      case 189 : itype = M32RBF_INSN_BGTZ; goto extract_fmt_beqz;
+      case 220 : itype = M32RBF_INSN_SETH; goto extract_fmt_seth;
+      case 224 : /* fall through */
+      case 225 : /* fall through */
+      case 226 : /* fall through */
+      case 227 : /* fall through */
+      case 228 : /* fall through */
+      case 229 : /* fall through */
+      case 230 : /* fall through */
+      case 231 : /* fall through */
+      case 232 : /* fall through */
+      case 233 : /* fall through */
+      case 234 : /* fall through */
+      case 235 : /* fall through */
+      case 236 : /* fall through */
+      case 237 : /* fall through */
+      case 238 : /* fall through */
+      case 239 : itype = M32RBF_INSN_LD24; goto extract_fmt_ld24;
+      case 240 : /* fall through */
+      case 241 : /* fall through */
+      case 242 : /* fall through */
+      case 243 : /* fall through */
+      case 244 : /* fall through */
+      case 245 : /* fall through */
+      case 246 : /* fall through */
+      case 247 : /* fall through */
+      case 248 : /* fall through */
+      case 249 : /* fall through */
+      case 250 : /* fall through */
+      case 251 : /* fall through */
+      case 252 : /* fall through */
+      case 253 : /* fall through */
+      case 254 : /* fall through */
+      case 255 :
+        {
+          unsigned int val = (((insn >> 8) & (15 << 0)));
+          switch (val)
           {
-            static const DECODE_DESC insns[16] = {
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) }, 
-              { I (INSN_BC24), E (FMT_BC24) }, { I (INSN_BNC24), E (FMT_BC24) }, 
-              { I (INSN_BL24), E (FMT_BL24) }, { I (INSN_BRA24), E (FMT_BRA24) }, 
-            };
-            unsigned int val = (((insn >> 8) & (15 << 0)));
-            idecode = &insns[val];
-            GOTO_EXTRACT (idecode);
+          case 12 : itype = M32RBF_INSN_BC24; goto extract_fmt_bc24;
+          case 13 : itype = M32RBF_INSN_BNC24; goto extract_fmt_bc24;
+          case 14 : itype = M32RBF_INSN_BL24; goto extract_fmt_bl24;
+          case 15 : itype = M32RBF_INSN_BRA24; goto extract_fmt_bra24;
+          default : itype = M32RBF_INSN_X_INVALID; goto extract_fmt_empty;
           }
-        DEFAULT (0) :
-          idecode = &insns[val];
-          GOTO_EXTRACT (idecode);
         }
-      ENDSWITCH (0)
+      default : itype = M32RBF_INSN_X_INVALID; goto extract_fmt_empty;
+      }
     }
-#undef I
-#undef E
   }
 
   /* The instruction has been decoded, now extract the fields.  */
 
- extract:
-  {
-#ifndef __GNUC__
-    switch (idecode->sfmt)
-#endif
-      {
-
-  CASE (ex, FMT_EMPTY) :
+ extract_fmt_empty:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_empty.f
   EXTRACT_IFMT_EMPTY_VARS /* */
@@ -661,11 +504,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_empty", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADD) :
extract_fmt_add:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_add.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -687,11 +531,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADD3) :
extract_fmt_add3:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_add3.f
   EXTRACT_IFMT_ADD3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -713,11 +558,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_AND3) :
extract_fmt_and3:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_and3.f
   EXTRACT_IFMT_AND3_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
@@ -739,11 +585,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_OR3) :
extract_fmt_or3:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_or3.f
   EXTRACT_IFMT_OR3_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
@@ -765,11 +612,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADDI) :
extract_fmt_addi:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_addi.f
   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-r1 f-simm8 */
@@ -790,11 +638,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADDV) :
extract_fmt_addv:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_addv.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -816,11 +665,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADDV3) :
extract_fmt_addv3:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_addv3.f
   EXTRACT_IFMT_ADDV3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -842,11 +692,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ADDX) :
extract_fmt_addx:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_addx.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -868,11 +719,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BC8) :
extract_fmt_bc8:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bc8.f
   EXTRACT_IFMT_BC8_VARS /* f-op1 f-r1 f-disp8 */
@@ -891,11 +743,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BC24) :
extract_fmt_bc24:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bc24.f
   EXTRACT_IFMT_BC24_VARS /* f-op1 f-r1 f-disp24 */
@@ -914,11 +767,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BEQ) :
extract_fmt_beq:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_beq.f
   EXTRACT_IFMT_BEQ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
@@ -941,11 +795,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BEQZ) :
extract_fmt_beqz:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_beqz.f
   EXTRACT_IFMT_BEQZ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
@@ -966,11 +821,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BL8) :
extract_fmt_bl8:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bl8.f
   EXTRACT_IFMT_BC8_VARS /* f-op1 f-r1 f-disp8 */
@@ -990,11 +846,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BL24) :
extract_fmt_bl24:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bl24.f
   EXTRACT_IFMT_BC24_VARS /* f-op1 f-r1 f-disp24 */
@@ -1014,11 +871,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BRA8) :
extract_fmt_bra8:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bra8.f
   EXTRACT_IFMT_BC8_VARS /* f-op1 f-r1 f-disp8 */
@@ -1037,11 +895,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_BRA24) :
extract_fmt_bra24:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_bra24.f
   EXTRACT_IFMT_BC24_VARS /* f-op1 f-r1 f-disp24 */
@@ -1060,11 +919,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMP) :
extract_fmt_cmp:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_cmp.f
   EXTRACT_IFMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1085,11 +945,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_CMPI) :
extract_fmt_cmpi:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_cmpi.f
   EXTRACT_IFMT_CMPI_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -1109,11 +970,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_DIV) :
extract_fmt_div:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_div.f
   EXTRACT_IFMT_DIV_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -1135,11 +997,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_JL) :
extract_fmt_jl:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_jl.f
   EXTRACT_IFMT_JL_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1160,11 +1023,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_JMP) :
extract_fmt_jmp:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_jmp.f
   EXTRACT_IFMT_JL_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1184,11 +1048,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD) :
extract_fmt_ld:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_ld.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1209,11 +1074,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD_D) :
extract_fmt_ld_d:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_ld_d.f
   EXTRACT_IFMT_ADD3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -1235,11 +1101,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDB) :
extract_fmt_ldb:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_ldb.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1260,11 +1127,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDB_D) :
extract_fmt_ldb_d:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_ldb_d.f
   EXTRACT_IFMT_ADD3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -1286,11 +1154,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDH) :
extract_fmt_ldh:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_ldh.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1311,11 +1180,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDH_D) :
extract_fmt_ldh_d:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_ldh_d.f
   EXTRACT_IFMT_ADD3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -1337,11 +1207,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD_PLUS) :
extract_fmt_ld_plus:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_ld_plus.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1363,11 +1234,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LD24) :
extract_fmt_ld24:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_ld24.f
   EXTRACT_IFMT_LD24_VARS /* f-op1 f-r1 f-uimm24 */
@@ -1387,11 +1259,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDI8) :
extract_fmt_ldi8:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_ldi8.f
   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-r1 f-simm8 */
@@ -1411,11 +1284,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LDI16) :
extract_fmt_ldi16:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_ldi16.f
   EXTRACT_IFMT_LDI16_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -1435,11 +1309,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_LOCK) :
extract_fmt_lock:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_lock.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1460,11 +1335,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MACHI) :
extract_fmt_machi:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_machi.f
   EXTRACT_IFMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1485,11 +1361,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MULHI) :
extract_fmt_mulhi:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_mulhi.f
   EXTRACT_IFMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1510,11 +1387,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MV) :
extract_fmt_mv:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_mv.f
   EXTRACT_IFMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1535,11 +1413,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MVFACHI) :
extract_fmt_mvfachi:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_mvfachi.f
   EXTRACT_IFMT_MVFACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1558,11 +1437,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MVFC) :
extract_fmt_mvfc:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_mvfc.f
   EXTRACT_IFMT_MVFC_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1582,11 +1462,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MVTACHI) :
extract_fmt_mvtachi:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_mvtachi.f
   EXTRACT_IFMT_MVTACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1605,11 +1486,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_MVTC) :
extract_fmt_mvtc:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_mvtc.f
   EXTRACT_IFMT_MVTC_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1629,11 +1511,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_NOP) :
extract_fmt_nop:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_nop.f
   EXTRACT_IFMT_NOP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1644,11 +1527,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_nop", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_RAC) :
extract_fmt_rac:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_rac.f
   EXTRACT_IFMT_NOP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1659,11 +1543,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_rac", (char *) 0));
 
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_RTE) :
extract_fmt_rte:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_rte.f
   EXTRACT_IFMT_NOP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1681,11 +1566,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_SETH) :
extract_fmt_seth:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_seth.f
   EXTRACT_IFMT_SETH_VARS /* f-op1 f-r1 f-op2 f-r2 f-hi16 */
@@ -1705,11 +1591,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_SLL3) :
extract_fmt_sll3:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_sll3.f
   EXTRACT_IFMT_ADDV3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -1731,11 +1618,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_SLLI) :
extract_fmt_slli:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_slli.f
   EXTRACT_IFMT_SLLI_VARS /* f-op1 f-r1 f-shift-op2 f-uimm5 */
@@ -1756,11 +1644,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST) :
extract_fmt_st:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_st.f
   EXTRACT_IFMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1781,11 +1670,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST_D) :
extract_fmt_st_d:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_st_d.f
   EXTRACT_IFMT_ST_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -1807,11 +1697,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STB) :
extract_fmt_stb:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_stb.f
   EXTRACT_IFMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1832,11 +1723,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STB_D) :
extract_fmt_stb_d:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_stb_d.f
   EXTRACT_IFMT_ST_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -1858,11 +1750,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STH) :
extract_fmt_sth:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_sth.f
   EXTRACT_IFMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1883,11 +1776,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_STH_D) :
extract_fmt_sth_d:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_sth_d.f
   EXTRACT_IFMT_ST_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
@@ -1909,11 +1803,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_ST_PLUS) :
extract_fmt_st_plus:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_st_plus.f
   EXTRACT_IFMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1935,11 +1830,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_TRAP) :
extract_fmt_trap:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.cti.fields.fmt_trap.f
   EXTRACT_IFMT_TRAP_VARS /* f-op1 f-r1 f-op2 f-uimm4 */
@@ -1958,11 +1854,12 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
+    return idesc;
   }
 
 CASE (ex, FMT_UNLOCK) :
extract_fmt_unlock:
   {
+    const IDESC *idesc = &m32rbf_insn_data[itype];
     CGEN_INSN_INT insn = entire_insn;
 #define FLD(f) abuf->fields.fmt_unlock.f
   EXTRACT_IFMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
@@ -1983,14 +1880,7 @@ m32rbf_decode (SIM_CPU *current_cpu, IADDR pc,
     }
 #endif
 #undef FLD
-  BREAK (ex);
-  }
-
-
-      }
-    ENDSWITCH (ex)
-
+    return idesc;
   }
 
-  return idecode->idesc;
 }
index d706869ad3b84587cdfbd3ca0f43fbc91e0e8e07..032c8e711466b48d31837c95f689f16e7bd2e9b4 100644 (file)
@@ -32,10 +32,8 @@ device m32r_devices;
 int
 device_io_read_buffer (device *me, void *source, int space,
                       address_word addr, unsigned nr_bytes,
-                      SIM_CPU *cpu, sim_cia cia)
+                      SIM_DESC sd, SIM_CPU *cpu, sim_cia cia)
 {
-  SIM_DESC sd = CPU_STATE (cpu);
-
   if (STATE_ENVIRONMENT (sd) != OPERATING_ENVIRONMENT)
     return nr_bytes;
 
@@ -70,10 +68,8 @@ device_io_read_buffer (device *me, void *source, int space,
 int
 device_io_write_buffer (device *me, const void *source, int space,
                        address_word addr, unsigned nr_bytes,
-                       SIM_CPU *cpu, sim_cia cia)
+                       SIM_DESC sd, SIM_CPU *cpu, sim_cia cia)
 {
-  SIM_DESC sd = CPU_STATE (cpu);
-
 #if WITH_SCACHE
   /* MSPR support is deprecated but is kept in for upward compatibility
      with existing overlay support.  */
@@ -105,4 +101,7 @@ device_io_write_buffer (device *me, const void *source, int space,
   return nr_bytes;
 }
 
-void device_error () {}
+void
+device_error (device *me, char *message, ...)
+{
+}
index 1dd1878ccd5eb31a0bdbe01ef6a1a7ec7eeed367..d0fae5eba2a6207c5c51762ac962ebc5b0419136 100644 (file)
@@ -41,26 +41,19 @@ extern int m32r_decode_gdb_ctrl_regnum (int);
    FIXME: Eventually move to cgen.  */
 #define GET_H_SM() ((CPU (h_psw) & 0x80) != 0)
 
+extern SI a_m32r_h_gr_get (SIM_CPU *, UINT);
+extern void a_m32r_h_gr_set (SIM_CPU *, UINT, SI);
+extern USI a_m32r_h_cr_get (SIM_CPU *, UINT);
+extern void a_m32r_h_cr_set (SIM_CPU *, UINT, USI);
+
 extern USI m32rbf_h_cr_get_handler (SIM_CPU *, UINT);
 extern void m32rbf_h_cr_set_handler (SIM_CPU *, UINT, USI);
-#define GET_H_CR(regno) \
-  XCONCAT2 (WANT_CPU,_h_cr_get_handler) (current_cpu, (regno))
-#define SET_H_CR(regno, val) \
-  XCONCAT2 (WANT_CPU,_h_cr_set_handler) (current_cpu, (regno), (val))
 
 extern UQI m32rbf_h_psw_get_handler (SIM_CPU *);
 extern void m32rbf_h_psw_set_handler (SIM_CPU *, UQI);
-#define GET_H_PSW() \
-  XCONCAT2 (WANT_CPU,_h_psw_get_handler) (current_cpu)
-#define SET_H_PSW(val) \
-  XCONCAT2 (WANT_CPU,_h_psw_set_handler) (current_cpu, (val))
 
 extern DI m32rbf_h_accum_get_handler (SIM_CPU *);
 extern void m32rbf_h_accum_set_handler (SIM_CPU *, DI);
-#define GET_H_ACCUM() \
-  XCONCAT2 (WANT_CPU,_h_accum_get_handler) (current_cpu)
-#define SET_H_ACCUM(val) \
-  XCONCAT2 (WANT_CPU,_h_accum_set_handler) (current_cpu, (val))
 
 \f
 /* Misc. profile data.  */
@@ -189,7 +182,7 @@ do { \
 
 /* Start address and length of all device support.  */
 #define M32R_DEVICE_ADDR       0xff000000
-#define M32R_DEVICE_LEN                0x00ffffff
+#define M32R_DEVICE_LEN                0x01000000
 
 /* sim_core_attach device argument.  */
 extern device m32r_devices;
index 13e71e632025d9b1fe0459f4296cb712f24c8419..3e5e4aaf7a8aed511fd59caca7fd5c68ed03717f 100644 (file)
@@ -48,6 +48,8 @@ m32r_decode_gdb_ctrl_regnum (int gdb_regnum)
 int
 m32rbf_fetch_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len)
 {
+  int mach = MACH_NUM (CPU_MACH (current_cpu));
+
   if (rn < 16)
     SETTWI (buf, a_m32r_h_gr_get (current_cpu, rn));
   else
@@ -64,13 +66,22 @@ m32rbf_fetch_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len
                                      m32r_decode_gdb_ctrl_regnum (rn)));
        break;
       case PC_REGNUM :
-       SETTWI (buf, a_m32r_h_pc_get (current_cpu));
+       if (mach == MACH_M32R)
+         SETTWI (buf, m32rbf_h_pc_get (current_cpu));
+       else
+         SETTWI (buf, m32rxf_h_pc_get (current_cpu));
        break;
       case ACCL_REGNUM :
-       SETTWI (buf, GETLODI (a_m32r_h_accum_get (current_cpu)));
+       if (mach == MACH_M32R)
+         SETTWI (buf, GETLODI (m32rbf_h_accum_get (current_cpu)));
+       else
+         SETTWI (buf, GETLODI (m32rxf_h_accum_get (current_cpu)));
        break;
       case ACCH_REGNUM :
-       SETTWI (buf, GETHIDI (a_m32r_h_accum_get (current_cpu)));
+       if (mach == MACH_M32R)
+         SETTWI (buf, GETHIDI (m32rbf_h_accum_get (current_cpu)));
+       else
+         SETTWI (buf, GETHIDI (m32rxf_h_accum_get (current_cpu)));
        break;
       default :
        return 0;
@@ -84,6 +95,8 @@ m32rbf_fetch_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len
 int
 m32rbf_store_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len)
 {
+  int mach = MACH_NUM (CPU_MACH (current_cpu));
+
   if (rn < 16)
     a_m32r_h_gr_set (current_cpu, rn, GETTWI (buf));
   else
@@ -101,20 +114,37 @@ m32rbf_store_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len
                         GETTWI (buf));
        break;
       case PC_REGNUM :
-       a_m32r_h_pc_set (current_cpu, GETTWI (buf));
+       if (mach == MACH_M32R)
+         m32rbf_h_pc_set (current_cpu, GETTWI (buf));
+       else
+         m32rxf_h_pc_set (current_cpu, GETTWI (buf));
        break;
       case ACCL_REGNUM :
        {
-         DI val = a_m32r_h_accum_get (current_cpu);
+         DI val;
+         if (mach == MACH_M32R)
+           val = m32rbf_h_accum_get (current_cpu);
+         else
+           val = m32rxf_h_accum_get (current_cpu);
          SETLODI (val, GETTWI (buf));
-         a_m32r_h_accum_set (current_cpu, val);
+         if (mach == MACH_M32R)
+           m32rbf_h_accum_set (current_cpu, val);
+         else
+           m32rxf_h_accum_set (current_cpu, val);
          break;
        }
       case ACCH_REGNUM :
        {
-         DI val = a_m32r_h_accum_get (current_cpu);
+         DI val;
+         if (mach == MACH_M32R)
+           val = m32rbf_h_accum_get (current_cpu);
+         else
+           val = m32rxf_h_accum_get (current_cpu);
          SETHIDI (val, GETTWI (buf));
-         a_m32r_h_accum_set (current_cpu, val);
+         if (mach == MACH_M32R)
+           m32rbf_h_accum_set (current_cpu, val);
+         else
+           m32rxf_h_accum_set (current_cpu, val);
          break;
        }
       default :
@@ -124,6 +154,84 @@ m32rbf_store_register (SIM_CPU *current_cpu, int rn, unsigned char *buf, int len
   return -1; /*FIXME*/
 }
 \f
+/* Cover fns for mach independent register accesses.  */
+
+SI
+a_m32r_h_gr_get (SIM_CPU *current_cpu, UINT regno)
+{
+  switch (MACH_NUM (CPU_MACH (current_cpu)))
+    {
+#ifdef HAVE_CPU_M32RBF
+    case MACH_M32R : 
+      return m32rbf_h_gr_get (current_cpu, regno);
+#endif
+#ifdef HAVE_CPU_M32RXF
+    case MACH_M32RX : 
+      return m32rxf_h_gr_get (current_cpu, regno);
+#endif
+    default :
+      abort ();
+    }
+}
+
+void
+a_m32r_h_gr_set (SIM_CPU *current_cpu, UINT regno, SI newval)
+{
+  switch (MACH_NUM (CPU_MACH (current_cpu)))
+    {
+#ifdef HAVE_CPU_M32RBF
+    case MACH_M32R : 
+      m32rbf_h_gr_set (current_cpu, regno, newval);
+      break;
+#endif
+#ifdef HAVE_CPU_M32RXF
+    case MACH_M32RX : 
+      m32rxf_h_gr_set (current_cpu, regno, newval);
+      break;
+#endif
+    default :
+      abort ();
+    }
+}
+
+USI
+a_m32r_h_cr_get (SIM_CPU *current_cpu, UINT regno)
+{
+  switch (MACH_NUM (CPU_MACH (current_cpu)))
+    {
+#ifdef HAVE_CPU_M32RBF
+    case MACH_M32R : 
+      return m32rbf_h_cr_get (current_cpu, regno);
+#endif
+#ifdef HAVE_CPU_M32RXF
+    case MACH_M32RX : 
+      return m32rxf_h_cr_get (current_cpu, regno);
+#endif
+    default :
+      abort ();
+    }
+}
+
+void
+a_m32r_h_cr_set (SIM_CPU *current_cpu, UINT regno, USI newval)
+{
+  switch (MACH_NUM (CPU_MACH (current_cpu)))
+    {
+#ifdef HAVE_CPU_M32RBF
+    case MACH_M32R : 
+      m32rbf_h_cr_set (current_cpu, regno, newval);
+      break;
+#endif
+#ifdef HAVE_CPU_M32RXF
+    case MACH_M32RX : 
+      m32rxf_h_cr_set (current_cpu, regno, newval);
+      break;
+#endif
+    default :
+      abort ();
+    }
+}
+\f
 USI
 m32rbf_h_cr_get_handler (SIM_CPU *current_cpu, UINT cr)
 {
index 8e0454e786fa8182f138860a94d02744619fb8bd..e82881e0eec9ee628ecc787355613f0c60fc2024 100644 (file)
@@ -4160,7 +4160,7 @@ m32r_init_cpu (SIM_CPU *cpu)
 
 const MACH m32r_mach =
 {
-  "m32r", "m32r",
+  "m32r", "m32r", MACH_M32R,
   32, 32, & m32r_models[0], & m32rbf_imp_properties,
   m32r_init_cpu,
   m32rbf_prepare_run
index b729074e1499a3ff885c40048fe4ad97abf7c52a..673b83680e25097f3a4bafe692aa7a7d025bd2be 100644 (file)
@@ -508,8 +508,8 @@ SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  BI temp1;SI temp0;
+{
+  SI temp0;BI temp1;
   temp0 = ADDSI (* FLD (i_dr), * FLD (i_sr));
   temp1 = ADDOFSI (* FLD (i_dr), * FLD (i_sr), 0);
   {
@@ -522,7 +522,7 @@ do {
     CPU (h_cond) = opval;
     TRACE_RESULT (current_cpu, abuf, "condbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -537,8 +537,8 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  BI temp1;SI temp0;
+{
+  SI temp0;BI temp1;
   temp0 = ADDSI (* FLD (i_sr), FLD (f_simm16));
   temp1 = ADDOFSI (* FLD (i_sr), FLD (f_simm16), 0);
   {
@@ -551,7 +551,7 @@ do {
     CPU (h_cond) = opval;
     TRACE_RESULT (current_cpu, abuf, "condbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -566,8 +566,8 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  BI temp1;SI temp0;
+{
+  SI temp0;BI temp1;
   temp0 = ADDCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
   temp1 = ADDCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
   {
@@ -580,7 +580,7 @@ do {
     CPU (h_cond) = opval;
     TRACE_RESULT (current_cpu, abuf, "condbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -821,7 +821,7 @@ if (NESI (* FLD (i_src2), 0)) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ADDSI (ANDSI (pc, -4), 4);
     CPU (h_gr[((UINT) 14)]) = opval;
@@ -832,7 +832,7 @@ do {
     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -849,7 +849,7 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   {
     SI opval = ADDSI (pc, 4);
     CPU (h_gr[((UINT) 14)]) = opval;
@@ -860,7 +860,7 @@ do {
     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -1162,8 +1162,8 @@ if (NESI (* FLD (i_sr), 0)) {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  USI temp1;SI temp0;
+{
+  SI temp0;USI temp1;
   temp0 = ADDSI (ANDSI (pc, -4), 4);
   temp1 = ANDSI (* FLD (i_sr), -4);
   {
@@ -1176,7 +1176,7 @@ do {
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -1403,8 +1403,8 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  SI temp1;SI temp0;
+{
+  SI temp0;SI temp1;
   temp0 = GETMEMSI (current_cpu, pc, * FLD (i_sr));
   temp1 = ADDSI (* FLD (i_sr), 4);
   {
@@ -1417,7 +1417,7 @@ do {
     * FLD (i_sr) = opval;
     TRACE_RESULT (current_cpu, abuf, "sr", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1489,18 +1489,18 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = 1;
     CPU (h_lock) = opval;
-    TRACE_RESULT (current_cpu, abuf, "lock-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
     * FLD (i_dr) = opval;
     TRACE_RESULT (current_cpu, abuf, "dr", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1891,7 +1891,7 @@ PROFILE_COUNT_FILLNOPS (current_cpu, abuf->addr);
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   DI tmp_tmp1;
   tmp_tmp1 = SLLDI (GET_H_ACCUM (), 1);
   tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 32768));
@@ -1900,7 +1900,7 @@ do {
     SET_H_ACCUM (opval);
     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1915,7 +1915,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   DI tmp_tmp1;
   tmp_tmp1 = ANDDI (GET_H_ACCUM (), MAKEDI (16777215, 0xffffffff));
 if (ANDIF (GEDI (tmp_tmp1, MAKEDI (16383, 0x80000000)), LEDI (tmp_tmp1, MAKEDI (8388607, 0xffffffff)))) {
@@ -1933,7 +1933,7 @@ if (ANDIF (GEDI (tmp_tmp1, MAKEDI (8388608, 0)), LEDI (tmp_tmp1, MAKEDI (1676083
     SET_H_ACCUM (opval);
     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -1949,7 +1949,7 @@ if (ANDIF (GEDI (tmp_tmp1, MAKEDI (8388608, 0)), LEDI (tmp_tmp1, MAKEDI (1676083
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = ANDSI (GET_H_CR (((UINT) 6)), -4);
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
@@ -1963,14 +1963,14 @@ do {
   {
     UQI opval = CPU (h_bpsw);
     SET_H_PSW (opval);
-    TRACE_RESULT (current_cpu, abuf, "psw-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
   }
   {
     UQI opval = CPU (h_bbpsw);
     CPU (h_bpsw) = opval;
-    TRACE_RESULT (current_cpu, abuf, "bpsw-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -2290,7 +2290,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_new_src2;
   tmp_new_src2 = ADDSI (* FLD (i_src2), 4);
   {
@@ -2303,7 +2303,7 @@ do {
     * FLD (i_src2) = opval;
     TRACE_RESULT (current_cpu, abuf, "src2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2318,7 +2318,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_new_src2;
   tmp_new_src2 = SUBSI (* FLD (i_src2), 4);
   {
@@ -2331,7 +2331,7 @@ do {
     * FLD (i_src2) = opval;
     TRACE_RESULT (current_cpu, abuf, "src2", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2365,8 +2365,8 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  BI temp1;SI temp0;
+{
+  SI temp0;BI temp1;
   temp0 = SUBSI (* FLD (i_dr), * FLD (i_sr));
   temp1 = SUBOFSI (* FLD (i_dr), * FLD (i_sr), 0);
   {
@@ -2379,7 +2379,7 @@ do {
     CPU (h_cond) = opval;
     TRACE_RESULT (current_cpu, abuf, "condbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2394,8 +2394,8 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  BI temp1;SI temp0;
+{
+  SI temp0;BI temp1;
   temp0 = SUBCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
   temp1 = SUBCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
   {
@@ -2408,7 +2408,7 @@ do {
     CPU (h_cond) = opval;
     TRACE_RESULT (current_cpu, abuf, "condbit", 'x', opval);
   }
-} while (0);
+}
 
 #undef FLD
 }
@@ -2424,7 +2424,7 @@ do {
   SEM_BRANCH_INIT
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = GET_H_CR (((UINT) 6));
     SET_H_CR (((UINT) 14), opval);
@@ -2438,24 +2438,24 @@ do {
   {
     UQI opval = CPU (h_bpsw);
     CPU (h_bbpsw) = opval;
-    TRACE_RESULT (current_cpu, abuf, "bbpsw-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "bbpsw", 'x', opval);
   }
   {
     UQI opval = GET_H_PSW ();
     CPU (h_bpsw) = opval;
-    TRACE_RESULT (current_cpu, abuf, "bpsw-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
   }
   {
     UQI opval = ANDQI (GET_H_PSW (), 128);
     SET_H_PSW (opval);
-    TRACE_RESULT (current_cpu, abuf, "psw-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
   }
   {
     SI opval = m32r_trap (current_cpu, pc, FLD (f_uimm4));
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
 #undef FLD
@@ -2471,7 +2471,7 @@ do {
   IADDR UNUSED pc = abuf->addr;
   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (CPU (h_lock)) {
   {
     SI opval = * FLD (i_src1);
@@ -2483,9 +2483,9 @@ if (CPU (h_lock)) {
   {
     BI opval = 0;
     CPU (h_lock) = opval;
-    TRACE_RESULT (current_cpu, abuf, "lock-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
 #undef FLD
index 62fe70c4a226755e5af2250720395a06c5d24a41..03b0a6fc6c3e35d5aed1f3d7ba276dea39decdbe 100644 (file)
@@ -380,8 +380,8 @@ SEM_FN_NAME (m32rbf,addv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  BI temp1;SI temp0;
+{
+  SI temp0;BI temp1;
   temp0 = ADDSI (* FLD (i_dr), * FLD (i_sr));
   temp1 = ADDOFSI (* FLD (i_dr), * FLD (i_sr), 0);
   {
@@ -394,7 +394,7 @@ do {
     CPU (h_cond) = opval;
     TRACE_RESULT (current_cpu, abuf, "condbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -411,8 +411,8 @@ SEM_FN_NAME (m32rbf,addv3) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
-  BI temp1;SI temp0;
+{
+  SI temp0;BI temp1;
   temp0 = ADDSI (* FLD (i_sr), FLD (f_simm16));
   temp1 = ADDOFSI (* FLD (i_sr), FLD (f_simm16), 0);
   {
@@ -425,7 +425,7 @@ do {
     CPU (h_cond) = opval;
     TRACE_RESULT (current_cpu, abuf, "condbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -442,8 +442,8 @@ SEM_FN_NAME (m32rbf,addx) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  BI temp1;SI temp0;
+{
+  SI temp0;BI temp1;
   temp0 = ADDCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
   temp1 = ADDCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
   {
@@ -456,7 +456,7 @@ do {
     CPU (h_cond) = opval;
     TRACE_RESULT (current_cpu, abuf, "condbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -717,7 +717,7 @@ SEM_FN_NAME (m32rbf,bl8) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     SI opval = ADDSI (ANDSI (pc, -4), 4);
     CPU (h_gr[((UINT) 14)]) = opval;
@@ -728,7 +728,7 @@ do {
     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -747,7 +747,7 @@ SEM_FN_NAME (m32rbf,bl24) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 
-do {
+{
   {
     SI opval = ADDSI (pc, 4);
     CPU (h_gr[((UINT) 14)]) = opval;
@@ -758,7 +758,7 @@ do {
     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -1088,8 +1088,8 @@ SEM_FN_NAME (m32rbf,jl) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  USI temp1;SI temp0;
+{
+  SI temp0;USI temp1;
   temp0 = ADDSI (ANDSI (pc, -4), 4);
   temp1 = ANDSI (* FLD (i_sr), -4);
   {
@@ -1102,7 +1102,7 @@ do {
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -1353,8 +1353,8 @@ SEM_FN_NAME (m32rbf,ld_plus) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  SI temp1;SI temp0;
+{
+  SI temp0;SI temp1;
   temp0 = GETMEMSI (current_cpu, pc, * FLD (i_sr));
   temp1 = ADDSI (* FLD (i_sr), 4);
   {
@@ -1367,7 +1367,7 @@ do {
     * FLD (i_sr) = opval;
     TRACE_RESULT (current_cpu, abuf, "sr", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1447,18 +1447,18 @@ SEM_FN_NAME (m32rbf,lock) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     BI opval = 1;
     CPU (h_lock) = opval;
-    TRACE_RESULT (current_cpu, abuf, "lock-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
   }
   {
     SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
     * FLD (i_dr) = opval;
     TRACE_RESULT (current_cpu, abuf, "dr", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1891,7 +1891,7 @@ SEM_FN_NAME (m32rbf,rac) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   DI tmp_tmp1;
   tmp_tmp1 = SLLDI (GET_H_ACCUM (), 1);
   tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 32768));
@@ -1900,7 +1900,7 @@ do {
     SET_H_ACCUM (opval);
     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1917,7 +1917,7 @@ SEM_FN_NAME (m32rbf,rach) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   DI tmp_tmp1;
   tmp_tmp1 = ANDDI (GET_H_ACCUM (), MAKEDI (16777215, 0xffffffff));
 if (ANDIF (GEDI (tmp_tmp1, MAKEDI (16383, 0x80000000)), LEDI (tmp_tmp1, MAKEDI (8388607, 0xffffffff)))) {
@@ -1935,7 +1935,7 @@ if (ANDIF (GEDI (tmp_tmp1, MAKEDI (8388608, 0)), LEDI (tmp_tmp1, MAKEDI (1676083
     SET_H_ACCUM (opval);
     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -1953,7 +1953,7 @@ SEM_FN_NAME (m32rbf,rte) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = ANDSI (GET_H_CR (((UINT) 6)), -4);
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
@@ -1967,14 +1967,14 @@ do {
   {
     UQI opval = CPU (h_bpsw);
     SET_H_PSW (opval);
-    TRACE_RESULT (current_cpu, abuf, "psw-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
   }
   {
     UQI opval = CPU (h_bbpsw);
     CPU (h_bpsw) = opval;
-    TRACE_RESULT (current_cpu, abuf, "bpsw-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -2328,7 +2328,7 @@ SEM_FN_NAME (m32rbf,st_plus) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_new_src2;
   tmp_new_src2 = ADDSI (* FLD (i_src2), 4);
   {
@@ -2341,7 +2341,7 @@ do {
     * FLD (i_src2) = opval;
     TRACE_RESULT (current_cpu, abuf, "src2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2358,7 +2358,7 @@ SEM_FN_NAME (m32rbf,st_minus) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   SI tmp_new_src2;
   tmp_new_src2 = SUBSI (* FLD (i_src2), 4);
   {
@@ -2371,7 +2371,7 @@ do {
     * FLD (i_src2) = opval;
     TRACE_RESULT (current_cpu, abuf, "src2", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2409,8 +2409,8 @@ SEM_FN_NAME (m32rbf,subv) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  BI temp1;SI temp0;
+{
+  SI temp0;BI temp1;
   temp0 = SUBSI (* FLD (i_dr), * FLD (i_sr));
   temp1 = SUBOFSI (* FLD (i_dr), * FLD (i_sr), 0);
   {
@@ -2423,7 +2423,7 @@ do {
     CPU (h_cond) = opval;
     TRACE_RESULT (current_cpu, abuf, "condbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2440,8 +2440,8 @@ SEM_FN_NAME (m32rbf,subx) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
-  BI temp1;SI temp0;
+{
+  SI temp0;BI temp1;
   temp0 = SUBCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
   temp1 = SUBCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
   {
@@ -2454,7 +2454,7 @@ do {
     CPU (h_cond) = opval;
     TRACE_RESULT (current_cpu, abuf, "condbit", 'x', opval);
   }
-} while (0);
+}
 
   return vpc;
 #undef FLD
@@ -2472,7 +2472,7 @@ SEM_FN_NAME (m32rbf,trap) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   SEM_BRANCH_INIT
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
   {
     USI opval = GET_H_CR (((UINT) 6));
     SET_H_CR (((UINT) 14), opval);
@@ -2486,24 +2486,24 @@ do {
   {
     UQI opval = CPU (h_bpsw);
     CPU (h_bbpsw) = opval;
-    TRACE_RESULT (current_cpu, abuf, "bbpsw-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "bbpsw", 'x', opval);
   }
   {
     UQI opval = GET_H_PSW ();
     CPU (h_bpsw) = opval;
-    TRACE_RESULT (current_cpu, abuf, "bpsw-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
   }
   {
     UQI opval = ANDQI (GET_H_PSW (), 128);
     SET_H_PSW (opval);
-    TRACE_RESULT (current_cpu, abuf, "psw-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
   }
   {
     SI opval = m32r_trap (current_cpu, pc, FLD (f_uimm4));
     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
   }
-} while (0);
+}
 
   SEM_BRANCH_FINI (vpc);
   return vpc;
@@ -2521,7 +2521,7 @@ SEM_FN_NAME (m32rbf,unlock) (SIM_CPU *current_cpu, SEM_ARG sem_arg)
   IADDR UNUSED pc = abuf->addr;
   SEM_PC vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 
-do {
+{
 if (CPU (h_lock)) {
   {
     SI opval = * FLD (i_src1);
@@ -2533,9 +2533,9 @@ if (CPU (h_lock)) {
   {
     BI opval = 0;
     CPU (h_lock) = opval;
-    TRACE_RESULT (current_cpu, abuf, "lock-0", 'x', opval);
+    TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
   }
-} while (0);
+}
 
   abuf->written = written;
   return vpc;
index 6116af8e88eec1a2901ff17a2dde846d6477cdb5..3ef5a315b8bee7f76582baf14a739b8f8cedcd52 100644 (file)
@@ -155,8 +155,8 @@ sim_open (kind, callback, abfd, argv)
 
   /* Open a copy of the cpu descriptor table.  */
   {
-    CGEN_CPU_DESC cd = m32r_cgen_cpu_open (STATE_ARCHITECTURE (sd)->mach,
-                                          CGEN_ENDIAN_BIG);
+    CGEN_CPU_DESC cd = m32r_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd)->printable_name,
+                                            CGEN_ENDIAN_BIG);
     for (i = 0; i < MAX_NR_PROCESSORS; ++i)
       {
        SIM_CPU *cpu = STATE_CPU (sd, i);
index c81a8626b8fe73d5d37eecf49b4bf1943512c60a..f3009f315a26644ddbb2d95b4f2be0dd017bdb99 100644 (file)
@@ -59,9 +59,18 @@ m32r_core_signal (SIM_DESC sd, SIM_CPU *current_cpu, sim_cia cia,
     {
       a_m32r_h_cr_set (current_cpu, H_CR_BBPC,
                       a_m32r_h_cr_get (current_cpu, H_CR_BPC));
-      a_m32r_h_bpsw_set (current_cpu, a_m32r_h_psw_get (current_cpu));
-      /* sm not changed */
-      a_m32r_h_psw_set (current_cpu, a_m32r_h_psw_get (current_cpu) & 0x80);
+      if (MACH_NUM (CPU_MACH (current_cpu)) == MACH_M32R)
+       {
+         m32rbf_h_bpsw_set (current_cpu, m32rbf_h_psw_get (current_cpu));
+         /* sm not changed */
+         m32rbf_h_psw_set (current_cpu, m32rbf_h_psw_get (current_cpu) & 0x80);
+       }
+      else
+       {
+         m32rxf_h_bpsw_set (current_cpu, m32rxf_h_psw_get (current_cpu));
+         /* sm not changed */
+         m32rxf_h_psw_set (current_cpu, m32rxf_h_psw_get (current_cpu) & 0x80);
+       }
       a_m32r_h_cr_set (current_cpu, H_CR_BPC, cia);
 
       sim_engine_restart (CPU_STATE (current_cpu), current_cpu, NULL,
index bb8ac4002c649ee39d775e8b5058cf11c67b5116..2efd41aa5bfbf7d06bc1531928d03c92b33637dd 100644 (file)
@@ -1,3 +1,24 @@
+1999-04-21  Frank Ch. Eigler  <fche@cygnus.com>
+
+       * mips.igen (bc0f): For the TX39 only, decode this as a no-op stub.
+
+Thu Apr 15 14:15:17 1999  Andrew Cagney  <cagney@amy.cygnus.com>
+
+       * configure.in: Any mips64vr5*-*-* target should have
+       -DTARGET_ENABLE_FR=1.
+       (default_endian): Any mips64vr*el-*-* target should default to
+       LITTLE_ENDIAN.
+       * configure: Re-generate.
+
+1999-02-19  Gavin Romig-Koch  <gavin@cygnus.com>
+
+       * mips.igen (ldl): Extend from _16_, not 32.
+
+Wed Jan 27 18:51:38 1999  Andrew Cagney  <cagney@chook.cygnus.com>
+
+       * interp.c (sim_store_register): Force registers written to by GDB
+       into an un-interpreted state.
+
 1999-02-05  Frank Ch. Eigler  <fche@cygnus.com>
 
        * dv-tx3904sio.c (tx3904sio_tickle): After a polled I/O from the
index 58be0650baf009378cffedd741d01e07dbe4e5bb..fe3e2d24b6c26f73d6e437ba388a5aa1e9aa828a 100755 (executable)
@@ -135,7 +135,7 @@ sim_inline="-DDEFAULT_INLINE=0"
 
 
 # Guess values for system-dependent variables and create Makefiles.
-# Generated automatically using autoconf version 2.12.2 
+# Generated automatically using autoconf version 2.13 
 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
 #
 # This configure script is free software; the Free Software Foundation
@@ -511,7 +511,7 @@ EOF
     verbose=yes ;;
 
   -version | --version | --versio | --versi | --vers)
-    echo "configure generated by autoconf version 2.12.2"
+    echo "configure generated by autoconf version 2.13"
     exit 0 ;;
 
   -with-* | --with-*)
@@ -1062,7 +1062,7 @@ else
 #endif
 EOF
 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  egrep "off_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
+  egrep "(^|[^a-zA-Z_0-9])off_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
   rm -rf conftest*
   ac_cv_type_off_t=yes
 else
@@ -1095,7 +1095,7 @@ else
 #endif
 EOF
 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  egrep "size_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
+  egrep "(^|[^a-zA-Z_0-9])size_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then
   rm -rf conftest*
   ac_cv_type_size_t=yes
 else
@@ -1755,7 +1755,8 @@ else
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       ac_cv_prog_CC="gcc"
@@ -1776,7 +1777,7 @@ if test -z "$CC"; then
   # Extract the first word of "cc", so it can be a program name with args.
 set dummy cc; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1780: checking for $ac_word" >&5
+echo "configure:1781: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1785,7 +1786,8 @@ else
 else
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
   ac_prog_rejected=no
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
@@ -1826,7 +1828,7 @@ fi
       # Extract the first word of "cl", so it can be a program name with args.
 set dummy cl; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1830: checking for $ac_word" >&5
+echo "configure:1832: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1834,7 +1836,8 @@ else
   ac_cv_prog_CC="$CC" # Let the user override the test.
 else
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       ac_cv_prog_CC="cl"
@@ -1857,7 +1860,7 @@ fi
 fi
 
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
-echo "configure:1861: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
+echo "configure:1864: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
 
 ac_ext=c
 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
@@ -1866,12 +1869,14 @@ ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 cross_compiling=$ac_cv_prog_cc_cross
 
-cat > conftest.$ac_ext <<EOF
-#line 1871 "configure"
+cat > conftest.$ac_ext << EOF
+
+#line 1875 "configure"
 #include "confdefs.h"
+
 main(){return(0);}
 EOF
-if { (eval echo configure:1875: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:1880: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   ac_cv_prog_cc_works=yes
   # If we can't run a trivial program, we are probably using a cross compiler.
   if (./conftest; exit) 2>/dev/null; then
@@ -1885,18 +1890,24 @@ else
   ac_cv_prog_cc_works=no
 fi
 rm -fr conftest*
+ac_ext=c
+# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
+ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
+cross_compiling=$ac_cv_prog_cc_cross
 
 echo "$ac_t""$ac_cv_prog_cc_works" 1>&6
 if test $ac_cv_prog_cc_works = no; then
   { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
 fi
 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
-echo "configure:1895: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
+echo "configure:1906: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
 echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
 cross_compiling=$ac_cv_prog_cc_cross
 
 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
-echo "configure:1900: checking whether we are using GNU C" >&5
+echo "configure:1911: checking whether we are using GNU C" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1905,7 +1916,7 @@ else
   yes;
 #endif
 EOF
-if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1909: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
+if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1920: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
   ac_cv_prog_gcc=yes
 else
   ac_cv_prog_gcc=no
@@ -1924,7 +1935,7 @@ ac_test_CFLAGS="${CFLAGS+set}"
 ac_save_CFLAGS="$CFLAGS"
 CFLAGS=
 echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
-echo "configure:1928: checking whether ${CC-cc} accepts -g" >&5
+echo "configure:1939: checking whether ${CC-cc} accepts -g" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -1967,7 +1978,7 @@ fi
 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 # ./install, which can be erroneously created by make from ./install.sh.
 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
-echo "configure:1971: checking for a BSD compatible install" >&5
+echo "configure:1982: checking for a BSD compatible install" >&5
 if test -z "$INSTALL"; then
 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2015,6 +2026,8 @@ echo "$ac_t""$INSTALL" 1>&6
 # It thinks the first close brace ends the variable substitution.
 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
+
 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 
 
@@ -2033,7 +2046,7 @@ AR=${AR-ar}
 # Extract the first word of "ranlib", so it can be a program name with args.
 set dummy ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2037: checking for $ac_word" >&5
+echo "configure:2050: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2041,7 +2054,8 @@ else
   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
 else
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       ac_cv_prog_RANLIB="ranlib"
@@ -2067,17 +2081,17 @@ unistd.h values.h sys/param.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2071: checking for $ac_hdr" >&5
+echo "configure:2085: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2076 "configure"
+#line 2090 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2081: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2095: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2107,12 +2121,12 @@ done
 __argz_count __argz_stringify __argz_next
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2111: checking for $ac_func" >&5
+echo "configure:2125: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2116 "configure"
+#line 2130 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -2135,7 +2149,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2139: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2153: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -2164,12 +2178,12 @@ done
      for ac_func in stpcpy
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2168: checking for $ac_func" >&5
+echo "configure:2182: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2173 "configure"
+#line 2187 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -2192,7 +2206,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2196: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2210: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -2226,19 +2240,19 @@ EOF
 
    if test $ac_cv_header_locale_h = yes; then
     echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
-echo "configure:2230: checking for LC_MESSAGES" >&5
+echo "configure:2244: checking for LC_MESSAGES" >&5
 if eval "test \"`echo '$''{'am_cv_val_LC_MESSAGES'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2235 "configure"
+#line 2249 "configure"
 #include "confdefs.h"
 #include <locale.h>
 int main() {
 return LC_MESSAGES
 ; return 0; }
 EOF
-if { (eval echo configure:2242: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2256: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   am_cv_val_LC_MESSAGES=yes
 else
@@ -2259,7 +2273,7 @@ EOF
     fi
   fi
    echo $ac_n "checking whether NLS is requested""... $ac_c" 1>&6
-echo "configure:2263: checking whether NLS is requested" >&5
+echo "configure:2277: checking whether NLS is requested" >&5
         # Check whether --enable-nls or --disable-nls was given.
 if test "${enable_nls+set}" = set; then
   enableval="$enable_nls"
@@ -2279,7 +2293,7 @@ fi
 EOF
 
       echo $ac_n "checking whether included gettext is requested""... $ac_c" 1>&6
-echo "configure:2283: checking whether included gettext is requested" >&5
+echo "configure:2297: checking whether included gettext is requested" >&5
       # Check whether --with-included-gettext or --without-included-gettext was given.
 if test "${with_included_gettext+set}" = set; then
   withval="$with_included_gettext"
@@ -2298,17 +2312,17 @@ fi
 
        ac_safe=`echo "libintl.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for libintl.h""... $ac_c" 1>&6
-echo "configure:2302: checking for libintl.h" >&5
+echo "configure:2316: checking for libintl.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2307 "configure"
+#line 2321 "configure"
 #include "confdefs.h"
 #include <libintl.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2312: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2326: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2325,19 +2339,19 @@ fi
 if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
   echo "$ac_t""yes" 1>&6
   echo $ac_n "checking for gettext in libc""... $ac_c" 1>&6
-echo "configure:2329: checking for gettext in libc" >&5
+echo "configure:2343: checking for gettext in libc" >&5
 if eval "test \"`echo '$''{'gt_cv_func_gettext_libc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2334 "configure"
+#line 2348 "configure"
 #include "confdefs.h"
 #include <libintl.h>
 int main() {
 return (int) gettext ("")
 ; return 0; }
 EOF
-if { (eval echo configure:2341: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2355: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   gt_cv_func_gettext_libc=yes
 else
@@ -2353,7 +2367,7 @@ echo "$ac_t""$gt_cv_func_gettext_libc" 1>&6
 
           if test "$gt_cv_func_gettext_libc" != "yes"; then
             echo $ac_n "checking for bindtextdomain in -lintl""... $ac_c" 1>&6
-echo "configure:2357: checking for bindtextdomain in -lintl" >&5
+echo "configure:2371: checking for bindtextdomain in -lintl" >&5
 ac_lib_var=`echo intl'_'bindtextdomain | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2361,7 +2375,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lintl  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 2365 "configure"
+#line 2379 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -2372,7 +2386,7 @@ int main() {
 bindtextdomain()
 ; return 0; }
 EOF
-if { (eval echo configure:2376: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2390: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -2388,19 +2402,19 @@ fi
 if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
   echo "$ac_t""yes" 1>&6
   echo $ac_n "checking for gettext in libintl""... $ac_c" 1>&6
-echo "configure:2392: checking for gettext in libintl" >&5
+echo "configure:2406: checking for gettext in libintl" >&5
 if eval "test \"`echo '$''{'gt_cv_func_gettext_libintl'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2397 "configure"
+#line 2411 "configure"
 #include "confdefs.h"
 
 int main() {
 return (int) gettext ("")
 ; return 0; }
 EOF
-if { (eval echo configure:2404: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2418: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   gt_cv_func_gettext_libintl=yes
 else
@@ -2428,7 +2442,7 @@ EOF
              # Extract the first word of "msgfmt", so it can be a program name with args.
 set dummy msgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2432: checking for $ac_word" >&5
+echo "configure:2446: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2462,12 +2476,12 @@ fi
                for ac_func in dcgettext
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:2466: checking for $ac_func" >&5
+echo "configure:2480: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2471 "configure"
+#line 2485 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -2490,7 +2504,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:2494: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2508: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -2517,7 +2531,7 @@ done
                # Extract the first word of "gmsgfmt", so it can be a program name with args.
 set dummy gmsgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2521: checking for $ac_word" >&5
+echo "configure:2535: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2530,7 +2544,8 @@ else
   ;;
   *)
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do 
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       ac_cv_path_GMSGFMT="$ac_dir/$ac_word"
@@ -2552,7 +2567,7 @@ fi
                # Extract the first word of "xgettext", so it can be a program name with args.
 set dummy xgettext; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2556: checking for $ac_word" >&5
+echo "configure:2571: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2584,7 +2599,7 @@ else
 fi
 
                cat > conftest.$ac_ext <<EOF
-#line 2588 "configure"
+#line 2603 "configure"
 #include "confdefs.h"
 
 int main() {
@@ -2592,7 +2607,7 @@ extern int _nl_msg_cat_cntr;
                               return _nl_msg_cat_cntr
 ; return 0; }
 EOF
-if { (eval echo configure:2596: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2611: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   CATOBJEXT=.gmo
                   DATADIRNAME=share
@@ -2624,7 +2639,7 @@ fi
         # Extract the first word of "msgfmt", so it can be a program name with args.
 set dummy msgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2628: checking for $ac_word" >&5
+echo "configure:2643: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2658,7 +2673,7 @@ fi
         # Extract the first word of "gmsgfmt", so it can be a program name with args.
 set dummy gmsgfmt; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2662: checking for $ac_word" >&5
+echo "configure:2677: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2671,7 +2686,8 @@ else
   ;;
   *)
   IFS="${IFS=  }"; ac_save_ifs="$IFS"; IFS=":"
-  for ac_dir in $PATH; do
+  ac_dummy="$PATH"
+  for ac_dir in $ac_dummy; do 
     test -z "$ac_dir" && ac_dir=.
     if test -f $ac_dir/$ac_word; then
       ac_cv_path_GMSGFMT="$ac_dir/$ac_word"
@@ -2693,7 +2709,7 @@ fi
         # Extract the first word of "xgettext", so it can be a program name with args.
 set dummy xgettext; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2697: checking for $ac_word" >&5
+echo "configure:2713: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -2783,7 +2799,7 @@ fi
        LINGUAS=
      else
        echo $ac_n "checking for catalogs to be installed""... $ac_c" 1>&6
-echo "configure:2787: checking for catalogs to be installed" >&5
+echo "configure:2803: checking for catalogs to be installed" >&5
        NEW_LINGUAS=
        for lang in ${LINGUAS=$ALL_LINGUAS}; do
          case "$ALL_LINGUAS" in
@@ -2811,17 +2827,17 @@ echo "configure:2787: checking for catalogs to be installed" >&5
       if test "$CATOBJEXT" = ".cat"; then
         ac_safe=`echo "linux/version.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for linux/version.h""... $ac_c" 1>&6
-echo "configure:2815: checking for linux/version.h" >&5
+echo "configure:2831: checking for linux/version.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2820 "configure"
+#line 2836 "configure"
 #include "confdefs.h"
 #include <linux/version.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2825: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2841: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2890,17 +2906,17 @@ for ac_hdr in stdlib.h string.h strings.h unistd.h time.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2894: checking for $ac_hdr" >&5
+echo "configure:2910: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2899 "configure"
+#line 2915 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2904: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2920: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2930,17 +2946,17 @@ for ac_hdr in sys/time.h sys/resource.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2934: checking for $ac_hdr" >&5
+echo "configure:2950: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2939 "configure"
+#line 2955 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2944: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2960: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -2970,17 +2986,17 @@ for ac_hdr in fcntl.h fpu_control.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2974: checking for $ac_hdr" >&5
+echo "configure:2990: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2979 "configure"
+#line 2995 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2984: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:3000: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3010,17 +3026,17 @@ for ac_hdr in dlfcn.h errno.h sys/stat.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:3014: checking for $ac_hdr" >&5
+echo "configure:3030: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3019 "configure"
+#line 3035 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:3024: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:3040: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -3049,12 +3065,12 @@ done
 for ac_func in getrusage time sigaction __setfpucw
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:3053: checking for $ac_func" >&5
+echo "configure:3069: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3058 "configure"
+#line 3074 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -3077,7 +3093,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:3081: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3097: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -3104,7 +3120,7 @@ done
 
 # Check for socket libraries
 echo $ac_n "checking for bind in -lsocket""... $ac_c" 1>&6
-echo "configure:3108: checking for bind in -lsocket" >&5
+echo "configure:3124: checking for bind in -lsocket" >&5
 ac_lib_var=`echo socket'_'bind | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -3112,7 +3128,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lsocket  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 3116 "configure"
+#line 3132 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -3123,7 +3139,7 @@ int main() {
 bind()
 ; return 0; }
 EOF
-if { (eval echo configure:3127: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3143: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -3151,7 +3167,7 @@ else
 fi
 
 echo $ac_n "checking for gethostbyname in -lnsl""... $ac_c" 1>&6
-echo "configure:3155: checking for gethostbyname in -lnsl" >&5
+echo "configure:3171: checking for gethostbyname in -lnsl" >&5
 ac_lib_var=`echo nsl'_'gethostbyname | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -3159,7 +3175,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lnsl  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 3163 "configure"
+#line 3179 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -3170,7 +3186,7 @@ int main() {
 gethostbyname()
 ; return 0; }
 EOF
-if { (eval echo configure:3174: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:3190: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -3346,12 +3362,12 @@ fi
 
 
 echo $ac_n "checking return type of signal handlers""... $ac_c" 1>&6
-echo "configure:3350: checking return type of signal handlers" >&5
+echo "configure:3366: checking return type of signal handlers" >&5
 if eval "test \"`echo '$''{'ac_cv_type_signal'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 3355 "configure"
+#line 3371 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <signal.h>
@@ -3368,7 +3384,7 @@ int main() {
 int i;
 ; return 0; }
 EOF
-if { (eval echo configure:3372: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3388: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_type_signal=void
 else
@@ -3388,7 +3404,7 @@ EOF
 
 
 echo $ac_n "checking for executable suffix""... $ac_c" 1>&6
-echo "configure:3392: checking for executable suffix" >&5
+echo "configure:3408: checking for executable suffix" >&5
 if eval "test \"`echo '$''{'am_cv_exeext'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
@@ -3541,14 +3557,14 @@ else
   
 if test "x$cross_compiling" = "xno"; then
   echo $ac_n "checking whether byte ordering is bigendian""... $ac_c" 1>&6
-echo "configure:3545: checking whether byte ordering is bigendian" >&5
+echo "configure:3561: checking whether byte ordering is bigendian" >&5
 if eval "test \"`echo '$''{'ac_cv_c_bigendian'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   ac_cv_c_bigendian=unknown
 # See if sys/param.h defines the BYTE_ORDER macro.
 cat > conftest.$ac_ext <<EOF
-#line 3552 "configure"
+#line 3568 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <sys/param.h>
@@ -3559,11 +3575,11 @@ int main() {
 #endif
 ; return 0; }
 EOF
-if { (eval echo configure:3563: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3579: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   # It does; now see whether it defined to BIG_ENDIAN or not.
 cat > conftest.$ac_ext <<EOF
-#line 3567 "configure"
+#line 3583 "configure"
 #include "confdefs.h"
 #include <sys/types.h>
 #include <sys/param.h>
@@ -3574,7 +3590,7 @@ int main() {
 #endif
 ; return 0; }
 EOF
-if { (eval echo configure:3578: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:3594: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   rm -rf conftest*
   ac_cv_c_bigendian=yes
 else
@@ -3594,7 +3610,7 @@ if test "$cross_compiling" = yes; then
     { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; }
 else
   cat > conftest.$ac_ext <<EOF
-#line 3598 "configure"
+#line 3614 "configure"
 #include "confdefs.h"
 main () {
   /* Are we little or big endian?  From Harbison&Steele.  */
@@ -3607,7 +3623,7 @@ main () {
   exit (u.c[sizeof (long) - 1] == 1);
 }
 EOF
-if { (eval echo configure:3611: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:3627: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   ac_cv_c_bigendian=no
 else
@@ -3683,6 +3699,7 @@ mips_endian=
 default_endian=
 case "${target}" in
   mips64el*-*-*)       mips_endian=LITTLE_ENDIAN ;;
+  mips64vr*el-*-*)      default_endian=LITTLE_ENDIAN ;;
   mips64*-*-*)          default_endian=BIG_ENDIAN ;;
   mips16*-*-*)          default_endian=BIG_ENDIAN ;;
   mips*-*-*)            default_endian=BIG_ENDIAN ;;
@@ -4021,7 +4038,7 @@ esac
 # Uses ac_ vars as temps to allow command line to override cache and checks.
 # --without-x overrides everything else, but does not touch the cache.
 echo $ac_n "checking for X""... $ac_c" 1>&6
-echo "configure:4125: checking for X" >&5
+echo "configure:4142: checking for X" >&5
 
 # Check whether --with-x or --without-x was given.
 if test "${with_x+set}" = set; then
@@ -4083,12 +4100,12 @@ if test "$ac_x_includes" = NO; then
 
   # First, try using that file with no special directory specified.
 cat > conftest.$ac_ext <<EOF
-#line 4187 "configure"
+#line 4204 "configure"
 #include "confdefs.h"
 #include <$x_direct_test_include>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:4192: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:4209: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -4157,14 +4174,14 @@ if test "$ac_x_libraries" = NO; then
   ac_save_LIBS="$LIBS"
   LIBS="-l$x_direct_test_library $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 4261 "configure"
+#line 4278 "configure"
 #include "confdefs.h"
 
 int main() {
 ${x_direct_test_function}()
 ; return 0; }
 EOF
-if { (eval echo configure:4268: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:4285: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   LIBS="$ac_save_LIBS"
 # We can link X programs with no special library path.
@@ -4257,17 +4274,17 @@ for ac_hdr in string.h strings.h stdlib.h stdlib.h
 do
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:5155: checking for $ac_hdr" >&5
+echo "configure:5172: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 5160 "configure"
+#line 5177 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:5165: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:5182: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
   rm -rf conftest*
@@ -4294,7 +4311,7 @@ fi
 done
 
 echo $ac_n "checking for fabs in -lm""... $ac_c" 1>&6
-echo "configure:5192: checking for fabs in -lm" >&5
+echo "configure:5209: checking for fabs in -lm" >&5
 ac_lib_var=`echo m'_'fabs | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -4302,7 +4319,7 @@ else
   ac_save_LIBS="$LIBS"
 LIBS="-lm  $LIBS"
 cat > conftest.$ac_ext <<EOF
-#line 5200 "configure"
+#line 5217 "configure"
 #include "confdefs.h"
 /* Override any gcc2 internal prototype to avoid an error.  */
 /* We use char because int might match the return type of a gcc2
@@ -4313,7 +4330,7 @@ int main() {
 fabs()
 ; return 0; }
 EOF
-if { (eval echo configure:5211: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5228: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_lib_$ac_lib_var=yes"
 else
@@ -4343,12 +4360,12 @@ fi
 for ac_func in aint anint sqrt
 do
 echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:5241: checking for $ac_func" >&5
+echo "configure:5258: checking for $ac_func" >&5
 if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 5246 "configure"
+#line 5263 "configure"
 #include "confdefs.h"
 /* System header to define __stub macros and hopefully few prototypes,
     which can conflict with char $ac_func(); below.  */
@@ -4371,7 +4388,7 @@ $ac_func();
 
 ; return 0; }
 EOF
-if { (eval echo configure:5269: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:5286: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   eval "ac_cv_func_$ac_func=yes"
 else
@@ -4421,7 +4438,7 @@ EOF
 # Ultrix sh set writes to stderr and can't be redirected directly,
 # and sets the high bit in the cache file unless we assign to the vars.
 (set) 2>&1 |
-  case `(ac_space=' '; set) 2>&1 | grep ac_space` in
+  case `(ac_space=' '; set | grep ac_space) 2>&1` in
   *ac_space=\ *)
     # `set' does not quote correctly, so add quotes (double-quote substitution
     # turns \\\\ into \\, and sed turns \\ into \).
@@ -4488,7 +4505,7 @@ do
     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
-    echo "$CONFIG_STATUS generated by autoconf version 2.12.2"
+    echo "$CONFIG_STATUS generated by autoconf version 2.13"
     exit 0 ;;
   -help | --help | --hel | --he | --h)
     echo "\$ac_cs_usage"; exit 0 ;;
@@ -4532,6 +4549,7 @@ s%@SHELL@%$SHELL%g
 s%@CFLAGS@%$CFLAGS%g
 s%@CPPFLAGS@%$CPPFLAGS%g
 s%@CXXFLAGS@%$CXXFLAGS%g
+s%@FFLAGS@%$FFLAGS%g
 s%@DEFS@%$DEFS%g
 s%@LDFLAGS@%$LDFLAGS%g
 s%@LIBS@%$LIBS%g
@@ -4567,6 +4585,7 @@ s%@build_vendor@%$build_vendor%g
 s%@build_os@%$build_os%g
 s%@CC@%$CC%g
 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
+s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
 s%@INSTALL_DATA@%$INSTALL_DATA%g
 s%@CC_FOR_BUILD@%$CC_FOR_BUILD%g
 s%@HDEFINES@%$HDEFINES%g
index 89959fe59af374a8786af41c670e9efa401e8603..bff4bc35cc4e6bf9bdbf42740f0fdaad181a3e65 100644 (file)
@@ -32,6 +32,7 @@ mips_endian=
 default_endian=
 case "${target}" in
   mips64el*-*-*)       mips_endian=LITTLE_ENDIAN ;;
+  mips64vr*el-*-*)      default_endian=LITTLE_ENDIAN ;;
   mips64*-*-*)          default_endian=BIG_ENDIAN ;;
   mips16*-*-*)          default_endian=BIG_ENDIAN ;;
   mips*-*-*)            default_endian=BIG_ENDIAN ;;
index 75bc54b7b821a0d0b43d6794f2ec29528a5ced6f..a2ed20fb7bef2657c9f89fc32d23599ac028cb4a 100644 (file)
@@ -750,6 +750,7 @@ sim_store_register (sd,rn,memory,length)
 
   if (rn >= FGRIDX && rn < FGRIDX + NR_FGR)
     {
+      cpu->fpr_state[rn - FGRIDX] = fmt_uninterpreted;
       if (cpu->register_widths[rn] == 32)
        {
          cpu->fgr[rn - FGRIDX] = T2H_4 (*(unsigned32*)memory);
index bfc209ab3dc6a54ae9c538f684168551d38c7187..66c475a7e428ae4004a13f052f7e390ce7782935 100644 (file)
 *vr5000:
 *r3900:
 {
-  GPR[RT] = EXTEND32 (do_load_left (SD_, AccessLength_WORD, GPR[BASE], EXTEND32 (OFFSET), GPR[RT]));
+  GPR[RT] = EXTEND32 (do_load_left (SD_, AccessLength_WORD, GPR[BASE], EXTEND16 (OFFSET), GPR[RT]));
 }
 
 
 *vr4100:
 *vr5000:
 
+010000,01000,00000,16.OFFSET:COP0:32::BC0F
+"bc0f <OFFSET>"
+// stub needed for eCos as tx39 hardware bug workaround
+*r3900:
+{
+  /* do nothing */
+}
+
 
 010000,01000,00010,16.OFFSET:COP0:32::BC0FL
 "bc0fl <OFFSET>"
index ce38f139e4a3b8a82cb159eca8ed0cad30b99f82..1eb7fbd702701dde1702d8e01ebd138fce98d1ee 100644 (file)
@@ -1,3 +1,18 @@
+1999-04-06  Keith Seitz  <keiths@cygnus.com>
+
+       * interp.c (sim_stop): Set the sim's exception
+       to SIGINT.
+
+1999-04-02  Keith Seitz  <keiths@cygnus.com>
+
+       * interp.c (UI_LOOP_POLL_INTERVAL): Define. Used to tweak the
+       frequency at which ui_loop_hook is called.
+       (ui_loop_hook_counter): New global defined when NEED_UI_LOOP_HOOK
+       is defined.
+       (sim_resume): Call ui_loop_hook (if defined) when the interval
+       passes.
+       * Makefile.in (SIM_EXTRA_CFLAGS): Include NEED_UI_LOOP_HOOK.
+
 Wed Jun 17 11:37:59 1998  Mark Alexander  <marka@cygnus.com>
 
        * Makefile.in: Define NL_TARGET so that targ-vals.h will be used
index dd9581ced2656f5cc93fbf54ceb2fcf4f9b6ee41..e19d9e778422ee835d0dcf3a75db2646fea09dcd 100644 (file)
@@ -19,7 +19,7 @@
 ## COMMON_PRE_CONFIG_FRAG
 
 SIM_OBJS = interp.o table.o simops.o sim-load.o
-SIM_EXTRA_CFLAGS = -I$(srcdir)/../../newlib/libc/sys/sysmec
+SIM_EXTRA_CFLAGS = -I$(srcdir)/../../newlib/libc/sys/sysmec -DNEED_UI_LOOP_HOOK
 SIM_EXTRA_CLEAN = clean-extra
 
 # Select mn10200 support in nltvals.def.
index df95b7c7ba5201f5e1cd8d2cd163832d64dd8dc4..43a87506184eae307954ac4fc1e42584be40abe2 100644 (file)
@@ -4,6 +4,17 @@
 
 #include "mn10200_sim.h"
 
+#ifdef NEED_UI_LOOP_HOOK
+/* How often to run the ui_loop update, when in use */
+#define UI_LOOP_POLL_INTERVAL 0x60000
+
+/* Counter for the ui_loop_hook update */
+static long ui_loop_hook_counter = UI_LOOP_POLL_INTERVAL;
+
+/* Actual hook to call to run through gdb's gui event loop */
+extern int (*ui_loop_hook) (int);
+#endif /* NEED_UI_LOOP_HOOK */
+
 host_callback *mn10200_callback;
 int mn10200_debug;
 static SIM_OPEN_KIND sim_kind;
@@ -292,7 +303,8 @@ int
 sim_stop (sd)
      SIM_DESC sd;
 {
-  return 0;
+  State.exception = SIGINT;
+  return 1;
 }
 
 void
@@ -313,6 +325,14 @@ sim_resume (sd, step, siggnal)
     {
       unsigned long insn, extension;
 
+#ifdef NEED_UI_LOOP_HOOK
+    if (ui_loop_hook != NULL && ui_loop_hook_counter-- < 0)
+      {
+       ui_loop_hook_counter = UI_LOOP_POLL_INTERVAL;
+       ui_loop_hook (0);
+      }
+#endif /* NEED_UI_LOOP_HOOK */
+
       /* Fetch the current instruction, fetch a double word to
         avoid redundant fetching for the common cases below.  */
       inst = load_mem_big (PC, 2);
index d9920997b95901e723e409a6e53cdc6beeb0acc5..161acf252e1d114683f01a67a4f8272407ca3afd 100644 (file)
@@ -1,3 +1,28 @@
+1999-04-16  Frank Ch. Eigler  <fche@cygnus.com>
+
+       * interp.c (program_interrupt): Detect undesired recursion using
+       static flag.  Set NMIRC register's SYSEF flag during
+       --board=stdeval1 mode.
+       * dv-mn103-int.c (write_icr): Add backdoor address to allow CPU to
+       set SYSEF flag.
+
+1999-04-02  Keith Seitz  <keiths@cygnus.com>
+
+       * Makefile.in (SIM_EXTRA_CFLAGS): Define a POLL_QUIT_INTERVAL
+       for use in the simulator so that the poll_quit callback is
+       not called too often.
+
+Tue Mar  9 21:26:41 1999  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * dv-mn103int.c (mn103int_ioctl): Return something.
+       * dv-mn103tim.c (write_tm6md): GCC suggested parentheses around &&
+       within ||.
+
+Tue Feb 16 23:57:17 1999  Jeffrey A Law  (law@cygnus.com)
+
+       * mn10300.igen (retf): Fix return address computation and store
+       the new pc value into nia.
+
 1998-12-29  Frank Ch. Eigler  <fche@cygnus.com>
 
        * Makefile.in (WITH_COMMON_OBJS): Build also dv-sockser.o.
index f5123c4d59254e3ce17250ca5f39c9baad0fb699..612576cce3b7108fb543e3bd7e509f6abc217217 100644 (file)
@@ -51,7 +51,7 @@ NL_TARGET = -DNL_TARGET_mn10300
 INCLUDE = mn10300_sim.h $(srcdir)/../../include/callback.h
 
 # List of extra flags to always pass to $(CC).
-SIM_EXTRA_CFLAGS = @sim_gen@
+SIM_EXTRA_CFLAGS = @sim_gen@ -DPOLL_QUIT_INTERVAL=0x20
 
 ## COMMON_POST_CONFIG_FRAG
 
index 11982fb2b5ac70ea28f276952f16ac9a4766e06d..d64e0074a1d46b9b68f14771394e8612765ca4bb 100644 (file)
@@ -585,6 +585,12 @@ write_icr (struct hw *me,
                     group->gid, val));
          group->request &= ~EXTRACT_ID (val);
          break;
+         /* Special backdoor access to SYSEF flag from CPU.  See
+             interp.c:program_interrupt(). */
+       case 3:
+         HW_TRACE ((me, "write-icr-special group=%d:0 nmi 0x%02x",
+                    group->gid, val));
+         group->request |= EXTRACT_ID (val);
        default:
          break;
        }
@@ -815,6 +821,7 @@ mn103int_ioctl(struct hw *me,
   struct mn103int *controller = (struct mn103int *)hw_data(me);
   controller->group[0].request = EXTRACT_ID(4);
   mn103int_port_event(me, 2 /* nmi_port(syserr) */, NULL, 0, 0);
+  return 0;
 }
 
 
index d93bb7161c6ba5e765a4e829e25f947685dfb02b..cd79f918fbf7b56fafad2fee7c9a3cd5393919d5 100644 (file)
@@ -842,7 +842,7 @@ write_tm6md (struct hw *me,
 
   unsigned_word offset = address - timers->block[0].base;
   
-  if ( offset != 0x84 && nr_bytes > 1 || nr_bytes > 2 )
+  if ((offset != 0x84 && nr_bytes > 1) || nr_bytes > 2 )
     {
       hw_abort (me, "Bad write size of %d bytes to TM6MD", nr_bytes);
     }
index d5e833e097e64c870d8494f16607d718ec6da620..12dffff8766e229ddba4b4fdd1007a6ea535ef32 100644 (file)
@@ -1329,19 +1329,39 @@ program_interrupt (SIM_DESC sd,
 {
   int status;
   struct hw *device;
+  static int in_interrupt = 0;
 
 #ifdef SIM_CPU_EXCEPTION_TRIGGER
   SIM_CPU_EXCEPTION_TRIGGER(sd,cpu,cia);
 #endif
 
-  /* copy NMI handler code from dv-mn103cpu.c */
-  /* XXX: possible infinite recursion if these store_*() calls fail! */
-  store_word (SP - 4, CIA_GET (cpu));
-  store_half (SP - 8, PSW);
+  /* avoid infinite recursion */
+  if (in_interrupt)
+    {
+      (*mn10300_callback->printf_filtered) (mn10300_callback, 
+                                           "ERROR: recursion in program_interrupt during software exception dispatch.");
+    }
+  else
+    {
+      in_interrupt = 1;
+      /* copy NMI handler code from dv-mn103cpu.c */
+      store_word (SP - 4, CIA_GET (cpu));
+      store_half (SP - 8, PSW);
+
+      /* Set the SYSEF flag in NMICR by backdoor method.  See
+        dv-mn103int.c:write_icr().  This is necessary because
+         software exceptions are not modelled by actually talking to
+         the interrupt controller, so it cannot set its own SYSEF
+         flag. */
+     if ((NULL != board) && (strcmp(board, BOARD_AM32) == 0))
+       store_byte (0x34000103, 0x04);
+    }
+
   PSW &= ~PSW_IE;
   SP = SP - 8;
   CIA_SET (cpu, 0x40000008);
 
+  in_interrupt = 0;
   sim_engine_halt(sd, cpu, NULL, cia, sim_stopped, sig);
 }
 
index 7c4f03d0024d0e49802ff6c56cd65df70a75c2ec..1b42db401e840eb873c84f6f2190909d8ad05876 100644 (file)
   PC = cia;
   State.regs[REG_SP] += IMM8;
   sp = State.regs[REG_SP];
-  State.regs[REG_PC] = State.regs[REG_MDR] - 3;
+  State.regs[REG_PC] = State.regs[REG_MDR];
 
   offset = -4;
   mask = REGS;
       State.regs[REG_LAR] = load_word (sp + offset);
       offset -= 4;
     }
+  nia = PC;
 }
 
index 49cf8ce11f0c8efc8a5423063533eedd34beee58..93312f0d3a057e733333d72bf40ca87eb4c60c45 100644 (file)
@@ -1,3 +1,21 @@
+1999-04-02  Keith Seitz  <keiths@cygnus.com>
+
+       * sim_calls.c (POLL_QUIT_INTERVAL): Define. Used to tweak
+       the frequency at which the poll_quit callback is called.
+       (poll_quit_count): New global.
+       (sim_io_poll_quit): Only call the poll_quit callback
+       after the specified POLL_QUIT_INTERVAL.
+
+1999-02-22  Jim Lemke  <jlemke@cygnus.com>
+
+       * dc-complex: Force expansion on all bits of field BO.
+       Previously, the least-significant (prediction) bit was ignored.
+       * ppc-instructions (conditional branches): Implement mpc860c0 option.
+       * igen.c (gen_semantics_[ch]): Setup for mpc860c0 option.
+       * psim.c (is_num, psim_options): Added parsing for mpc860c0 option.
+       * interrupts.h: Added "mpc860c0_instruction_program_interrupt".
+       * interrupts.c (program_interrupt): Added handling for above interrupt.
+
 1999-02-01  Jim Blandy  <jimb@zwingli.cygnus.com>
 
        Make the simulator compatible with the MPC750.  It would be nicer
index 13361ecd5250ac4fc70b9808e9e558dcaae7a969..34a58615dcb5028dd05258599126ee19c6ea682f 100644 (file)
@@ -20,9 +20,9 @@
 array,normal:        0: 5: 0: 5:
 array,normal:       21:31:32:-1:OE,LR,AA,Rc,LK:
 ##
-## Branch Conditional instruction - Expand BO{0:4} only, ignore BO{5}
+## Branch Conditional instruction - Expand BO{0:4}
 ##
-array,expand-forced: 6: 9: 6: 9:BO:            0xfc000000:0x40000000
+array,expand-forced: 6:10: 6:10:BO:            0xfc000000:0x40000000
 ##
 ## Expand RA on equality with 0 in Add instructions were if(RA==0) appears.
 ##
index dc87087e23b9c4798997318e5f706c9cd32c7441..94dcf5130dcac4c53c1e8d2e219b06382d4466f8 100644 (file)
@@ -181,14 +181,12 @@ gen_semantics_h(insn_table *table,
            SEMANTIC_FUNCTION_FORMAL);
   lf_printf(file, "\n");
   if ((code & generate_calls)) {
-    lf_printf(file, "#ifdef WITH_OPTION_MPC860C0\n");
     lf_printf(file, "extern int option_mpc860c0;\n");
     lf_printf(file, "#define PAGE_SIZE 0x1000\n");
     lf_printf(file, "\n");
     lf_printf(file, "EXTERN_SEMANTICS(void)\n");
     lf_printf(file, "semantic_init(device* root);\n");
     lf_printf(file, "\n");
-    lf_printf(file, "#endif // WITH_OPTION_MPC860C0\n");
     if (generate_expanded_instructions)
       insn_table_traverse_tree(table,
                               file, NULL,
@@ -222,7 +220,6 @@ gen_semantics_c(insn_table *table,
     lf_printf(file, "#include \"semantics.h\"\n");
     lf_printf(file, "#include \"support.h\"\n");
     lf_printf(file, "\n");
-    lf_printf(file, "#ifdef WITH_OPTION_MPC860C0\n");
     lf_printf(file, "int option_mpc860c0 = 0;\n");
     lf_printf(file, "\n");
     lf_printf(file, "EXTERN_SEMANTICS(void)\n");
@@ -231,9 +228,9 @@ gen_semantics_c(insn_table *table,
     lf_printf(file, "  option_mpc860c0 = 0;\n");
     lf_printf(file, "  if (tree_find_property(root, \"/options/mpc860c0\"))\n");
     lf_printf(file, "    option_mpc860c0 = tree_find_integer_property(root, \"/options/mpc860c0\");\n");
+    lf_printf(file, "    option_mpc860c0 *= 4;   /* convert word count to byte count */\n");
     lf_printf(file, "}\n");
     lf_printf(file, "\n");
-    lf_printf(file, "#endif // WITH_OPTION_MPC860C0\n");
     if (generate_expanded_instructions)
       insn_table_traverse_tree(table,
                               file, cache_rules,
index 7a13f7609b26a5959dbb043bb09bac32c329869f..deab7e9bf43c15f9152a52e2d0e55341b7fee176 100644 (file)
@@ -315,12 +315,10 @@ program_interrupt(cpu *processor,
       cpu_error(processor, cia, "program interrupt - %s",
                "illegal instruction (optional instruction not supported)");
       break;
-#ifdef WITH_OPTION_MPC860C0
     case mpc860c0_instruction_program_interrupt:
       cpu_error(processor, cia, "program interrupt - %s",
                "problematic branch detected, see MPC860 C0 errata");
       break;
-#endif // WITH_OPTION_MPC860C0
     default:
       error("internal error - program_interrupt - reason %d not implemented", reason);
     }
@@ -342,13 +340,11 @@ program_interrupt(cpu *processor,
       case trap_program_interrupt:
        srr1_set = srr1_trap;
        break;
-#ifdef WITH_OPTION_MPC860C0
       case mpc860c0_instruction_program_interrupt:
         srr1_set = 0;
-        error(processor, cia, "program interrupt - %s",
+        cpu_error(processor, cia, "program interrupt - %s",
               "problematic branch detected, see MPC860 C0 errata");
         break;
-#endif // WITH_OPTION_MPC860C0
       default:
        srr1_set = 0;
        error("internal error - program_interrupt - reason %d not implemented", reason);
index 6e87b77de5ad5264e2fa7893df6a921fd14601a8..93447a874d7e763f23c6afcb0406c823848e9d35 100644 (file)
@@ -94,9 +94,7 @@ typedef enum {
   privileged_instruction_program_interrupt,
   trap_program_interrupt,
   optional_instruction_program_interrupt, /* subset of illegal instruction */
-#ifdef WITH_OPTION_MPC860C0
   mpc860c0_instruction_program_interrupt, /* fwd br, taken but not predicted, near EO page */
-#endif // WITH_OPTION_MPC860C0
   nr_program_interrupt_reasons
 } program_interrupt_reasons;
 
index 6ebe0812e7a4003405246f6842cf2b7ac0d217f0..cfbac643e3a524b014a201789fa3a36d21680845 100644 (file)
@@ -1440,7 +1440,7 @@ void::function::invalid_zero_divide_operation:cpu *processor, unsigned_word cia,
 *603: PPC_UNIT_BPU,   PPC_UNIT_BPU,   1,  1,  0
 *603e:PPC_UNIT_BPU,   PPC_UNIT_BPU,   1,  1,  0
 *604: PPC_UNIT_BPU,   PPC_UNIT_BPU,   1,  1,  0
-       /* WITH_OPTION_MPC860C0
+       /* option_mpc860c0:
        No problem here because this branch is predicted taken (unconditional). */
        if (AA) NIA = IEA(EXTS(LI_0b00));
        else    NIA = IEA(CIA + EXTS(LI_0b00));
@@ -1469,9 +1469,8 @@ void::function::invalid_zero_divide_operation:cpu *processor, unsigned_word cia,
        else
          succeed = 0;
        if (LK) LR = (spreg)IEA(CIA + 4);
-       #ifdef WITH_OPTION_MPC860C0
-       if (option_mpc860c0 && (BO{0} && BO{2} || !BO{4})) {
-         /* This branch is predicted as not-taken.
+       if (option_mpc860c0 && (!BO{0} || !BO{2}) && !BO{4}) {
+         /* This branch is predicted as "normal".
          If this is a forward branch and it is near the end of a page,
          we've detected a problematic branch. */
          if (succeed && NIA > CIA) {
@@ -1479,7 +1478,6 @@ void::function::invalid_zero_divide_operation:cpu *processor, unsigned_word cia,
              program_interrupt(processor, cia, mpc860c0_instruction_program_interrupt);
          }
        }
-       #endif // WITH_OPTION_MPC860C0
        if (CURRENT_MODEL_ISSUE > 0)
          model_branches(cpu_model(processor), succeed, BO);
        if (! BO{0}) {
@@ -1513,8 +1511,7 @@ void::function::invalid_zero_divide_operation:cpu *processor, unsigned_word cia,
        else
          succeed = 0;
        if (LK) LR = (spreg)IEA(CIA + 4);
-       #ifdef WITH_OPTION_MPC860C0
-       if (option_mpc860c0 && (BO{0} && BO{2} || !BO{4})) {
+       if (option_mpc860c0 && (!BO{0} || !BO{2}) && !BO{4}) {
          /* This branch is predicted as not-taken.
          If this is a forward branch and it is near the end of a page,
          we've detected a problematic branch. */
@@ -1523,7 +1520,6 @@ void::function::invalid_zero_divide_operation:cpu *processor, unsigned_word cia,
              program_interrupt(processor, cia, mpc860c0_instruction_program_interrupt);
          }
        }
-       #endif // WITH_OPTION_MPC860C0
        if (CURRENT_MODEL_ISSUE > 0) {
          model_branches(cpu_model(processor), succeed, BO);
          if (! BO{0})
@@ -1546,8 +1542,7 @@ void::function::invalid_zero_divide_operation:cpu *processor, unsigned_word cia,
        else
          succeed = 0;
        if (LK) LR = (spreg)IEA(CIA + 4);
-       #ifdef WITH_OPTION_MPC860C0
-       if (option_mpc860c0 && (BO{0} && BO{2} || !BO{4})) {
+       if (option_mpc860c0 && (!BO{0} || !BO{2}) && !BO{4}) {
          /* This branch is predicted as not-taken.
          If this is a forward branch and it is near the end of a page,
          we've detected a problematic branch. */
@@ -1556,7 +1551,6 @@ void::function::invalid_zero_divide_operation:cpu *processor, unsigned_word cia,
              program_interrupt(processor, cia, mpc860c0_instruction_program_interrupt);
          }
        }
-       #endif // WITH_OPTION_MPC860C0
        if (CURRENT_MODEL_ISSUE > 0) {
          model_branches(cpu_model(processor), succeed, BO);
          if (! BO{0})
index 81e54b0adf973477d9b28d83bbf592228001e658..20d843b80bf3280b4263444bc6a5e58f51bf8629 100644 (file)
@@ -220,7 +220,7 @@ psim_usage(int verbose)
 }
 
 /* Test "string" for containing a string of digits that form a number
-between "min" and "max".  The return value is the number of "err". */
+between "min" and "max".  The return value is the number or "err". */
 static
 int is_num( char *string, int min, int max, int err)
 {
@@ -316,7 +316,6 @@ psim_options(device *root,
        break;
       case 'o':
        param = find_arg("Missing <dev-spec> option for -o\n", &argp, argv);
-#ifdef WITH_OPTION_MPC860C0
        if (memcmp(param, "mpc860c0", 8) == 0)
         {
           if (param[8] == '\0')
@@ -328,7 +327,6 @@ psim_options(device *root,
           else error("Invalid mpc860c0 option for -o\n");
         }
        else
-#endif // WITH_OPTION_MPC860C0
           current = tree_parse(current, "%s", param);
        break;
       case 'r':
@@ -354,9 +352,10 @@ psim_options(device *root,
               NULL, 0,
               device_ioctl_set_trace);
 
-#ifdef WITH_OPTION_MPC860C0
-  semantic_init(root);
-#endif // WITH_OPTION_MPC860C0
+  {
+    void semantic_init(device* root);
+    semantic_init(root);
+  }
 
   /* return where the options end */
   return argv + argp;
index bb845397152c318dbbaf02450eb95848d5e2e0a3..15df3c50d01e495a1e280d29a9c17e02cf0434d7 100644 (file)
 #include "callback.h"
 #include "remote-sim.h"
 
+/* Define the rate at which the simulator should poll the host
+   for a quit. */
+#ifndef POLL_QUIT_INTERVAL
+#define POLL_QUIT_INTERVAL 0x20
+#endif
+
+static int poll_quit_count = POLL_QUIT_INTERVAL;
 
 /* Structures used by the simulator, for gdb just have static structures */
 
@@ -324,8 +331,9 @@ sim_do_command (SIM_DESC sd, char *cmd)
 void
 sim_io_poll_quit (void)
 {
-  if (callbacks->poll_quit != NULL)
+  if (callbacks->poll_quit != NULL && poll_quit_count-- < 0)
     {
+      poll_quit_count = POLL_QUIT_INTERVAL;
       if (callbacks->poll_quit (callbacks))
        psim_stop (simulator);
     }
index 1939d18805aba124962d1e7e3ad258948b1126db..61de57b73f5a155ee80e946f5120b090183d9a0e 100644 (file)
@@ -1,3 +1,10 @@
+1999-04-02  Keith Seitz  <keiths@cygnus.com>
+
+       * interp.c (POLL_QUIT_INTERVAL): Define. Used to tweak the
+       frequency at which the poll_quit callback is called.
+       (sim_resume): Use POLL_QUIT_INTERVAL instead of a
+       hard-coded value.
+
 Thu Sep 10 02:16:39 1997  J"orn Rennecke <amylaar@cygnus.co.uk>
 
        * interp.c (saved_state.asregs): Add new member pad_dummy.
@@ -143,16 +150,51 @@ Mon Jun 23 15:49:14 1997  Andrew Cagney  <cagney@b1.cygnus.com>
        FP's around.
        (set_dr): Ditto.
        
+Mon Jun 23 15:02:40 1997  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * interp.c (XD, SET_XD): Delete.
+       (XF, SET_XF, XD_TO_XF): Define, move around registers in either
+       FP bank.
+       
+       * gencode.c (fmov): Update.
+
 Sun Jun 22 19:33:33 1997  Andrew Cagney  <cagney@b1.cygnus.com>
 
        * interp.c (set_fpscr1): From J"orn Rennecke
        <amylaar@cygnus.co.uk>, Fix typo. Ditto for comment.
        
+Tue Aug 12 00:19:11 1997  J"orn Rennecke <amylaar@cygnus.co.uk>
+
+       * interp.c (special_address): New function.
+       (BUSERROR): Call it.  Added parameters bits_written and data.
+       Changed all callers.
+       * gencode.c (tab): Fixed ocbwb and pref.
+
+Fri Jun 20 22:03:18 1997  J"orn Rennecke <amylaar@cygnus.co.uk>
+
+       * interp.c (do_wdat, do_wdat): Fix bug in register number calculation.
+
 Thu Jun 19 00:28:08 1997  Andrew Cagney  <cagney@b1.cygnus.com>
 
        * interp.c (sim_create_inferior): Clear registers each time an
        inferior is started.
 
+Mon Jun 16 14:01:55 1997  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * interp.c (*FP, FP_OP, FP_CMP, FP_UNARY): Provide a hook for
+       when a host doesn't support IEEE FP.
+       (*DP): Provide alternative definition that supports 64bit floating
+       point.
+       (target_little_endian): Combine little_endian and little_endian_p.
+       (saved_state_type): Make fpscr and sr simple integers.
+       (SET_FPSCR, GET_FPSCR): Use macros to update fpscr register.
+       (set_fpscr1): New function.  Handle swapping when PR / FR bits
+       changed. Call via *_FPSCR macro.
+       (SET_SR*, GET_SR*): Use macro's to access the SR bits - avoids
+       endian problems.
+
+       * gencode.c (tab): Update.
+       
 Sun Jun 15 15:22:52 1997  Andrew Cagney  <cagney@b1.cygnus.com>
 
        * gencode.c (main): Perform basic checks on tab entries.
@@ -185,10 +227,22 @@ Fri Jun 13 15:33:53 1997  J"orn Rennecke <amylaar@cygnus.co.uk>
 
        * interp.c (init_pointers): Fix little endian test.
 
+Thu Jun  5 12:56:08 1997  J"orn Rennecke <amylaar@cygnus.co.uk>
+
+       * interp.c (init_pointers): SH4 hardware is always WORDS_BIT_ENDIAN.
+       * gencode (fmov from/to memory): take endian_mismatch into account
+       for 32 bit moves too.
+
 Wed May 28 23:42:35 1997  J"orn Rennecke <amylaar@cygnus.co.uk>
 
         * gencode.c (swap.b): Fix treatment of high word.
 
+Wed May 28 23:42:35 1997  J"orn Rennecke <amylaar@cygnus.co.uk>
+
+        * sh/gencode.c,
+        * interp.c: experimental SH4 support.
+        DFmode moves are probaly broken for target little endian.
+
 Tue May 20 10:23:28 1997  Andrew Cagney  <cagney@b1.cygnus.com>
 
        * interp.c (sim_open): Add callback argument.
index 338b934428796f4b177353deeef57ca4259e1bfd..be10e59c28032b5517ff26ce273c8074b9a6b371 100644 (file)
@@ -244,12 +244,43 @@ op tab[] =
     "FP_CMP (n, >, m);",
   },
 
+  /* sh4 */
+  { "", "", "fcnvds <DR_N>,FPUL", "1111nnnn10111101",
+    "if (! FPSCR_PR || n & 1)",
+    "  saved_state.asregs.exception = SIGILL;",
+    "else",
+    "{",
+    "  char buf[4];",
+    "  *(float *)buf = DR(n);",
+    "  FPUL = *(int *)buf;",
+    "}",
+  },
+
+  /* sh4 */
+  { "", "", "fcnvsd FPUL,<DR_N>", "1111nnnn10101101",
+    "if (! FPSCR_PR || n & 1)",
+    "  saved_state.asregs.exception = SIGILL;",
+    "else",
+    "{",
+    "  char buf[4];",
+    "  *(int *)buf = FPUL;",
+    "  SET_DR(n, *(float *)buf);",
+    "}",
+  },
+
   /* sh3e */
   { "", "", "fdiv <FREG_M>,<FREG_N>", "1111nnnnmmmm0011",
     "FP_OP (n, /, m);",
     "/* FIXME: check for DP and (n & 1) == 0? */",
   },
 
+  /* sh4 */
+  { "", "", "fipr <FV_M>,<FV_N>", "1111nnmm11101101",
+    "/* FIXME: not implemented */",
+    "saved_state.asregs.exception = SIGILL;",
+    "/* FIXME: check for DP and (n & 1) == 0? */",
+  },
+
   /* sh3e */
   { "", "", "fldi0 <FREG_N>", "1111nnnn10001101",
     "SET_FR (n, (float)0.0);",
@@ -271,6 +302,10 @@ op tab[] =
 
   /* sh3e */
   { "", "", "float FPUL,<FREG_N>", "1111nnnn00101101",
+    /* sh4 */
+    "if (FPSCR_PR)",
+    "  SET_DR (n, (double)FPUL);",
+    "else",
     "{",
     "  SET_FR (n, (float)FPUL);",
     "}",
@@ -284,12 +319,26 @@ op tab[] =
 
   /* sh3e */
   { "", "", "fmov <FREG_M>,<FREG_N>", "1111nnnnmmmm1100",
+    /* sh4 */
+    "if (FPSCR_SZ) {",
+    "  int ni = XD_TO_XF (n);",
+    "  int mi = XD_TO_XF (m);",
+    "  SET_XF (ni + 0, XF (mi + 0));",
+    "  SET_XF (ni + 1, XF (mi + 1));",
+    "}",
+    "else",
     "{",
     "  SET_FR (n, FR (m));",
     "}",
   },
   /* sh3e */
   { "", "", "fmov.s <FREG_M>,@<REG_N>", "1111nnnnmmmm1010",
+    /* sh4 */
+    "if (FPSCR_SZ) {",
+    "  MA (2);",
+    "  WDAT (R[n], m);",
+    "}",
+    "else",
     "{",
     "  MA (1);",
     "  WLAT (R[n], FI(m));",
@@ -297,6 +346,12 @@ op tab[] =
   },
   /* sh3e */
   { "", "", "fmov.s @<REG_M>,<FREG_N>", "1111nnnnmmmm1000",
+    /* sh4 */
+    "if (FPSCR_SZ) {",
+    "  MA (2);",
+    "  RDAT (R[m], n);",
+    "}",
+    "else",
     "{",
     "  MA (1);",
     "  SET_FI(n, RLAT(R[m]));",
@@ -304,6 +359,13 @@ op tab[] =
   },
   /* sh3e */
   { "", "", "fmov.s @<REG_M>+,<FREG_N>", "1111nnnnmmmm1001",
+    /* sh4 */
+    "if (FPSCR_SZ) {",
+    "  MA (2);",
+    "  RDAT (R[m], n);",
+    "  R[m] += 8;",
+    "}",
+    "else",
     "{",
     "  MA (1);",
     "  SET_FI (n, RLAT (R[m]));",
@@ -312,6 +374,13 @@ op tab[] =
   },
   /* sh3e */
   { "", "", "fmov.s <FREG_M>,@-<REG_N>", "1111nnnnmmmm1011",
+    /* sh4 */
+    "if (FPSCR_SZ) {",
+    "  MA (2);",
+    "  R[n] -= 8;",
+    "  WDAT (R[n], m);",
+    "}",
+    "else",
     "{",
     "  MA (1);",
     "  R[n] -= 4;",
@@ -320,6 +389,12 @@ op tab[] =
   },
   /* sh3e */
   { "", "", "fmov.s @(R0,<REG_M>),<FREG_N>", "1111nnnnmmmm0110",
+    /* sh4 */
+    "if (FPSCR_SZ) {",
+    "  MA (2);",
+    "  RDAT (R[0]+R[m], n);",
+    "}",
+    "else",
     "{",
     "  MA (1);",
     "  SET_FI(n, RLAT(R[0] + R[m]));",
@@ -327,12 +402,20 @@ op tab[] =
   },
   /* sh3e */
   { "", "", "fmov.s <FREG_M>,@(R0,<REG_N>)", "1111nnnnmmmm0111",
+    /* sh4 */
+    "if (FPSCR_SZ) {",
+    "  MA (2);",
+    "  WDAT (R[0]+R[n], m);",
+    "}",
+    "else",
     "{",
     "  MA (1);",
     "  WLAT((R[0]+R[n]), FI(m));",
     "}",
   },
 
+  /* sh4: See fmov instructions above for move to/from extended fp registers */
+
   /* sh3e */
   { "", "", "fmul <FREG_M>,<FREG_N>", "1111nnnnmmmm0010",
     "FP_OP(n, *, m);",
@@ -343,6 +426,16 @@ op tab[] =
     "FP_UNARY(n, -);",
   },
 
+  /* sh4 */
+  { "", "", "frchg", "1111101111111101",
+    "SET_FPSCR (GET_FPSCR() ^ FPSCR_MASK_FR);",
+  },
+
+  /* sh4 */
+  { "", "", "fschg", "1111001111111101",
+    "SET_FPSCR (GET_FPSCR() ^ FPSCR_MASK_SZ);",
+  },
+
   /* sh3e */
   { "", "", "fsqrt <FREG_N>", "1111nnnn01101101",
     "FP_UNARY(n, sqrt);",
@@ -355,16 +448,20 @@ op tab[] =
 
   /* sh3e */
   { "", "", "ftrc <FREG_N>, FPUL", "1111nnnn00111101",
+    /* sh4 */
+    "if (FPSCR_PR) {",
+    "  if (DR(n) != DR(n)) /* NaN */",
+    "    FPUL = 0x80000000;",
+    "  else",
+    "    FPUL =  (int)DR(n);",
+    "}",
+    "else",
     "if (FR(n) != FR(n)) /* NaN */",
     "  FPUL = 0x80000000;",
     "else",
     "  FPUL = (int)FR(n);",
   },
 
-  /* sh3e */
-  { "", "", "ftst/nan <FREG_N>", "1111nnnn01111101",
-    "SET_SR_T (isnan (FR(n)));",
-  },
   /* sh3e */
   { "", "", "fsts FPUL,<FREG_N>", "1111nnnn00001101",
     "char buf[4];",
@@ -405,6 +502,12 @@ op tab[] =
     "SPC = R[n];",
     "/* FIXME: user mode */",
   },
+#if 0
+  { "", "n", "ldc <REG_N>,DBR", "0100nnnn11111010",
+    "DBR = R[n];",
+    "/* FIXME: user mode */",
+  },
+#endif
   { "", "n", "ldc <REG_N>,R0_BANK", "0100nnnn10001110",
     "SET_Rn_BANK (0, R[n]);",
     "/* FIXME: user mode */",
@@ -467,6 +570,14 @@ op tab[] =
     "R[n] += 4;",
     "/* FIXME: user mode */",
   },
+#if 0
+  { "", "n", "ldc.l @<REG_N>+,DBR", "0100nnnn11110110",
+    "MA (1);",
+    "DBR = RLAT (R[n]);",
+    "R[n] += 4;",
+    "/* FIXME: user mode */",
+  },
+#endif
   { "", "n", "ldc.l @<REG_N>+,R0_BANK", "0100nnnn10000111",
     "MA (1);",
     "SET_Rn_BANK (0, RLAT (R[n]));",
@@ -740,6 +851,11 @@ op tab[] =
     "R0 = ((i + 4 + PC) & ~0x3);",
   },
 
+  { "0", "", "movca.l @R0, <REG_N>", "0000nnnn11000011",
+    "/* FIXME: Not implemented */",
+    "saved_state.asregs.exception = SIGILL;",
+  },
+
   { "n", "", "movt <REG_N>", "0000nnnn00101001",
     "R[n] = T;",
   },
@@ -783,6 +899,21 @@ op tab[] =
     "R[n] = ~R[m];",
   },
 
+  { "0", "", "ocbi @<REG_N>", "0000nnnn10010011",
+    "/* FIXME: Not implemented */",
+    "saved_state.asregs.exception = SIGILL;",
+  },
+
+  { "0", "", "ocbp @<REG_N>", "0000nnnn10100011",
+    "/* FIXME: Not implemented */",
+    "saved_state.asregs.exception = SIGILL;",
+  },
+
+  { "", "n", "ocbwb @<REG_N>", "0000nnnn10110011",
+    "RSBAT (R[n]); /* Take exceptions like byte load.  */",
+    "/* FIXME: Cache not implemented */",
+  },
+
   { "0", "", "or #<imm>,R0", "11001011i8*1....",
     "R0 |= i;",
   },
@@ -920,6 +1051,14 @@ op tab[] =
   { "n", "", "stc SPC,<REG_N>", "0000nnnn01000010",
     "R[n] = SPC;",
   },
+#if 0
+  { "n", "", "stc SGR,<REG_N>", "0000nnnn00111010",
+    "R[n] = SGR;",
+  },
+  { "n", "", "stc DBR,<REG_N>", "0000nnnn11111010",
+    "R[n] = DBR;",
+  },
+#endif
   { "n", "", "stc R0_BANK,<REG_N>", "0000nnnn10000010",
     "R[n] = Rn_BANK (0);",
   },
@@ -969,6 +1108,18 @@ op tab[] =
     "R[n] -= 4;",
     "WLAT (R[n], SPC);",
   },
+#if 0
+  { "n", "n", "stc.l SGR,@-<REG_N>", "0100nnnn00110010",
+    "MA (1);",
+    "R[n] -= 4;",
+    "WLAT (R[n], SGR);",
+  },
+  { "n", "n", "stc.l DBR,@-<REG_N>", "0100nnnn11110010",
+    "MA (1);",
+    "R[n] -= 4;",
+    "WLAT (R[n], DBR);",
+  },
+#endif
   { "n", "", "stc R0_BANK,@-<REG_N>", "0100nnnn10000010",
     "MA (1);",
     "R[n] -= 4;",
@@ -1153,6 +1304,15 @@ op tab[] =
     "        | ((R[m] << 16) & 0xffff0000));",
   },
 
+#if 0
+  { "divs.l <REG_M>,<REG_N>", "0100nnnnmmmm1110",
+    "divl(0,R[n],R[m]);",
+  },
+  { "divu.l <REG_M>,<REG_N>", "0100nnnnmmmm1101",
+    "divl(0,R[n],R[m]);",
+  },
+#endif
+
   {0, 0}};
 
 /* Tables of things to put into enums for sh-opc.h */
index bd26967b1521f42c15fa0eccbaee28d2f406e37e..4d7c5cf4399bf6d27fa2616cf116be74964822c5 100644 (file)
 #define DEFINE_TABLE
 #define DISASSEMBLER_TABLE
 
+/* Define the rate at which the simulator should poll the host
+   for a quit. */
+#define POLL_QUIT_INTERVAL 0x60000
+
 typedef union
 {
 
   struct
   {
+    /* On targets like sparc-sun-solaris, fregs will be aligned on a 64 bit
+       boundary (because of the d member).  To avoid padding between
+       registers - which whould make the job of sim_fetch_register harder,
+       we add padding at the start.  */
     int pad_dummy;
     int regs[16];
     int pc;
@@ -84,7 +92,7 @@ typedef union
        double d[8];
        int i[16];
       }
-    fregs;
+    fregs[2];
 
     int ssr;
     int spc;
@@ -221,9 +229,34 @@ set_sr (new_sr)
 
 /* Manipulate FPSCR */
 
-#define set_fpscr1(x)
-#define SET_FPSCR(x) (saved_state.asregs.fpscr = (x))
+#define FPSCR_MASK_FR (1 << 21)
+#define FPSCR_MASK_SZ (1 << 20)
+#define FPSCR_MASK_PR (1 << 19)
+
+#define FPSCR_FR  ((GET_FPSCR() & FPSCR_MASK_FR) != 0)
+#define FPSCR_SZ  ((GET_FPSCR() & FPSCR_MASK_SZ) != 0)
+#define FPSCR_PR  ((GET_FPSCR() & FPSCR_MASK_PR) != 0)
+
+static void
+set_fpscr1 (x)
+       int x;
+{
+  int old = saved_state.asregs.fpscr;
+  saved_state.asregs.fpscr = (x);
+  /* swap the floating point register banks */
+  if ((saved_state.asregs.fpscr ^ old) & FPSCR_MASK_FR)
+    {
+      union fregs_u tmpf = saved_state.asregs.fregs[0];
+      saved_state.asregs.fregs[0] = saved_state.asregs.fregs[1];
+      saved_state.asregs.fregs[1] = tmpf;
+    }
+}
+
 #define GET_FPSCR()  (saved_state.asregs.fpscr)
+#define SET_FPSCR(x) \
+do { \
+  set_fpscr1 (x); \
+} while (0)
 
 
 int 
@@ -232,6 +265,21 @@ fail ()
   abort ();
 }
 
+int
+special_address (addr, bits_written, data)
+     void *addr;
+     int bits_written, data;
+{
+  if ((unsigned) addr >> 24 == 0xf0 && bits_written == 32 && (data & 1) == 0)
+    /* This invalidates (if not associative) or might invalidate
+       (if associative) an instruction cache line.  This is used for
+       trampolines.  Since we don't simulate the cache, this is a no-op
+       as far as the simulator is concerned.  */
+    return 1;
+  /* We can't do anything useful with the other stuff, so fail.  */
+  return 0;
+}
+
 /* This function exists solely for the purpose of setting a breakpoint to
    catch simulated bus errors when running the simulator under GDB.  */
 
@@ -244,8 +292,14 @@ bp_holder ()
    being implemented by ../common/sim_resume.c and the below should
    make a call to sim_engine_halt */
 
-#define BUSERROR(addr, mask) \
-  if (addr & ~mask) { saved_state.asregs.exception = SIGBUS;  bp_holder (); }
+#define BUSERROR(addr, mask, bits_written, data) \
+  if (addr & ~mask) \
+    { \
+      if (special_address (addr, bits_written, data)) \
+       return; \
+      saved_state.asregs.exception = SIGBUS; \
+      bp_holder (); \
+    }
 
 /* Define this to enable register lifetime checking.
    The compiler generates "add #0,rn" insns to mark registers as invalid,
@@ -276,15 +330,98 @@ static host_callback *callback;
 
 /* Floating point registers */
 
-#define FI(n) (saved_state.asregs.fregs.i[(n)])
-#define FR(n) (saved_state.asregs.fregs.f[(n)])
+#define DR(n) (get_dr (n))
+static double
+get_dr (n)
+     int n;
+{
+  n = (n & ~1);
+  if (host_little_endian)
+    {
+      union
+      {
+       int i[2];
+       double d;
+      } dr;
+      dr.i[1] = saved_state.asregs.fregs[0].i[n + 0];
+      dr.i[0] = saved_state.asregs.fregs[0].i[n + 1];
+      return dr.d;
+    }
+  else
+    return (saved_state.asregs.fregs[0].d[n >> 1]);
+}
+
+#define SET_DR(n, EXP) set_dr ((n), (EXP))
+static void
+set_dr (n, exp)
+     int n;
+     double exp;
+{
+  n = (n & ~1);
+  if (host_little_endian)
+    {
+      union
+      {
+       int i[2];
+       double d;
+      } dr;
+      dr.d = exp;
+      saved_state.asregs.fregs[0].i[n + 0] = dr.i[1];
+      saved_state.asregs.fregs[0].i[n + 1] = dr.i[0];
+    }
+  else
+    saved_state.asregs.fregs[0].d[n >> 1] = exp;
+}
+
+#define SET_FI(n,EXP) (saved_state.asregs.fregs[0].i[(n)] = (EXP))
+#define FI(n) (saved_state.asregs.fregs[0].i[(n)])
 
-#define SET_FI(n,EXP) (saved_state.asregs.fregs.i[(n)] = (EXP))
-#define SET_FR(n,EXP) (saved_state.asregs.fregs.f[(n)] = (EXP))
+#define FR(n) (saved_state.asregs.fregs[0].f[(n)])
+#define SET_FR(n,EXP) (saved_state.asregs.fregs[0].f[(n)] = (EXP))
 
-#define FP_OP(n, OP, m) (SET_FR(n, (FR(n) OP FR(m))))
-#define FP_UNARY(n, OP) (SET_FR(n, (OP (FR(n)))))
-#define FP_CMP(n, OP, m) SET_SR_T(FR(n) OP FR(m))
+#define XD_TO_XF(n) ((((n) & 1) << 5) | ((n) & 0x1e))
+#define XF(n) (saved_state.asregs.fregs[(n) >> 5].i[(n) & 0x1f])
+#define SET_XF(n,EXP) (saved_state.asregs.fregs[(n) >> 5].i[(n) & 0x1f] = (EXP))
+
+
+#define FP_OP(n, OP, m) \
+{ \
+  if (FPSCR_PR) \
+    { \
+      if (((n) & 1) || ((m) & 1)) \
+       saved_state.asregs.exception = SIGILL; \
+      else \
+       SET_DR(n, (DR(n) OP DR(m))); \
+    } \
+  else \
+    SET_FR(n, (FR(n) OP FR(m))); \
+} while (0)
+
+#define FP_UNARY(n, OP) \
+{ \
+  if (FPSCR_PR) \
+    { \
+      if ((n) & 1) \
+       saved_state.asregs.exception = SIGILL; \
+      else \
+       SET_DR(n, (OP (DR(n)))); \
+    } \
+  else \
+    SET_FR(n, (OP (FR(n)))); \
+} while (0)
+
+#define FP_CMP(n, OP, m) \
+{ \
+  if (FPSCR_PR) \
+    { \
+      if (((n) & 1) || ((m) & 1)) \
+       saved_state.asregs.exception = SIGILL; \
+      else \
+       SET_SR_T (DR(n) OP DR(m)); \
+    } \
+  else \
+    SET_SR_T (FR(n) OP FR(m)); \
+} while (0)
 
 
 
@@ -294,7 +431,7 @@ wlat_little (memory, x, value, maskl)
 {
   int v = value;
   unsigned char *p = memory + ((x) & maskl);
-  BUSERROR(x, maskl);
+  BUSERROR(x, maskl, 32, v);
   p[3] = v >> 24;
   p[2] = v >> 16;
   p[1] = v >> 8;
@@ -307,7 +444,7 @@ wwat_little (memory, x, value, maskw)
 {
   int v = value;
   unsigned char *p = memory + ((x) & maskw);
-  BUSERROR(x, maskw);
+  BUSERROR(x, maskw, 16, v);
 
   p[1] = v >> 8;
   p[0] = v;
@@ -320,7 +457,7 @@ wbat_any (memory, x, value, maskb)
   unsigned char *p = memory + (x & maskb);
   if (x > 0x5000000)
     IOMEM (x, 1, value);
-  BUSERROR(x, maskb);
+  BUSERROR(x, maskb, 8, value);
 
   p[0] = value;
 }
@@ -331,7 +468,7 @@ wlat_big (memory, x, value, maskl)
 {
   int v = value;
   unsigned char *p = memory + ((x) & maskl);
-  BUSERROR(x, maskl);
+  BUSERROR(x, maskl, 32, v);
 
   p[0] = v >> 24;
   p[1] = v >> 16;
@@ -345,7 +482,7 @@ wwat_big (memory, x, value, maskw)
 {
   int v = value;
   unsigned char *p = memory + ((x) & maskw);
-  BUSERROR(x, maskw);
+  BUSERROR(x, maskw, 16, v);
 
   p[0] = v >> 8;
   p[1] = v;
@@ -356,7 +493,7 @@ wbat_big (memory, x, value, maskb)
      unsigned char *memory;
 {
   unsigned char *p = memory + (x & maskb);
-  BUSERROR(x, maskb);
+  BUSERROR(x, maskb, 8, value);
 
   if (x > 0x5000000)
     IOMEM (x, 1, value);
@@ -370,7 +507,7 @@ rlat_little (memory, x, maskl)
      unsigned char *memory;
 {
   unsigned char *p = memory + ((x) & maskl);
-  BUSERROR(x, maskl);
+  BUSERROR(x, maskl, -32, -1);
 
   return (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
 }
@@ -380,7 +517,7 @@ rwat_little (memory, x, maskw)
      unsigned char *memory;
 {
   unsigned char *p = memory + ((x) & maskw);
-  BUSERROR(x, maskw);
+  BUSERROR(x, maskw, -16, -1);
 
   return (p[1] << 8) | p[0];
 }
@@ -390,7 +527,7 @@ rbat_any (memory, x, maskb)
      unsigned char *memory;
 {
   unsigned char *p = memory + ((x) & maskb);
-  BUSERROR(x, maskb);
+  BUSERROR(x, maskb, -8, -1);
 
   return p[0];
 }
@@ -400,7 +537,7 @@ rlat_big (memory, x, maskl)
      unsigned char *memory;
 {
   unsigned char *p = memory + ((x) & maskl);
-  BUSERROR(x, maskl);
+  BUSERROR(x, maskl, -32, -1);
 
   return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 }
@@ -410,7 +547,7 @@ rwat_big (memory, x, maskw)
      unsigned char *memory;
 {
   unsigned char *p = memory + ((x) & maskw);
-  BUSERROR(x, maskw);
+  BUSERROR(x, maskw, -16, -1);
 
   return (p[0] << 8) | p[1];
 }
@@ -426,7 +563,59 @@ rwat_big (memory, x, maskw)
 #define RSWAT(x)  ((short)(RWAT(x)))
 #define RSBAT(x)  (SEXT(RBAT(x)))
 
+#define RDAT(x, n) (do_rdat (memory, (x), (n), (little_endian)))
+static int
+do_rdat (memory, x, n, little_endian)
+     char *memory;
+     int x;
+     int n;
+     int little_endian;
+{
+  int f0;
+  int f1;
+  int i = (n & 1);
+  int j = (n & ~1);
+  if (little_endian)
+    {
+      f0 = rlat_little (memory, x + 0, maskl);
+      f1 = rlat_little (memory, x + 4, maskl);
+    }
+  else
+    {
+      f0 = rlat_big (memory, x + 0, maskl);
+      f1 = rlat_big (memory, x + 4, maskl);
+    }
+  saved_state.asregs.fregs[i].i[(j + 0)] = f0;
+  saved_state.asregs.fregs[i].i[(j + 1)] = f1;
+  return 0;
+}
 
+#define WDAT(x, n) (do_wdat (memory, (x), (n), (little_endian)))
+static int
+do_wdat (memory, x, n, little_endian)
+     char *memory;
+     int x;
+     int n;
+     int little_endian;
+{
+  int f0;
+  int f1;
+  int i = (n & 1);
+  int j = (n & ~1);
+  f0 = saved_state.asregs.fregs[i].i[(j + 0)];
+  f1 = saved_state.asregs.fregs[i].i[(j + 1)];
+  if (little_endian)
+    {
+      wlat_little (memory, (x + 0), f0, maskl);
+      wlat_little (memory, (x + 4), f1, maskl);
+    }
+  else
+    {
+      wlat_big (memory, (x + 0), f0, maskl);
+      wlat_big (memory, (x + 4), f1, maskl);
+    }
+  return 0;
+}
 
 
 #define MA(n) do { memstalls += (((pc & 3) != 0) ? (n) : ((n) - 1)); } while (0)
@@ -1070,7 +1259,7 @@ sim_resume (sd, step, siggnal)
 
       if (--pollcount < 0)
        {
-         pollcount = 1000;
+         pollcount = POLL_QUIT_INTERVAL;
          if ((*callback->poll_quit) != NULL
              && (*callback->poll_quit) (callback))
            {
index f86348293940f17a9ce92f585ba8d7303b0c49a7..953d2a4f50af4a8e5c331f9c894dd39c8a688432 100644 (file)
@@ -1,3 +1,15 @@
+1999-04-21  Doug Evans  <devans@casey.cygnus.com>
+
+       * sim/m32r/nop.cgs: Add missing nop insn.
+
+Mon Mar 22 13:28:56 1999  Dave Brolley  <brolley@cygnus.com>
+
+       * sim/fr30/stb.cgs: Correct for unaligned access.
+       * sim/fr30/sth.cgs: Correct for unaligned access.
+       * sim/fr30/ldub.cgs: Fix typo: lduh->ldub. Correct
+       for unaligned access.
+       * sim/fr30/and.cgs: Test unaligned access.
+
 Fri Feb  5 12:41:11 1999  Doug Evans  <devans@canuck.cygnus.com>
 
        * lib/sim-defs.exp (sim_run): Print simulator arguments log message.
@@ -140,6 +152,11 @@ Tue Sep 15 14:56:22 1998  Doug Evans  <devans@canuck.cygnus.com>
        * sim/m32r/rte.cgs: Test bbpc,bbpsw.
        * sim/m32r/trap.cgs: Test bbpc,bbpsw.
 
+Fri Jul 31 17:49:13 1998  Felix Lee  <flee@cygnus.com>
+
+       * lib/sim-defs.exp (sim_run): remote_spawn, use writeto instead of
+       writeonly.
+
 Fri Jul 24 09:40:34 1998  Doug Evans  <devans@canuck.cygnus.com>
 
        * Makefile.in (clean,mostlyclean): Change leading spaces to a tab.
@@ -148,6 +165,15 @@ Wed Jul  1 15:57:54 1998  Doug Evans  <devans@seba.cygnus.com>
 
        * sim/m32r/hw-trap.ms: New testcase.
 
+Tue Jun 16 15:44:01 1998 Jillian Ye <jillian@cygnus.com>
+
+       * lib/sim-defs.exp: Print out timeout setting info when "-v" is used.
+
+Thu Jun 11 15:24:53 1998  Doug Evans  <devans@canuck.cygnus.com>
+
+       * lib/sim-defs.exp (sim_run): Argument env_vals renamed to options,
+       which is now a list of options controlling the behaviour of sim_run.
+
 Wed Jun 10 10:53:20 1998  Doug Evans  <devans@seba.cygnus.com>
 
        * sim/m32r/addx.cgs: Add another test.
index 6d8369f432b2abb8865d5489250f33c3c5381aa5..98e5877e96d081424543bca01217fb137806d4d2 100644 (file)
@@ -1,3 +1,7 @@
+1999-03-17  Frank Ch. Eigler  <fche@cygnus.com>
+
+       * do-flags.S: Added new test for non-lkr status of MVTSYS.
+
 1999-01-12  Frank Ch. Eigler  <fche@cygnus.com>
 
        * do-flags.S: Added one old, one new regression test.
index 25797e503594aa8d4a76f5b8a9b4fe10cc56b675..f8a15cf16b00ccd92dc2810f656fb70ee037de48 100644 (file)
        assert r60, 0x80000000
        assert r61, 0x80000000
        
-                       
-                                                       
+
+       # PR 19224
+
+       add r7,r0,0x80000000
+       add r2,r0,r0            || nop
+       add r1,r0,0x1           || nop
+       # confirm that these insns do not kill the add in the right container
+       mvtsys psw,r7           -> add r2,r2,r1
+       mvtsys pswh,r7          -> add r2,r2,r1
+       mvtsys pswl,r7          -> add r2,r2,r1 
+       mvtsys f0,r7            -> add r2,r2,r1                 
+       mvtsys mod_s,r7         -> add r2,r2,r1                                                 
+
+       assert r2, 0x5
+
+                                                                       
        # all okay
 
        bra     ok
index 49db6fd2ee10040ce862d51755ca446eddf4e30b..3148a3119156e99bd56443cbcb9ece459c945dd8 100644 (file)
@@ -42,10 +42,16 @@ and:
        test_cc         1 0 0 0
        test_h_mem      0xaaaa0000,sp
 
-       mvi_h_mem       0xffff,sp
-       set_cc          0x0d            ; Set mask opposite of expected
+       mvr_h_gr        sp,r9
+       inci_h_gr       4,r9
+       mvi_h_mem       0xffffffff,sp
+       mvi_h_mem       0xffff0000,r9
+       inci_h_gr       1,sp            ; test unaligned access
+       set_cc          0x05            ; Set mask opposite of expected
        and             r7,@sp
-       test_cc         0 0 0 1
-       test_h_mem      0xaaaa,sp
+       test_cc         1 0 0 1
+       inci_h_gr       -1,sp
+       test_h_mem      0xaaaaaaaa,sp
+       test_h_mem      0xffff0000,r9
 
        pass
index 97e00d9e00a1609c02454269b013bf8ba5881ecf..8d42cfa8595e17fb36110f932686a25949d59211 100644 (file)
@@ -84,31 +84,31 @@ ldub:
        add_h_gr        r8,r14
 
        set_cc          0x0f            ; condition codes should not change
-       lduh            @(r14,0x7f),r7
+       ldub            @(r14,0x7f),r7
        test_cc         1 1 1 1
        test_h_gr       0xde,r7
 
-       inci_h_gr       0x3e,r14
+       inci_h_gr       0x3f,r14
        set_cc          0x07            ; condition codes should not change
-       lduh            @(r14,0x40),r7
+       ldub            @(r14,0x40),r7
        test_cc         0 1 1 1
        test_h_gr       0xde,r7
 
        inci_h_gr       0x40,r14
        set_cc          0x0b            ; condition codes should not change
-       lduh            @(r14,0x0),r7
+       ldub            @(r14,0x0),r7
        test_cc         1 0 1 1
        test_h_gr       0xde,r7
 
        inci_h_gr       0x40,r14
        set_cc          0x0d            ; condition codes should not change
-       lduh            @(r14,-0x40),r7
+       ldub            @(r14,-0x40),r7
        test_cc         1 1 0 1
        test_h_gr       0xde,r7
 
        inci_h_gr       0x40,r14
        set_cc          0x0e            ; condition codes should not change
-       lduh            @(r14,-0x80),r7
+       ldub            @(r14,-0x80),r7
        test_cc         1 1 1 0
        test_h_gr       0xde,r7
 
index d9d4fd00aedc373a23a382a6d63d9e3ea3e1eaea..edbf4f22c7ea5e554f179e947e419367a4003755 100644 (file)
@@ -55,13 +55,13 @@ stb:
        mvi_h_gr        0xaaaaaafe,r8
        mvi_h_mem       0xdeadbeef,sp
        mvr_h_gr        sp,r14
-       inci_h_gr       -127,r14
+       inci_h_gr       -128,r14        ; must be aligned
+       mvi_h_mem       0xdeadbeef,r14
        mvr_h_gr        r14,r2
+       inci_h_gr       -128,r14        ; must be aligned
        mvi_h_mem       0xdeadbeef,r14
-       inci_h_gr       -128,r14
        mvr_h_gr        r14,r3
-       mvi_h_mem       0xdeadbeef,r14
-       inci_h_gr       128,r14
+       inci_h_gr       129,r14
 
        set_cc          0x0b            ; Condition codes should not change
        stb             r8,@(r14,127)
@@ -72,13 +72,13 @@ stb:
        set_cc          0x0a            ; Condition codes should not change
        stb             r8,@(r14,0)
        test_cc         1 0 1 0
-       test_h_mem      0xfeadbeef,r2
+       test_h_mem      0xdefebeef,r2
        test_h_gr       0xaaaaaafe,r8
 
        set_cc          0x09            ; Condition codes should not change
        stb             r8,@(r14,-128)
        test_cc         1 0 0 1
-       test_h_mem      0xfeadbeef,r3
+       test_h_mem      0xdefebeef,r3
        test_h_gr       0xaaaaaafe,r8
 
        pass
index 64c83e6072fc3c51c6ab6f01a67a1a08cebbfb20..8c4a1156b92cfb08c612b60781c3e28017b960b1 100644 (file)
@@ -52,33 +52,33 @@ sth:
 
        ; Test sth $Ri,@(R14,$disp9)
        mvr_h_gr        r9,sp           ; Restore stack pointer
-       mvi_h_gr        0xaaaabeef,r8
+       mvi_h_gr        0xaaaaabcd,r8
        mvi_h_mem       0xdeadbeef,sp
        mvr_h_gr        sp,r14
-       inci_h_gr       -254,r14
+       inci_h_gr       -256,r14        ; must be aligned
        mvr_h_gr        r14,r2
        mvi_h_mem       0xdeadbeef,r14
        inci_h_gr       -256,r14
        mvr_h_gr        r14,r3
        mvi_h_mem       0xdeadbeef,r14
-       inci_h_gr       256,r14
+       inci_h_gr       258,r14
 
        set_cc          0x0b            ; Condition codes should not change
        sth             r8,@(r14,254)
        test_cc         1 0 1 1
-       test_h_mem      0xbeefbeef,r1
-       test_h_gr       0xaaaabeef,r8
+       test_h_mem      0xabcdbeef,r1
+       test_h_gr       0xaaaaabcd,r8
 
        set_cc          0x0a            ; Condition codes should not change
        sth             r8,@(r14,0)
        test_cc         1 0 1 0
-       test_h_mem      0xbeefbeef,r2
-       test_h_gr       0xaaaabeef,r8
+       test_h_mem      0xdeadabcd,r2
+       test_h_gr       0xaaaaabcd,r8
 
        set_cc          0x09            ; Condition codes should not change
        sth             r8,@(r14,-256)
        test_cc         1 0 0 1
-       test_h_mem      0xbeefbeef,r3
-       test_h_gr       0xaaaabeef,r8
+       test_h_mem      0xdeadabcd,r3
+       test_h_gr       0xaaaaabcd,r8
 
        pass
index 05b44bc552d93c939f090bc310ae33d199a81022..e06d656f20eb74405191c14dc26b3b4b5dbce910 100644 (file)
@@ -7,4 +7,5 @@
 
        .global nop
 nop:
+       nop
        pass